using System.Collections;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using UnityEngine;

public class Building : MonoBehaviour
{
    [Tooltip("Direct Reference to the Grid Manager Class")]
    private Grid_Manager gridManager;   // Reference to our Grid Manager CS file
    [Header("Building Grid Size")]
    [Tooltip("Cell Building Scale On X Axis")]
    public int buildingSizeX = 2; // Set your desired size
    [Tooltip("Cell Building Scale On Z Axis")]
    public int buildingSizeZ = 2; // Set your desired size

    private int lastOccupiedX = -1; // Last position in the Grid On X
    private int lastOccupiedZ = -1; // Last Position in the Grid On Z

    private int currentlyOccupiedX = -1;    // Current Position in Grid on X
    private int currentlyOccupiedZ = -1;    // Current Position in Grid on Z

    private string occupyingBuildingName = "";  // Current Building GameObject String name inside a cell
    private bool hasOccupiedCell = false;   // Bool to check if a cell is occupied 

    private bool isBeingDragged = false;    // Boolean controlling if mouse is down and dragging a building

    // New variables to keep track of the last occupied cell for each building
    private Dictionary<string, Vector2Int> buildingLastOccupiedCells = new Dictionary<string, Vector2Int>();

    void Awake()
    {
        gridManager = FindObjectOfType<Grid_Manager>(); // Find the Grid Manager inside the scene
        if (gridManager == null)    // if we do not find the grid manager
        {
            Debug.LogError("Grid Manager not found. Make sure it is present in the scene.");    // Log Error since nothing works without it 
        }

        if (buildingSizeX >= 5 || buildingSizeZ >= 5)
            Debug.LogWarning("This Script Does not support larger buildings well"
                + " Please Reduce the size if you see any abnormalities");

    }

    void Start()
    {
        // when grid manager is aquired
        if (gridManager != null)
        {
            PlaceBuilding();    // Run PLace Building Function
        }
    }

    void Update()
    {
        // When true
        if (isBeingDragged)
        {
            // Update the building position during drag
            UpdateGridOccupancy();
        }
    }


    void PlaceBuilding()
    {
        UpdateGridOccupancy(); // Initial update
    }

    void SnapToGrid(int x, int z)
    {
        // Calculate the center position of the grid cells
        float centerX = (x + 0.5f * (buildingSizeX - 1)) * gridManager.cellSize;
        float centerZ = (z + 0.5f * (buildingSizeZ - 1)) * gridManager.cellSize;

        // Set the new position while maintaining the Y position
        transform.position = new Vector3(centerX, transform.position.y, centerZ);
    }

    private void OnMouseDrag()
    {
        // Get the mouse position in world coordinates
        Vector3 mousePosition = Camera.main.ScreenToWorldPoint(new Vector3(Input.mousePosition.x, Input.mousePosition.y, Camera.main.transform.position.y));

        // Calculate the half size of the building on the X and Z axes
        float halfSizeX = buildingSizeX * 0.5f * gridManager.cellSize;
        float halfSizeZ = buildingSizeZ * 0.5f * gridManager.cellSize;

        // Calculate the snapped position based on the closest grid cell
        float snappedX = Mathf.Floor((mousePosition.x - halfSizeX) / gridManager.cellSize) * gridManager.cellSize + halfSizeX;
        float snappedZ = Mathf.Floor((mousePosition.z - halfSizeZ) / gridManager.cellSize) * gridManager.cellSize + halfSizeZ;

        // Set the new position while maintaining the Y position
        transform.position = new Vector3(snappedX, transform.position.y, snappedZ);

        // Debug logs for diagnosis
        //Debug.Log($"Mouse Position: {mousePosition}, Snapped Position: {snappedX}, {snappedZ}, Actual Position: {transform.position}");
    }

    void OnMouseDown()
    {
        isBeingDragged = true;
    }

    void OnMouseUp()
    {
        isBeingDragged = false;
    }

    void UpdateGridOccupancy()
    {
        // grid cell index on the Axis where the center of the building is located.
        int x = Mathf.FloorToInt((transform.position.x - gridManager.transform.position.x) / gridManager.cellSize);
        int z = Mathf.FloorToInt((transform.position.z - gridManager.transform.position.z) / gridManager.cellSize);

        // Debug log for actual position
        Debug.Log($"Actual Position: {transform.position}");

        // Check if the building is within the grid
        if (x >= 0 && x < gridManager.gridSize - buildingSizeX + 1 &&
            z >= 0 && z < gridManager.gridSize - buildingSizeZ + 1)
        {

            SnapToGrid(x, z);
            // Check if the cell is already occupied by another building
            if (gridManager.IsCellOccupiedByOther(x, z, buildingSizeX, buildingSizeZ, gameObject.name))
            {
                // Cell is already occupied by another building, handle accordingly (e.g., print a message)
                Debug.LogWarning($"Cannot place {gameObject.name} in occupied cell ({x}, {z}). Already occupied by another building.");
                // When a Building moves towards an occupied Cell it refreshes the grid since we are no longer in the old cell
                gridManager.ReleaseCells(lastOccupiedX, lastOccupiedZ, buildingSizeX, buildingSizeZ, gameObject.name);

                return; // Skip updating last occupied values if there is a conflict
            }

            // Rest of the logic for handling placement inside the grid
            if (!hasOccupiedCell)
            {
                occupyingBuildingName = gameObject.name;
                Debug.Log($"Cell ({x}, {z}) is now occupied by {occupyingBuildingName}.");
                hasOccupiedCell = true;
            }
            else if (occupyingBuildingName == gameObject.name)
            {
                Debug.Log($"Cell ({x}, {z}) is still occupied by {gameObject.name}.");
            }
            else
            {
                // Check if the cell was previously occupied by another building with a different name
                if (lastOccupiedX != -1 && lastOccupiedZ != -1 &&
                    (lastOccupiedX == x && lastOccupiedZ == z))
                {
                    // Cell is already occupied by another building, handle accordingly (e.g., print a message)
                    Debug.LogWarning($"Cannot place {gameObject.name} in occupied cell ({x}, {z}). Already occupied by another building.");
                    return; // Skip updating last occupied values if there is a conflict
                }
            }

            // If the building moved to a new cell, update the currently occupied cell for debugging
            currentlyOccupiedX = x;
            currentlyOccupiedZ = z;

            // If the building moved to a new cell, revert the color of the last occupied cells to green
            if (lastOccupiedX != -1 && lastOccupiedZ != -1 && (lastOccupiedX != x || lastOccupiedZ != z))
            {
                gridManager.ReleaseCells(lastOccupiedX, lastOccupiedZ, buildingSizeX, buildingSizeZ, gameObject.name);
            }

            // Update the grid to occupy the current cells
            gridManager.OccupyCells(x, z, buildingSizeX, buildingSizeZ, gameObject.name);

            // Update the last occupied cell for this building
            buildingLastOccupiedCells[gameObject.name] = new Vector2Int(x, z);

            lastOccupiedX = x;
            lastOccupiedZ = z;
        }
        else
        {
            // If the building is outside the grid, revert the color of the last occupied cells to green
            if (lastOccupiedX != -1 && lastOccupiedZ != -1)
            {
                gridManager.ReleaseCells(lastOccupiedX, lastOccupiedZ, buildingSizeX, buildingSizeZ, gameObject.name);
                currentlyOccupiedX = -1;
                currentlyOccupiedZ = -1;
                // If the building is outside the grid, clear its occupancy from the grid
                gridManager.ClearBuildingOccupancy(gameObject.name);
            }

            lastOccupiedX = -1;
            lastOccupiedZ = -1;
        }
    }
}