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

namespace Northbound
{
    /// <summary>
    /// 상호작용 대상 - 자원 채집
    /// </summary>
    public class Resource : NetworkBehaviour, IInteractable
    {
        [Header("Resource Settings")]
        public int maxResources = 100;
        public int resourcesPerGathering = 10;
        public float gatheringCooldown = 2f;
        public string resourceName = "광석";

        [Header("Resource Recharge")]
        public float rechargeInterval = 5f; // 충전 주기 (초)
        public int rechargeAmount = 10; // 주기당 충전량

        [Header("Quality (Runtime)")]
        [SerializeField] private NetworkVariable<float> _qualityPercentage = new NetworkVariable<float>(
            0f,
            NetworkVariableReadPermission.Everyone,
            NetworkVariableWritePermission.Server
        );

        [Tooltip("품질 보정율 (-30% ~ +30%)")]
        [SerializeField] private float _displayQuality = 0f;

        [Tooltip("품질 적용 후 최대 자원량")]
        [SerializeField] private int _displayMaxResources = 100;

        [Tooltip("품질 적용 후 충전량")]
        [SerializeField] private int _displayRechargeAmount = 10;

        private bool _isQualityInitialized = false;

        [Header("Animation")]
        public string interactionAnimationTrigger = "Mining"; // 플레이어 애니메이션 트리거

        [Header("Equipment")]
        public EquipmentData equipmentData = new EquipmentData
        {
            socketName = "RightHand",
            equipmentPrefab = null, // Inspector에서 곡괭이 프리팹 할당
            attachOnStart = true,
            detachOnEnd = true
        };

        [Header("Visual")]
        public GameObject gatheringEffectPrefab;
        public Transform effectSpawnPoint;

        [Header("Worker Assignment")]
        public bool allowWorkerAssignment = true;
        
        [Header("Multi-worker")]
        public bool allowMultipleWorkers = true; // 한 자원에 여러 워커 허용 여부
        
        public bool HasResourcesAvailable()
        {
            return _currentResources.Value > 0;
        }

        public bool CanWorkerMineResource(ulong workerId)
        {
            if (!HasResourcesAvailable())
                return false;

            if (allowMultipleWorkers)
                return true;

            if (_currentWorkerId.Value == ulong.MaxValue)
                return true;

            return _currentWorkerId.Value == workerId;
        }

        public int TakeResourcesForWorker(int amount, ulong workerId)
        {
            if (!IsServer) return 0;

            if (!allowMultipleWorkers)
            {
                if (_currentWorkerId.Value != ulong.MaxValue && _currentWorkerId.Value != workerId)
                    return 0;
            }

            int availableResources = _currentResources.Value;
            int actualAmount = Mathf.Min(amount, availableResources);
            
            if (actualAmount <= 0)
                return 0;

            _currentResources.Value -= actualAmount;
            _lastGatheringTime = Time.time;

            if (!allowMultipleWorkers && actualAmount > 0)
            {
                _currentWorkerId.Value = workerId;
            }

            if (_currentResources.Value <= 0 && !allowMultipleWorkers)
            {
                _currentWorkerId.Value = ulong.MaxValue;
            }

            ShowGatheringEffectClientRpc();

            return actualAmount;
        }

        private NetworkVariable<int> _currentResources = new NetworkVariable<int>(
            0,
            NetworkVariableReadPermission.Everyone,
            NetworkVariableWritePermission.Server
        );

        private NetworkVariable<ulong> _currentWorkerId = new NetworkVariable<ulong>(
            ulong.MaxValue,
            NetworkVariableReadPermission.Everyone,
            NetworkVariableWritePermission.Server
        );

        private float _lastGatheringTime;
        private float _lastRechargeTime;

        public float QualityPercentage => _qualityPercentage.Value;

        public int ActualMaxResources
        {
            get
            {
                float multiplier = 1f + (_qualityPercentage.Value / 100f);
                return Mathf.RoundToInt(maxResources * multiplier);
            }
        }

        public int ActualRechargeAmount
        {
            get
            {
                float multiplier = 1f + (_qualityPercentage.Value / 100f);
                return Mathf.RoundToInt(rechargeAmount * multiplier);
            }
        }

        public override void OnNetworkSpawn()
        {
            _qualityPercentage.OnValueChanged += OnQualityChanged;
            
            if (IsServer)
            {
                if (!_isQualityInitialized)
                {
                    _qualityPercentage.Value = Random.Range(-30f, 30f);
                }

                _currentResources.Value = ActualMaxResources;
                _lastRechargeTime = Time.time;
                _lastGatheringTime = Time.time - gatheringCooldown;
            }

            _displayQuality = _qualityPercentage.Value;
            UpdateDisplayValues();
        }

        public void InitializeQuality(float qualityPercentage)
        {
            if (IsServer)
            {
                _qualityPercentage.Value = qualityPercentage;
                _displayQuality = qualityPercentage;
                _isQualityInitialized = true;
            }
            else if (IsClient)
            {
                _displayQuality = qualityPercentage;
                UpdateDisplayValues();
            }
        }

        public override void OnNetworkDespawn()
        {
            _qualityPercentage.OnValueChanged -= OnQualityChanged;
        }

        private void OnQualityChanged(float previous, float current)
        {
            _displayQuality = current;
            UpdateDisplayValues();
        }

        private void UpdateDisplayValues()
        {
            if (IsClient || IsServer)
            {
                _displayMaxResources = ActualMaxResources;
                _displayRechargeAmount = ActualRechargeAmount;
            }
            else
            {
                _displayMaxResources = maxResources;
                _displayRechargeAmount = rechargeAmount;
            }
        }

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

            // 자원 충전 로직
            if (Time.time - _lastRechargeTime >= rechargeInterval)
            {
                if (_currentResources.Value < ActualMaxResources)
                {
                    int rechargeAmountToAdd = Mathf.Min(ActualRechargeAmount, ActualMaxResources - _currentResources.Value);
                    _currentResources.Value += rechargeAmountToAdd;

                    // Debug.Log($"{resourceName} {rechargeAmountToAdd} 충전됨. 현재: {_currentResources.Value}/{ActualMaxResources}");
                }

                _lastRechargeTime = Time.time;
            }
        }

        public bool CanInteract(ulong playerId)
        {
            if (_currentResources.Value <= 0)
                return false;

            if (Time.time - _lastGatheringTime < gatheringCooldown)
                return false;

            // 플레이어의 자원 공간 확인
            int availableSpace = GetPlayerAvailableSpace(playerId);
            if (availableSpace <= 0)
                return false;

            return true;
        }

        /// <summary>
        /// 플레이어의 자원 공간 확인 (서버와 클라이언트 모두 지원)
        /// </summary>
        private int GetPlayerAvailableSpace(ulong playerId)
        {
            // 서버에서는 ServerResourceManager 사용
            var resourceManager = ServerResourceManager.Instance;
            if (resourceManager != null)
            {
                return resourceManager.GetAvailableSpace(playerId);
            }

            // 클라이언트에서는 PlayerResourceInventory 사용
            if (NetworkManager.Singleton != null)
            {
                var spawnedObjects = NetworkManager.Singleton.SpawnManager.SpawnedObjects;
                foreach (var kvp in spawnedObjects)
                {
                    var controller = kvp.Value.GetComponent<NetworkPlayerController>();
                    if (controller != null && controller.OwnerPlayerId == playerId)
                    {
                        var inventory = kvp.Value.GetComponent<PlayerResourceInventory>();
                        if (inventory != null)
                        {
                            return inventory.MaxResourceCapacity - inventory.CurrentResourceAmount;
                        }
                    }
                }
            }

            return 0;
        }

        public void Interact(ulong playerId)
        {
            AssignOrGatherResourceServerRpc(playerId, NetworkObject.NetworkObjectId);
        }

        [Rpc(SendTo.Server, InvokePermission = RpcInvokePermission.Everyone)]
        private void AssignOrGatherResourceServerRpc(ulong playerId, ulong resourceId)
        {
            if (!IsServer) return;

            bool workerAssigned = false;

            if (allowWorkerAssignment)
            {
                // Find worker owned by player in Following state (server-side, not client-side)
                Worker assignedWorker = FindWorkerForPlayer(playerId);

                if (assignedWorker != null)
                {
                    if ((int)assignedWorker.CurrentState == 1) // 1 = Following
                    {
                        assignedWorker.AssignMiningTargetServerRpc(resourceId);
                        workerAssigned = true;

                        ShowGatheringEffectClientRpc();
                    }
                }
            }

            if (!workerAssigned)
            {
                if (!CanInteract(playerId))
                {
                    return;
                }

                GatherResource(playerId);
            }
        }

        private void GatherResource(ulong playerId)
        {
            Debug.Log($"[Resource] GatherResource called - IsServer: {IsServer}, OwnerClientId: {OwnerClientId}, Current: {_currentResources.Value}");
            
            if (!IsServer)
            {
                Debug.LogError($"[Resource] GatherResource called on CLIENT! This should not happen!");
                return;
            }

            if (!CanInteract(playerId))
                return;

            var resourceManager = ServerResourceManager.Instance;
            if (resourceManager == null)
                return;

            int playerAvailableSpace = resourceManager.GetAvailableSpace(playerId);

            int gatheredAmount = Mathf.Min(
                resourcesPerGathering,
                _currentResources.Value,
                playerAvailableSpace
            );

            if (gatheredAmount <= 0)
            {
                return;
            }

            _currentResources.Value -= gatheredAmount;
            _lastGatheringTime = Time.time;

            resourceManager.AddResource(playerId, gatheredAmount);
            UpdatePlayerResourcesClientRpc(playerId);

            ShowGatheringEffectClientRpc();
        }

        [Rpc(SendTo.ClientsAndHost)]
        private void UpdatePlayerResourcesClientRpc(ulong playerId)
        {
            // 해당 플레이어만 업데이트
            if (NetworkManager.Singleton.LocalClientId != playerId)
                return;

            // 로컬 플레이어의 PlayerResourceInventory 찾아서 업데이트 요청
            var spawnedObjects = NetworkManager.Singleton.SpawnManager.SpawnedObjects;
            foreach (var kvp in spawnedObjects)
            {
                var controller = kvp.Value.GetComponent<NetworkPlayerController>();
                if (controller != null && controller.IsLocalPlayer)
                {
                    var inventory = kvp.Value.GetComponent<PlayerResourceInventory>();
                    if (inventory != null)
                    {
                        inventory.RequestResourceUpdateServerRpc(playerId);
                        return;
                    }
                }
            }
        }

        [Rpc(SendTo.NotServer)]
        private void ShowGatheringEffectClientRpc()
        {
            if (gatheringEffectPrefab != null && effectSpawnPoint != null)
            {
                GameObject effect = Instantiate(gatheringEffectPrefab, effectSpawnPoint.position, effectSpawnPoint.rotation);
                Destroy(effect, 2f);
            }
        }

        public string GetInteractionPrompt()
        {
            if (_currentResources.Value <= 0)
                return "Recharging...";

            return $"[E] {resourceName} Mining ({_currentResources.Value}/{ActualMaxResources})";
        }

        public string GetInteractionAnimation()
        {
            return interactionAnimationTrigger;
        }

        public EquipmentData GetEquipmentData()
        {
            return equipmentData;
        }

        public Transform GetTransform()
        {
            return transform;
        }

        private Worker FindWorkerForPlayer(ulong playerId)
        {
            if (NetworkManager.Singleton == null || NetworkManager.Singleton.SpawnManager == null)
            {
                return null;
            }

            var spawnedObjects = NetworkManager.Singleton.SpawnManager.SpawnedObjects;
            int workersFound = 0;

            foreach (var kvp in spawnedObjects)
            {
                var networkObj = kvp.Value;
                var worker = networkObj.GetComponent<Worker>();

                if (worker != null)
                {
                    workersFound++;

                    // Use worker's internal OwnerPlayerId, NOT NetworkObject.OwnerClientId!
                    if (worker.OwnerPlayerId == playerId && (int)worker.CurrentState == 1) // 1 = Following
                    {
                        return worker;
                    }
                }
            }

            return null;
        }
    }
}