using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.EventSystems;
using System.Collections.Generic;

public class BuildManager : MonoBehaviour
{
    public static BuildManager Instance;

    [System.Serializable]
    public struct TurretData
    {
        public string turretName;
        public bool isTunnel; // [추가] 터널 여부 체크
        public GameObject finalPrefab;
        public GameObject ghostPrefab;
        public float buildTime;
        public Vector2Int size;
    }

    public bool IsBuildMode => isBuildMode;

    [Header("Settings")]
    [SerializeField] private float cellSize = 1f;
    [SerializeField] private LayerMask groundLayer;
    [SerializeField] private GameObject constructionSitePrefab; // 공용 토대 프리팹

    [Header("Current Selection")]
    [SerializeField] private TurretData selectedTurret; // 현재 선택된 타워 데이터
    [SerializeField] private bool isBuildMode = false;

    [SerializeField] private LayerMask playerLayer; // 플레이어의 레이어

    [Header("Turret Library")]
    [SerializeField] private List<TurretData> turretLibrary; // 인스펙터에서 여러 타워 등록

    private GameObject _ghostInstance;
    private Material _ghostMaterial;
    private HashSet<Vector2Int> _occupiedNodes = new HashSet<Vector2Int>();
    private PlayerInputActions _inputActions;

    void Awake()
    {
        Instance = this;
        _inputActions = new PlayerInputActions();
    }

    void OnEnable()
    {
        _inputActions.Player.Build.performed += OnBuildPerformed;
        _inputActions.Player.Cancel.performed += OnCancelPerformed;
        _inputActions.Player.ToggleBuild.performed += OnTogglePerformed;
        _inputActions.Enable();
    }

    void OnDisable()
    {
        _inputActions.Disable();
    }

    void Update()
    {
        if (!isBuildMode || _ghostInstance == null) return;

        Vector2 mousePos = Mouse.current.position.ReadValue();
        Ray ray = Camera.main.ScreenPointToRay(mousePos);

        if (Physics.Raycast(ray, out RaycastHit hit, Mathf.Infinity, groundLayer))
        {
            Vector2Int gridPos = WorldToGrid(hit.point);
            _ghostInstance.transform.position = GridToWorld(gridPos, selectedTurret.size);

            // [수정] CanBuild 호출 인자를 selectedTurret 전체로 변경
            bool canPlace = CanBuild(gridPos, selectedTurret);

            // 고스트 색상 변경
            if (_ghostMaterial != null)
            {
                _ghostMaterial.color = canPlace ? new Color(0, 1, 0, 0.5f) : new Color(1, 0, 0, 0.5f);
            }

            // 미리보기 타워의 사거리 표시기 제어
            TowerRangeOverlay overlay = _ghostInstance.GetComponentInChildren<TowerRangeOverlay>();
            if (overlay != null)
            {
                overlay.ShowRange(true);
                overlay.UpdateRangeScale(); // 매 프레임 스케일 보정
            }
        }
    }

    // --- Input Callbacks ---
    private void OnTogglePerformed(InputAction.CallbackContext context) => ToggleBuildMode();
    private void OnCancelPerformed(InputAction.CallbackContext context)
    {
        if (isBuildMode) ToggleBuildMode();
    }

    private void OnBuildPerformed(InputAction.CallbackContext context)
    {
        if (!isBuildMode || EventSystem.current.IsPointerOverGameObject()) return;

        Vector2 mousePos = Mouse.current.position.ReadValue();
        Ray ray = Camera.main.ScreenPointToRay(mousePos);

        if (Physics.Raycast(ray, out RaycastHit hit, Mathf.Infinity, groundLayer))
        {
            Vector2Int gridPos = WorldToGrid(hit.point);
            // [수정] CanBuild 호출 인자 변경
            if (CanBuild(gridPos, selectedTurret))
            {
                Build(gridPos, selectedTurret);
            }
        }
    }

    // --- Core Logic ---
    private void ToggleBuildMode()
    {
        isBuildMode = !isBuildMode;

        if (isBuildMode) CreateGhost();
        else DestroyGhost();
    }

    private void CreateGhost()
    {
        if (selectedTurret.ghostPrefab == null) return;
        if (_ghostInstance != null) Destroy(_ghostInstance);

        _ghostInstance = Instantiate(selectedTurret.ghostPrefab);

        // 고스트의 머티리얼 참조 (색상 변경용)
        Renderer ghostRenderer = _ghostInstance.GetComponentInChildren<Renderer>();
        if (ghostRenderer != null) _ghostMaterial = ghostRenderer.material;

        // 1. 비주얼 스케일 조절
        Transform visual = _ghostInstance.transform.Find("Visual");
        if (visual != null)
        {
            visual.localScale = new Vector3(selectedTurret.size.x, 1f, selectedTurret.size.y);
        }

        // 2. 바닥 정렬
        AlignToGround(_ghostInstance, 0f);
    }

    private void DestroyGhost()
    {
        if (_ghostInstance != null) Destroy(_ghostInstance);
        _ghostMaterial = null;
    }

    private void Build(Vector2Int gridPos, TurretData data)
    {
        if (constructionSitePrefab == null || data.finalPrefab == null)
        {
            Debug.LogError("BuildManager: 프리팹 할당 상태를 확인하세요!");
            return;
        }

        // 점유 노드 등록
        for (int x = 0; x < data.size.x; x++)
            for (int y = 0; y < data.size.y; y++)
                _occupiedNodes.Add(new Vector2Int(gridPos.x + x, gridPos.y + y));

        // 토대 생성
        GameObject siteObj = Instantiate(constructionSitePrefab, GridToWorld(gridPos, data.size), Quaternion.identity);

        // 토대 비주얼 스케일 조절
        Transform visual = siteObj.transform.Find("Visual");
        if (visual != null)
        {
            visual.localScale = new Vector3(data.size.x, 1f, data.size.y);
        }

        // 토대 바닥 정렬
        AlignToGround(siteObj, 0f);

        // 컴포넌트 초기화
        ConstructionSite siteScript = siteObj.GetComponent<ConstructionSite>();
        if (siteScript != null)
        {
            siteScript.Initialize(data.finalPrefab, data.buildTime, data.size);
        }

        ToggleBuildMode();
    }

    // --- Utilities ---
    private bool CanBuild(Vector2Int startPos, TurretData data)
    {
        // 1. 기존 점유 노드 및 플레이어 충돌 체크
        for (int x = 0; x < data.size.x; x++)
        {
            for (int y = 0; y < data.size.y; y++)
            {
                if (_occupiedNodes.Contains(new Vector2Int(startPos.x + x, startPos.y + y)))
                    return false;
            }
        }

        // 플레이어와 겹치는지 체크
        Vector3 center = GridToWorld(startPos, data.size);
        center.y = 1f;
        Vector3 halfExtents = new Vector3(data.size.x * 0.45f, 0.5f, data.size.y * 0.45f);
        if (Physics.CheckBox(center, halfExtents, Quaternion.identity, playerLayer))
            return false;

        // 2. 터널 연결 제약 조건 체크
        if (data.isTunnel)
        {
            return IsConnectedToExistingTunnel(startPos, data);
        }

        return true;
    }

    private bool IsConnectedToExistingTunnel(Vector2Int startPos, TurretData data)
    {
        // 첫 번째 터널은 자유롭게 설치 (또는 특정 구역 제한)
        if (_occupiedNodes.Count == 0) return true;

        Vector3 ghostWorldPos = GridToWorld(startPos, data.size);
        float checkRadius = cellSize * 1.5f;
        Collider[] neighbors = Physics.OverlapSphere(ghostWorldPos, checkRadius, LayerMask.GetMask("Tunnel"));

        foreach (var col in neighbors)
        {
            TunnelNode node = col.GetComponent<TunnelNode>();
            if (node != null && node.gameObject.activeInHierarchy)
            {
                return true;
            }
        }
        return false;
    }

    public Vector2Int WorldToGrid(Vector3 worldPos) => new Vector2Int(Mathf.FloorToInt(worldPos.x / cellSize), Mathf.FloorToInt(worldPos.z / cellSize));

    public Vector3 GridToWorld(Vector2Int gridPos, Vector2Int size)
    {
        return new Vector3(gridPos.x * cellSize + (size.x - 1) * cellSize * 0.5f, 0.05f, gridPos.y * cellSize + (size.y - 1) * cellSize * 0.5f);
    }

    public void AlignToGround(GameObject obj, float yOffset)
    {
        Transform visual = obj.transform.Find("Visual");
        if (visual == null) return;

        MeshRenderer[] renderers = visual.GetComponentsInChildren<MeshRenderer>();
        if (renderers.Length == 0) return;

        Bounds bounds = renderers[0].bounds;
        foreach (var renderer in renderers)
        {
            bounds.Encapsulate(renderer.bounds);
        }

        float bottomY = bounds.min.y - obj.transform.position.y;
        visual.localPosition = new Vector3(0, -bottomY + yOffset, 0);
    }

    private void OnDrawGizmos()
    {
        Gizmos.color = new Color(1, 1, 1, 0.1f);
        for (int x = -10; x <= 10; x++)
            for (int z = -10; z <= 10; z++)
                Gizmos.DrawWireCube(new Vector3(x * cellSize, 0, z * cellSize), new Vector3(cellSize, 0.01f, cellSize));
    }

    public void SelectTurret(int index)
    {
        if (index >= 0 && index < turretLibrary.Count)
        {
            selectedTurret = turretLibrary[index];
            if (isBuildMode) CreateGhost();
        }
    }
}