using System.Collections.Generic;
using Unity.Netcode;
using UnityEngine;

namespace Northbound
{
    /// <summary>
    /// 전장의 안개 시스템 - 플레이어별 시야 관리
    /// </summary>
    public class FogOfWarSystem : NetworkBehaviour
    {
        public static FogOfWarSystem Instance { get; private set; }

        [Header("Grid Settings")]
        public int gridWidth = 100;
        public int gridHeight = 100;
        public float cellSize = 1f;
        public Vector3 worldOrigin = Vector3.zero;

        [Header("Visibility Settings")]
        public float updateInterval = 0.2f;
        
        // 서버: 각 플레이어별 가시성 맵
        private Dictionary<ulong, FogOfWarData> _serverFogData = new Dictionary<ulong, FogOfWarData>();
        
        // 클라이언트: 로컬 플레이어의 가시성 맵
        private FogOfWarData _localFogData;
        
        private List<IVisionProvider> _visionProviders = new List<IVisionProvider>();
        private float _updateTimer;

        private void Awake()
        {
            if (Instance != null && Instance != this)
            {
                Destroy(gameObject);
                return;
            }
            Instance = this;
        }

        public override void OnNetworkSpawn()
        {
            base.OnNetworkSpawn();
            
            if (IsClient && !IsServer)
            {
                // 클라이언트는 로컬 데이터 초기화
                _localFogData = new FogOfWarData(gridWidth, gridHeight);
                Debug.Log($"<color=cyan>[FogOfWar] 클라이언트 {NetworkManager.LocalClientId} 초기화</color>");
            }
        }

        private void Update()
        {
            if (!IsServer) return;

            _updateTimer += Time.deltaTime;
            if (_updateTimer >= updateInterval)
            {
                _updateTimer = 0f;
                UpdateAllVision();
            }
        }

        /// <summary>
        /// 시야 제공자 등록 (플레이어, 건물 등)
        /// </summary>
        public void RegisterVisionProvider(IVisionProvider provider)
        {
            if (!_visionProviders.Contains(provider))
            {
                _visionProviders.Add(provider);
                Debug.Log($"<color=cyan>[FogOfWar] Vision Provider 등록: {provider.GetTransform().name} (Owner: {provider.GetOwnerId()})</color>");
            }
        }

        /// <summary>
        /// 시야 제공자 등록 해제
        /// </summary>
        public void UnregisterVisionProvider(IVisionProvider provider)
        {
            _visionProviders.Remove(provider);
        }

        /// <summary>
        /// 플레이어별 FogOfWar 데이터 가져오기
        /// </summary>
        public FogOfWarData GetPlayerFogData(ulong clientId)
        {
            // 클라이언트는 자신의 로컬 데이터 반환
            if (IsClient && !IsServer)
            {
                return _localFogData;
            }

            // 서버는 해당 클라이언트의 데이터 반환
            if (!_serverFogData.ContainsKey(clientId))
            {
                _serverFogData[clientId] = new FogOfWarData(gridWidth, gridHeight);
            }
            return _serverFogData[clientId];
        }

        /// <summary>
        /// 모든 시야 업데이트 (서버만)
        /// </summary>
        private void UpdateAllVision()
        {
            // 각 플레이어의 현재 시야 초기화
            foreach (var fogData in _serverFogData.Values)
            {
                fogData.ClearCurrentVision();
            }

            // 모든 시야 제공자의 시야 범위 계산
            foreach (var provider in _visionProviders)
            {
                if (provider == null || !provider.IsActive()) continue;

                ulong ownerId = provider.GetOwnerId();
                if (!_serverFogData.ContainsKey(ownerId))
                {
                    _serverFogData[ownerId] = new FogOfWarData(gridWidth, gridHeight);
                }

                Vector3 position = provider.GetTransform().position;
                float visionRange = provider.GetVisionRange();
                
                RevealArea(ownerId, position, visionRange);
            }

            // 각 클라이언트에게 시야 데이터 전송
            foreach (var kvp in _serverFogData)
            {
                ulong clientId = kvp.Key;
                FogOfWarData fogData = kvp.Value;

                // 압축된 데이터로 전송
                byte[] visibleData = fogData.GetVisibleData();
                byte[] exploredData = fogData.GetExploredData();

                SendFogDataToClientRpc(visibleData, exploredData, 
                    new ClientRpcParams
                    {
                        Send = new ClientRpcSendParams
                        {
                            TargetClientIds = new ulong[] { clientId }
                        }
                    });
            }
        }

        /// <summary>
        /// 클라이언트에게 안개 데이터 전송
        /// </summary>
        [ClientRpc]
        private void SendFogDataToClientRpc(byte[] visibleData, byte[] exploredData, ClientRpcParams clientRpcParams = default)
        {
            if (_localFogData == null)
            {
                _localFogData = new FogOfWarData(gridWidth, gridHeight);
            }

            _localFogData.SetVisibleData(visibleData);
            _localFogData.SetExploredData(exploredData);
        }

        /// <summary>
        /// 특정 영역을 밝힘 (서버만)
        /// </summary>
        private void RevealArea(ulong clientId, Vector3 worldPosition, float radius)
        {
            FogOfWarData fogData = _serverFogData[clientId];
            Vector2Int gridPos = WorldToGrid(worldPosition);

            int cellRadius = Mathf.CeilToInt(radius / cellSize);

            for (int x = -cellRadius; x <= cellRadius; x++)
            {
                for (int y = -cellRadius; y <= cellRadius; y++)
                {
                    if (x * x + y * y > cellRadius * cellRadius) continue;

                    int gridX = gridPos.x + x;
                    int gridY = gridPos.y + y;

                    if (gridX < 0 || gridX >= gridWidth || gridY < 0 || gridY >= gridHeight)
                        continue;

                    // 현재 시야에 표시 + 방문한 적 있음으로 기록
                    fogData.SetVisible(gridX, gridY, true);
                    fogData.SetExplored(gridX, gridY, true);
                }
            }
        }

        /// <summary>
        /// 월드 좌표를 그리드 좌표로 변환
        /// </summary>
        public Vector2Int WorldToGrid(Vector3 worldPos)
        {
            Vector3 localPos = worldPos - worldOrigin;
            int x = Mathf.FloorToInt(localPos.x / cellSize);
            int z = Mathf.FloorToInt(localPos.z / cellSize);
            return new Vector2Int(x, z);
        }

        /// <summary>
        /// 그리드 좌표를 월드 좌표로 변환
        /// </summary>
        public Vector3 GridToWorld(int x, int y)
        {
            return worldOrigin + new Vector3(x * cellSize, 0, y * cellSize);
        }

        /// <summary>
        /// 특정 위치가 플레이어에게 보이는지 확인
        /// </summary>
        public FogOfWarState GetVisibilityState(ulong clientId, Vector3 worldPosition)
        {
            FogOfWarData fogData = GetPlayerFogData(clientId);
            if (fogData == null)
                return FogOfWarState.Unexplored;

            Vector2Int gridPos = WorldToGrid(worldPosition);
            return fogData.GetState(gridPos.x, gridPos.y);
        }

        private void OnDrawGizmos()
        {
            // 그리드 시각화
            Gizmos.color = Color.yellow;
            Vector3 size = new Vector3(gridWidth * cellSize, 0.1f, gridHeight * cellSize);
            Gizmos.DrawWireCube(worldOrigin + size / 2f, size);
        }
    }

    /// <summary>
    /// 플레이어별 안개 데이터
    /// </summary>
    public class FogOfWarData
    {
        private bool[,] _explored;      // 한번이라도 방문한 적이 있는가
        private bool[,] _currentlyVisible; // 현재 보이는가
        private int _width;
        private int _height;

        public FogOfWarData(int width, int height)
        {
            _width = width;
            _height = height;
            _explored = new bool[width, height];
            _currentlyVisible = new bool[width, height];
        }

        public void SetExplored(int x, int y, bool value)
        {
            if (IsValidCoord(x, y))
                _explored[x, y] = value;
        }

        public void SetVisible(int x, int y, bool value)
        {
            if (IsValidCoord(x, y))
                _currentlyVisible[x, y] = value;
        }

        public void ClearCurrentVision()
        {
            System.Array.Clear(_currentlyVisible, 0, _currentlyVisible.Length);
        }

        public FogOfWarState GetState(int x, int y)
        {
            if (!IsValidCoord(x, y))
                return FogOfWarState.Unexplored;

            if (_currentlyVisible[x, y])
                return FogOfWarState.Visible;

            if (_explored[x, y])
                return FogOfWarState.Explored;

            return FogOfWarState.Unexplored;
        }

        private bool IsValidCoord(int x, int y)
        {
            return x >= 0 && x < _explored.GetLength(0) && 
                   y >= 0 && y < _explored.GetLength(1);
        }

        /// <summary>
        /// Visible 데이터를 바이트 배열로 압축
        /// </summary>
        public byte[] GetVisibleData()
        {
            int totalCells = _width * _height;
            int byteCount = (totalCells + 7) / 8; // 8비트 = 1바이트
            byte[] data = new byte[byteCount];

            for (int i = 0; i < totalCells; i++)
            {
                int x = i % _width;
                int y = i / _width;
                
                if (_currentlyVisible[x, y])
                {
                    int byteIndex = i / 8;
                    int bitIndex = i % 8;
                    data[byteIndex] |= (byte)(1 << bitIndex);
                }
            }

            return data;
        }

        /// <summary>
        /// Explored 데이터를 바이트 배열로 압축
        /// </summary>
        public byte[] GetExploredData()
        {
            int totalCells = _width * _height;
            int byteCount = (totalCells + 7) / 8;
            byte[] data = new byte[byteCount];

            for (int i = 0; i < totalCells; i++)
            {
                int x = i % _width;
                int y = i / _width;
                
                if (_explored[x, y])
                {
                    int byteIndex = i / 8;
                    int bitIndex = i % 8;
                    data[byteIndex] |= (byte)(1 << bitIndex);
                }
            }

            return data;
        }

        /// <summary>
        /// 바이트 배열에서 Visible 데이터 복원
        /// </summary>
        public void SetVisibleData(byte[] data)
        {
            System.Array.Clear(_currentlyVisible, 0, _currentlyVisible.Length);

            int totalCells = _width * _height;
            for (int i = 0; i < totalCells && i / 8 < data.Length; i++)
            {
                int byteIndex = i / 8;
                int bitIndex = i % 8;
                
                bool isVisible = (data[byteIndex] & (1 << bitIndex)) != 0;
                
                int x = i % _width;
                int y = i / _width;
                _currentlyVisible[x, y] = isVisible;
            }
        }

        /// <summary>
        /// 바이트 배열에서 Explored 데이터 복원
        /// </summary>
        public void SetExploredData(byte[] data)
        {
            int totalCells = _width * _height;
            for (int i = 0; i < totalCells && i / 8 < data.Length; i++)
            {
                int byteIndex = i / 8;
                int bitIndex = i % 8;
                
                bool isExplored = (data[byteIndex] & (1 << bitIndex)) != 0;
                
                int x = i % _width;
                int y = i / _width;
                
                // Explored는 누적 (한번 탐색하면 계속 유지)
                if (isExplored)
                    _explored[x, y] = true;
            }
        }
    }

    /// <summary>
    /// 안개 상태
    /// </summary>
    public enum FogOfWarState
    {
        Unexplored,  // 방문한 적 없음 (완전히 어두움)
        Explored,    // 방문했지만 현재 시야 밖 (지형/건물만 보임)
        Visible      // 현재 시야 안 (모두 보임)
    }
}