using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using Cinemachine;
using DG.Tweening;

namespace CryingSnow.FarmingIsland
{
    public class Silo : MonoBehaviour, IProp
    {
        [Tooltip("The minimum distance between the player and the silo for the upgrade menu to appear.")]
        [SerializeField] private float nearDistance = 2.5f;

        [Tooltip("The maximum level the silo can reach through upgrades.")]
        [SerializeField] private int maxLevel = 20;

        [Tooltip("The base capacity for storing crops in the silo (per crop).")]
        [SerializeField] private int baseCapacity = 100;

        [Tooltip("The base price for upgrading the silo (increases exponentially).")]
        [SerializeField] private int basePrice = 1500;

        [Tooltip("The price increase factor for upgrades.")]
        [SerializeField] private float priceFactor = 1.1f;

        [Tooltip("The maximum time required for the player to withdraw all crops from the silo.")]
        [SerializeField] private float maxWithdrawTime = 5f;

        [Tooltip("The virtual camera that will be activated when the player is about to upgrade.")]
        [SerializeField] private CinemachineVirtualCamera virtualCamera;

        [Header("Farmer Settings")]
        [Tooltip("Prefab of the farmer that will be instantiated based on the number of farms assigned to this silo.")]
        [SerializeField] private Farmer farmerPrefab;

        [Tooltip("The maximum level each farmer can achieve through upgrades.")]
        [SerializeField] private int farmerMaxLevel = 10;

        [Tooltip("The base capacity for crops that each farmer can carry from the farm to the silo.")]
        [SerializeField] private int farmerBaseCapacity = 50;

        [Tooltip("The base price for upgrading each farmer (price increases exponentially).")]
        [SerializeField] private int farmerBasePrice = 1200;

        [Tooltip("The factor by which the price increases for each farmer upgrade.")]
        [SerializeField] private float farmerPriceFactor = 1.2f;

        [Tooltip("List of farms assigned to the farmers.")]
        [SerializeField] private List<Farm> farms = new List<Farm>();

        private PlayerController player;
        private Inventory inventory;

        private string siloId;
        private SiloData data;

        private int capacity => baseCapacity * data.SiloLevel;
        private int upgradePrice => data.SiloLevel < maxLevel ? (int)(basePrice * Mathf.Pow(priceFactor, data.SiloLevel - 1)) : -1;

        public Location Location => Location.Silo;

        // For storing all farmers data
        private List<FarmerData> farmerDatabase = new List<FarmerData>();

        private bool isWithdrawing;
        private bool isUpgrading;

        void Awake()
        {
            transform.localScale = Vector3.zero;
            inventory = GetComponent<Inventory>();
        }

        void Start()
        {
            // Generate a unique identifier for the silo
            siloId = $"{gameObject.name} {(transform.parent != null ? transform.parent.name : "")}";

            // Load silo data using the generated siloId
            data = IslandManager.Instance.LoadSiloData(siloId);

            // If no data is found for this siloId, create new silo data with default values
            if (data == null)
            {
                // Initialize farmer levels to 0 (not hired) for each farm in the list
                var farmerLevels = Enumerable.Repeat(0, farms.Count).ToList();

                // Create new SiloData with an initial level of 1 and the initialized farmer levels
                data = new SiloData(siloId, 1, farmerLevels);
            }

            // Iterate through each farm to set up the corresponding farmer
            for (int index = 0; index < farms.Count; index++)
            {
                var farm = farms[index]; // Get the current farm
                int level = 0; // Default level for a new farmer

                // Check if the current index has a level assigned in the loaded data
                if (index < data.FarmerLevels.Count)
                {
                    level = data.FarmerLevels[index]; // Use the existing level
                }
                else
                {
                    data.FarmerLevels.Add(level); // Add the default level if not present
                }

                // Create a FarmerData object with the relevant parameters
                var farmerData = new FarmerData(
                    level,                      // Current level of the farmer
                    farmerMaxLevel,             // Maximum level the farmer can achieve
                    farmerBaseCapacity,         // Base capacity for carrying crops
                    farmerBasePrice,            // Base price for upgrading the farmer
                    farmerPriceFactor,          // Price increase factor for upgrades
                    farm,                       // The farm assigned to the farmer
                    this                        // Reference to the current silo
                );

                // Add the created FarmerData to the farmer database
                farmerDatabase.Add(farmerData);

                // Add an initial entry for the crop associated with the farm to the inventory with a count of 0.
                // This allows the SiloInfo to display the items that might be stored in this silo.
                inventory.AddItem(farm.CropData.ItemId, 0);

                // If the farmer level is greater than 0 (already hired), start a coroutine to spawn the farmer
                if (data.FarmerLevels[index] > 0) StartCoroutine(SpawnFarmer(index));
            }

            // Subscribe to the OnSaveGame event of the IslandManager instance to sync SiloData.
            IslandManager.Instance.OnSaveGame += (gameData) =>
            {
                // Find the saved silo data from the game data using the current siloId.
                var savedSiloData = gameData.SiloDatabase.FirstOrDefault(db => db.SiloId == siloId);

                // Check if there is existing silo data with the same siloId.
                if (savedSiloData != null)
                {
                    // If found, update the existing silo data with the current data.
                    savedSiloData = data;
                }
                else
                {
                    // If not found, add the current silo data to the SiloDatabase in the game data.
                    gameData.SiloDatabase.Add(data);
                }
            };
        }

        void OnTriggerEnter(Collider other)
        {
            if (other.CompareTag("Player"))
            {
                // Retrieve the PlayerController component
                player = other.GetComponent<PlayerController>();

                // Display the silo information UI (SiloInfo) at the current position of the silo.
                UIManager.Instance.SiloInfo.Show(transform.position, inventory.Items, capacity);
            }
        }

        void OnTriggerExit(Collider other)
        {
            if (other.CompareTag("Player"))
            {
                // Set the player reference to null, as the player is no longer within the trigger.
                player = null;

                // Hide the silo information UI, as the player has exited the trigger area.
                UIManager.Instance.SiloInfo.Hide();
            }
        }

        void Update()
        {
            // Exit early if no player is currently assigned.
            if (player == null) return;

            // Check if the player is near the silo (within nearDistance).
            if (IsPlayerNear())
            {
                // If the player is near and there are crops stored in silo (items exist in the inventory),
                if (inventory.SumItems() > 0)
                {
                    // If the player is not currently withdrawing crops or upgrading,
                    // start the coroutine to withdraw crops.
                    if (!isWithdrawing && !isUpgrading) StartCoroutine(WithdrawCrop());
                }
                else
                {
                    // If the inventory is empty and the player is not upgrading,
                    // display the upgrade option.
                    if (!isUpgrading) ShowUpgrade();
                }
            }
            else
            {
                // If the player is not near and the upgrade option is currently shown,
                // hide the upgrade option.
                if (isUpgrading) HideUpgrade();
            }
        }

        public void Animate(bool instant, System.Action onFinished)
        {
            if (instant)
            {
                transform.localScale = Vector3.one;
                onFinished?.Invoke();
            }
            else
            {
                transform.DOScale(Vector3.one, 1f)
                    .SetEase(Ease.OutBounce)
                    .OnComplete(() => onFinished?.Invoke());
            }
        }

        bool IsPlayerNear()
        {
            float distance = Vector3.Distance(player.transform.position, transform.position);
            return distance <= nearDistance;
        }

        void ShowUpgrade()
        {
            // Define an action for upgrading the silo.
            // This will be called when the player confirms the silo upgrade.
            System.Action onSiloUpgrade = () =>
            {
                // Deduct the upgrade price from the player's coins.
                IslandManager.Instance.Coin -= upgradePrice;

                // Increment the silo level in the data.
                data.SiloLevel++;

                // Refresh the upgrade UI to reflect the new silo level and upgrade price.
                ShowUpgrade();

                // Play a sound effect to indicate the purchase.
                AudioManager.Instance.PlaySFX(AudioID.Cash);
            };

            // Define an action for upgrading a farmer.
            // This will be called when the player confirms a farmer upgrade.
            System.Action<int> onFarmerUpgrade = (index) =>
            {
                // Retrieve the farmer data for the specified index.
                var farmer = farmerDatabase[index];

                // If the farmer's level is 0 (not hired), start the coroutine to spawn the farmer.
                if (farmer.Level == 0) StartCoroutine(SpawnFarmer(index));

                // Deduct the farmer's upgrade price from the player's coins.
                IslandManager.Instance.Coin -= farmer.UpgradePrice;

                // Increment the farmer's level and the corresponding entry in the silo data.
                farmer.Level++;
                data.FarmerLevels[index]++;

                // Refresh the upgrade UI to reflect the new farmer level and upgrade price.
                ShowUpgrade();

                // Play a sound effect to indicate the purchase.
                AudioManager.Instance.PlaySFX(AudioID.Cash);
            };

            // Show the silo upgrade UI with the current silo level, capacity, upgrade price,
            // and the actions defined for silo and farmer upgrades.
            UIManager.Instance.SiloUpgrade.Show(data.SiloLevel, capacity, upgradePrice, onSiloUpgrade,
                farmerDatabase, onFarmerUpgrade
            );

            // Set the upgrading flag to true to indicate that the upgrade UI is currently active.
            isUpgrading = true;

            // Hide the silo information UI (SiloInfo) since the upgrade UI is now visible.
            UIManager.Instance.SiloInfo.Hide();

            // Activate the virtual camera to focus on the silo.
            virtualCamera.gameObject.SetActive(true);
        }

        void HideUpgrade()
        {
            UIManager.Instance.SiloUpgrade.Hide();

            // Set the upgrading flag to false to indicate that the upgrade UI is no longer active.
            isUpgrading = false;

            // Show the silo information UI (SiloInfo) at the silo position,
            // This re-displays the silo information now that the upgrade UI is hidden.
            UIManager.Instance.SiloInfo.Show(transform.position, inventory.Items, capacity);

            // Deactivate the virtual camera, which was focused on the silo.
            virtualCamera.gameObject.SetActive(false);
        }

        IEnumerator SpawnFarmer(int index)
        {
            // Wait until the NavMesh is available for the island to ensure proper farmer spawning.
            yield return new WaitUntil(() => IslandManager.Instance.HasNavMesh);

            // Get the position of the island to determine where to spawn the farmer.
            var islandPos = GetComponentInParent<Island>().GetPosition();

            // Instantiate a new farmer prefab at the island's position with the current silo's rotation.
            var farmer = Instantiate(farmerPrefab, islandPos, transform.rotation);

            // Name the newly instantiated farmer for identification purposes.
            farmer.gameObject.name = $"Farmer_{index}_{islandPos}";

            // Initialize the newly instantiated farmer with the data from the farmer database.
            farmer.Initialize(farmerDatabase[index]);
        }

        public bool DepositCrop(string itemId)
        {
            // Check if the inventory has reached its capacity for the specified item.
            if (inventory.CountItem(itemId) >= capacity) return false;

            // Add the specified item to the inventory.
            inventory.AddItem(itemId);

            // If there is a player present, update the silo information UI with the current inventory items and capacity.
            if (player != null)
                UIManager.Instance.SiloInfo.UpdateCropInfos(inventory.Items, capacity);

            // Return true to indicate that the crop was successfully deposited.
            return true;
        }

        IEnumerator WithdrawCrop()
        {
            // Set the flag indicating that a withdrawal process is in progress.
            isWithdrawing = true;

            // Initialize variables to track the elapsed time and pitch settings for sound effects.
            float elapsedTime = 0f;
            float initialPitch = 1f;
            float finalPitch = 3f;

            // Loop while the player is present, there are crops in silo, and the elapsed time is less than the maximum allowed withdraw time.
            while (player != null && inventory.SumItems() > 0 && elapsedTime < maxWithdrawTime)
            {
                // Get the first crop item in the inventory with a non-zero amount.
                var cropItem = inventory.Items.FirstOrDefault(i => i.Amount > 0);

                // Calculate the ratio of elapsed time to the maximum withdraw time.
                float timeRatio = Mathf.Clamp01(elapsedTime / maxWithdrawTime);
                float remainingTime = maxWithdrawTime - elapsedTime;

                // Determine the amount of crop to withdraw, ensuring it's at least 1 and does not exceed the crop item's available amount.
                int deductionAmount = Mathf.Max(1, Mathf.RoundToInt((cropItem.Amount * (1 - timeRatio)) / remainingTime));
                int actualDeduction = Mathf.Min(deductionAmount, cropItem.Amount);

                // Add the deducted amount to the player's inventory.
                player.Inventory.AddItem(cropItem.ItemId, actualDeduction);

                // Subtract the deducted amount from the silo inventory.
                inventory.SubtractItem(cropItem.ItemId, actualDeduction, false);

                // Update the silo information UI with the current inventory state.
                UIManager.Instance.SiloInfo.UpdateCropInfos(inventory.Items, capacity);

                // Calculate the current pitch for the sound effect based on the time ratio.
                float currentPitch = Mathf.Lerp(initialPitch, finalPitch, timeRatio);

                // Play the sound effect with the current pitch.
                AudioManager.Instance.PlaySFX(AudioID.Pop, pitch: currentPitch);

                // Spawn a crop object from the pool and position it above the ground.
                var crop = PoolManager.Instance.SpawnObject(cropItem.Data.Drop.name).transform;
                crop.position = transform.TransformPoint(Vector3.up * 2f);

                AnimateCrop(crop);

                // Wait for a short period before continuing the loop.
                yield return new WaitForSeconds(0.05f);

                // Increment the elapsed time by the time taken for this frame.
                elapsedTime += Time.deltaTime;
            }

            // Reset the flag to indicate that the withdrawal process is complete.
            isWithdrawing = false;
        }

        void AnimateCrop(Transform crop)
        {
            Vector3 siloFront = transform.TransformPoint(Vector3.forward * 3f);
            Vector3 randomPos = (siloFront + Random.insideUnitSphere).Flatten();

            crop.DOJump(randomPos, 2f, 1, 0.5f)
                .SetEase(Ease.InQuad)
                .OnComplete(() =>
                {
                    crop.DOJump(crop.position, 1f, 1, 0.5f)
                        .SetEase(Ease.OutBounce)
                        .OnComplete(() =>
                        {
                            PoolManager.Instance.ReturnObject(crop.gameObject);
                        });
                });
        }
    }

    public class FarmerData
    {
        public int Level { get; set; }

        private int maxLevel;
        private int baseCapacity;
        private int basePrice;
        private float priceFactor;

        public int Capacity => baseCapacity + (Level * 10);
        public int UpgradePrice => CalculateUpgradePrice();
        public Farm Farm { get; private set; }
        public Silo Silo { get; private set; }
        public Vector3Int FarmIslandPosition { get; private set; }
        public Vector3Int SiloIslandPosition { get; private set; }

        public FarmerData(int level, int maxLevel, int baseCapacity, int basePrice, float priceFactor, Farm farm, Silo silo)
        {
            Level = level;
            this.maxLevel = maxLevel;
            this.baseCapacity = baseCapacity;
            this.basePrice = basePrice;
            this.priceFactor = priceFactor;
            Farm = farm;
            Silo = silo;

            FarmIslandPosition = IslandManager.Instance.GetCurrentIsland(farm.transform.position).GetPosition();
            SiloIslandPosition = IslandManager.Instance.GetCurrentIsland(silo.transform.position).GetPosition();
        }

        private int CalculateUpgradePrice()
        {
            if (Level >= maxLevel) return -1;
            return (int)(basePrice * Mathf.Pow(priceFactor, Level));
        }
    }
}