using System.Collections.Generic;
using UnityEngine;

public class GridManager : MonoBehaviour
{
    public int tileSize = 1; // my grid is set to 32x32 and so that is 1 in unity, ok huh.
    private readonly Dictionary<string, TileGrid> _grids = new();
    private GameObject _gridParent;

    public static GridManager Instance { get; private set; }

    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
        }

        else
        {
            Destroy(gameObject);
        }
    }

    public TileGrid CreateGridForMap(string mapName, Vector2Int gridSize)
    {
        _grids[mapName] = ScriptableObject.CreateInstance<TileGrid>();
        _grids[mapName].Initialize(gridSize);
        Debug.Log("New Grid created for map: " + mapName);
        // move grid to correct position
        return _grids[mapName];
    }

    public TileGrid GetGridForMap(Map map)
    {
        if (_grids.TryGetValue(map.sceneName, out var grid)) return grid;

        Debug.LogError($"No grid found for map {map.sceneName}");
        // create a new grid with default size
        return CreateGridForMap(map.sceneName, map.gridSize);
    }

    public void AssignGridToMap(Map map, TileGrid grid)
    {
        // Load the grid for the map
        Debug.Log("Loading grid for map: " + map.sceneName);
        _grids[map.sceneName] = grid;
    }

    // Update your other methods to take a mapName parameter and operate on the correct grid
    public void LoadGrid(string currentMapSceneName, Vector3 gridPosition)
    {
        Debug.Log("GRID: Loading grid: " + currentMapSceneName);

        if (_grids.TryGetValue(currentMapSceneName, out var grid))
        {
            Debug.Log("GRID: Grid found for map: " + currentMapSceneName);
            Debug.Log("GRID: Size: " + grid.size.x + ", " + grid.size.y);

            // Create a parent object for the grid
            _gridParent = new GameObject("Grid");
            // set grid parent position from Map parent


            var mapParent = GameObject.FindGameObjectWithTag("Map");

            if (mapParent != null) _gridParent.transform.SetParent(mapParent.transform);

            Instantiate(_gridParent, new Vector3(0, 0, 0), Quaternion.identity);

            // Load the grid by looping through the grid's tiles
            for (var x = 0; x < grid.size.x; x++)
            for (var y = 0; y < grid.size.y; y++)
                if (grid.GetTile(x, y) == null)
                {
                    var interactable = PrefabManager.Instance.GetRandomCropPrefabInstance();
                    GameObject tile;
                    tile = CreateTile(new Vector2Int(x, y));
                    // set interactive as child of tile
                    interactable.transform.SetParent(tile.transform);
                    interactable.transform.position = tile.transform.position;
                    Debug.Log("GRID: Created tile at position: " + x + ", " + y);
                }

            // set tile as parent to interactable game object

            /*// Load the tile at position (x, y)
                Debug.Log("GRID: Loading tile at position: " + x + ", " + y);

                var tile = ScriptableObject.CreateInstance<Tile>();
                tile.Initialize(new Vector2Int(x, y));
                var interactable = InteractableManager.Instance.GetRandomCropInteractable();
                tile.SetInteractable(interactable);

                grid.SetTile(x, y, tile);
                var tilePrefab = PrefabManager.Instance.GetTilePrefab();
                var cropPrefab = PrefabManager.Instance.GetRandomCropPrefabInstance();

                var tileObject = Instantiate(tilePrefab, new Vector3(x * tileSize, -y * tileSize, 0),
                    Quaternion.identity);
                tileObject.name = $"Tile_{x}_{y}";
                tileObject.transform.SetParent(gridParent.transform);
                var tileComponent = tileObject.GetComponent<TileComponent>();
                tileComponent.Initialize(x, y, tile);

                // check if it's a crop
                var interactablePrefab = PrefabManager.Instance.GetInteractablePrefab();
                var interactableObject =
                    Instantiate(interactablePrefab, tileObject.transform.position, Quaternion.identity);

                var interactableComponent = interactableObject.GetComponent<InteractiveComponent>();


                interactableComponent.SetInteractable(tile.Interactable);
                interactableObject.name = $"Interactable{tile.Interactable.ObjectName}_{x}_{y}";

                // interactableObject.transform.SetParent(tileObject.transform);
                // get Crop prefab and instantiate it at the center of its new parent tile
                interactableComponent.transform.SetParent(tileObject.transform);
                interactableComponent.GetComponent<SpriteRenderer>().sprite = interactable.growthSprites[0];
                // move interatable sprite child objectsuch that the bottom of the sprite is at the bottom of the tile
                Debug.Log("GRID: Setting Interactable sprite position to bottom of tile");
                var spriteRenderer = interactableComponent.GetComponent<SpriteRenderer>();
                var spriteHeight = spriteRenderer.bounds.size.y;
                spriteRenderer.transform.position = new Vector3(tileObject.transform.position.x,
                    tileObject.transform.position.y + spriteHeight / 2 - 0.5f, 0);*/
            // }
            Debug.Log("GRID: Setting grid parent position to: " + gridPosition);
            _gridParent.transform.position = gridPosition;
        }
        else
        {
            Debug.LogError("GRID: No grid found for map: " + currentMapSceneName);
        }
    }


    public GameObject CreateTile(Vector2Int position)
    {
        Debug.Log("GRID: Creating tile at position: " + position);
        var tilePrefab = PrefabManager.Instance.GetTilePrefab();

        var tileObject = Instantiate(tilePrefab, new Vector3(position.x * tileSize, -position.y * tileSize, 0),
            Quaternion.identity);

        tileObject.name = $"Tile_{position.x}_{position.y}";
        tileObject.transform.SetParent(_gridParent.transform);
        var tileComponent = tileObject.GetComponent<TileComponent>();

        var tile = ScriptableObject.CreateInstance<Tile>();
        tile.Initialize(new Vector2Int(position.x, position.y));
        tileComponent.Initialize(position.x, position.y, tile);


        return tileObject;
    }
}