using System.Collections;
using System.Collections.Generic;
using System.Threading.Tasks;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;

namespace BulletHellTemplate
{
    /// <summary>
    /// Manages the profile menu UI, including displaying player information and managing icon, frame selections, and audio settings.
    /// </summary>
    public class UIProfileMenu : MonoBehaviour
    {
        [Header("UI Elements")]
        [Tooltip("Text component to display the player's name.")]
        public TextMeshProUGUI playerName;
        
        [Tooltip("Image component to display the player's icon.")]
        public Image playerIcon;
        
        [Tooltip("Image component to display the player's frame.")]
        public Image playerFrame;

        [Header("UI Prefabs")]
        [Tooltip("Prefab for creating icon entries.")]
        public IconsEntry iconsEntryPrefab;
        
        [Tooltip("Prefab for creating frame entries.")]
        public FramesEntry framesEntryPrefab;
        
        [Tooltip("Container to hold dynamically created icon and frame entries.")]
        public Transform container;
        
        [Tooltip("Container GameObject for icons/frames.")]
        public GameObject containerPref;

        [Header("Change Name Components")]
        [Tooltip("Currency ID used for name change.")]
        public string changeNameTick = "TKN";
        
        [Tooltip("Minimum length for the player's name.")]
        public int minNameLength = 3;
        
        [Tooltip("Maximum length for the player's name.")]
        public int maxNameLength = 20;
        
        [Tooltip("Number of tickets required to change the player's name.")]
        public int ticketsToChange = 1;
        
        [Tooltip("Indicates if a ticket is required for name change.")]
        public bool needTicket;
        
        [Tooltip("UI prefab for the name change input screen.")]
        public GameObject changeNamePref;
        
        [Tooltip("Input field for entering a new name.")]
        public TMP_InputField changeNameInput;
        
        [Tooltip("UI component to display status messages (success/error).")]
        public TextMeshProUGUI statusText;

        [Header("Favorite character")]
        [Tooltip("Image to display mastery icon of the favorite character.")]
        public Image masteryIcon;
        
        [Tooltip("Image fill component to display mastery progress.")]
        public Image masteryProgressBar;
        
        [Tooltip("UI text to display current mastery experience.")]
        public TextMeshProUGUI currentMasteryExp;
        
        [Tooltip("UI text to display the mastery level name.")]
        public TextMeshProUGUI masteryName;
        
        [Tooltip("Container to hold the temporary favorite character model.")]
        public Transform tempCharacterContainer;

        [Header("UI Translations")]
        [Tooltip("Fallback message when there are not enough tickets to change the name.")]
        public string notEnoughTickets = "Not enough tickets to change the name.";
        [Tooltip("Translations for the message when there are not enough tickets to change the name.")]
        public NameTranslatedByLanguage[] notEnoughTicketsTranslated;

        [Tooltip("Fallback message when name length is invalid.")]
        public string nameLengthError = "Name must be between 3 and 14 characters.";
        [Tooltip("Translations for the message when name length is invalid.")]
        public NameTranslatedByLanguage[] nameLengthErrorTranslated;

        [Tooltip("Fallback message when the name is already taken.")]
        public string nameAlreadyTaken = "Name already taken.";
        [Tooltip("Translations for the message when the name is already taken.")]
        public NameTranslatedByLanguage[] nameAlreadyTakenTranslated;

        [Tooltip("Fallback message when the name is changed successfully.")]
        public string nameChangeSuccess = "Name changed successfully.";
        [Tooltip("Translations for the message when the name is changed successfully.")]
        public NameTranslatedByLanguage[] nameChangeSuccessTranslated;

        [Tooltip("Fallback message when there's an error changing the name.")]
        public string nameChangeFail = "Error changing name.";
        [Tooltip("Translations for the message when there's an error changing the name.")]
        public NameTranslatedByLanguage[] nameChangeFailTranslated;

        [Header("Events")]
        [Tooltip("Event invoked when the menu is opened.")]
        public UnityEvent OnOpenMenu;

        [Tooltip("Event invoked when the menu is closed.")]
        public UnityEvent OnCloseMenu;

        [Tooltip("Event invoked when the nickname is successfully changed.")]
        public UnityEvent OnChangeNickname;

        [Tooltip("Event invoked when the icon is successfully changed.")]
        public UnityEvent OnChangeIcon;

        [Tooltip("Event invoked when the frame is successfully changed.")]
        public UnityEvent OnChangeFrame;

        [Tooltip("Event invoked when a coupon is redeemed successfully.")]
        public UnityEvent OnRedeemCoupon;

        [Header("Audio Settings")]
        [Tooltip("Slider for adjusting master volume.")]
        public Slider masterVolumeSlider;
        
        [Tooltip("Slider for adjusting VFX volume.")]
        public Slider vfxVolumeSlider;
        
        [Tooltip("Slider for adjusting ambience volume.")]
        public Slider ambienceVolumeSlider;

        private string currentLang;
        private List<IconsEntry> iconsEntries = new List<IconsEntry>();
        private List<FramesEntry> framesEntries = new List<FramesEntry>();
        public static UIProfileMenu Singleton;

        /// <summary>
        /// Subscribes to language change events and sets up the singleton reference.
        /// </summary>
        private void Awake()
        {
            LanguageManager.LanguageManager.onLanguageChanged += UpdateText;
            Singleton = this;
        }

        /// <summary>
        /// Unsubscribes from language change events.
        /// </summary>
        private void OnDestroy()
        {
            LanguageManager.LanguageManager.onLanguageChanged -= UpdateText;
        }

        /// <summary>
        /// Initializes the UI menu when enabled.
        /// </summary>
        private void OnEnable()
        {
            currentLang = LanguageManager.LanguageManager.Instance.GetCurrentLanguage();
            OnOpenMenu.Invoke();
            DestroyTemporaryModel();
            LoadProfile();
            LoadFavoriteCharacter();
            UpdateText(); 
            SetupSliders();
        }

        /// <summary>
        /// Cleans up the UI menu when disabled.
        /// </summary>
        private void OnDisable()
        {
            DestroyTemporaryModel();
            OnCloseMenu.Invoke();
            UIMainMenu.Singleton.LoadPlayerInfo();
        }

        /// <summary>
        /// Called when the language is changed, forcing the UI to update translations.
        /// </summary>
        private void UpdateText()
        {
            currentLang = LanguageManager.LanguageManager.Instance.GetCurrentLanguage();
            LoadFavoriteCharacter();
        }

        /// <summary>
        /// Loads and displays the player's profile information, including name, icon, and frame.
        /// </summary>
        public void LoadProfile()
        {
            containerPref.SetActive(!containerPref.activeSelf); 
            string name = PlayerSave.GetPlayerName();
            playerName.text = !string.IsNullOrEmpty(name) ? name : "Unknown Player";

            string iconId = PlayerSave.GetPlayerIcon();
            string frameId = PlayerSave.GetPlayerFrame();

            SetPlayerIcon(iconId);
            SetPlayerFrame(frameId);
        }

        /// <summary>
        /// Sets initial slider values from the AudioManager (if available) and adds listeners.
        /// </summary>
        private void SetupSliders()
        {
            if (masterVolumeSlider != null)
            {
                masterVolumeSlider.onValueChanged.RemoveAllListeners();
                masterVolumeSlider.value = AudioManager.Singleton.masterVolume;
                masterVolumeSlider.onValueChanged.AddListener(OnMasterVolumeChanged);
            }

            if (vfxVolumeSlider != null)
            {
                vfxVolumeSlider.onValueChanged.RemoveAllListeners();
                vfxVolumeSlider.value = AudioManager.Singleton.vfxVolume;
                vfxVolumeSlider.onValueChanged.AddListener(OnVFXVolumeChanged);
            }

            if (ambienceVolumeSlider != null)
            {
                ambienceVolumeSlider.onValueChanged.RemoveAllListeners();
                ambienceVolumeSlider.value = AudioManager.Singleton.ambienceVolume;
                ambienceVolumeSlider.onValueChanged.AddListener(OnAmbienceVolumeChanged);
            }
        }

        /// <summary>
        /// Handles changes in the master volume slider.
        /// </summary>
        /// <param name="value">Volume value from 0 to 1.</param>
        public void OnMasterVolumeChanged(float value)
        {
            AudioManager.Singleton.masterVolume = value;
        }

        /// <summary>
        /// Handles changes in the VFX volume slider.
        /// </summary>
        /// <param name="value">Volume value from 0 to 1.</param>
        public void OnVFXVolumeChanged(float value)
        {
            AudioManager.Singleton.vfxVolume = value;
        }

        /// <summary>
        /// Handles changes in the ambience volume slider.
        /// </summary>
        /// <param name="value">Volume value from 0 to 1.</param>
        public void OnAmbienceVolumeChanged(float value)
        {
            AudioManager.Singleton.ambienceVolume = value;
        }

        /// <summary>
        /// Creates and displays icon entries in the container, clearing old entries first.
        /// </summary>
        public void LoadIcons()
        {
            foreach (Transform child in container)
            {
                Destroy(child.gameObject);
            }

            containerPref.SetActive(true);

            foreach (IconItem item in GameInstance.Singleton.iconItems)
            {
                if (MonetizationManager.Singleton.IsIconPurchased(item.iconId) || item.isUnlocked)
                {
                    IconsEntry iconEntry = Instantiate(iconsEntryPrefab, container);
                    iconEntry.SetIconInfo(item.iconId);
                    iconEntry.icon.sprite = item.icon;
                    string iconNameTranslatedName = GetTranslatedString(item.iconNameTranslated, item.iconName, currentLang);
                    iconEntry.iconName.text = iconNameTranslatedName;
                    iconsEntries.Add(iconEntry);
                }
            }
        }

        /// <summary>
        /// Creates and displays frame entries in the container, clearing old entries first.
        /// </summary>
        public void LoadFrames()
        {
            foreach (Transform child in container)
            {
                Destroy(child.gameObject);
            }

            containerPref.SetActive(true);

            foreach (FrameItem item in GameInstance.Singleton.frameItems)
            {
                if (MonetizationManager.Singleton.IsFramePurchased(item.frameId) || item.isUnlocked)
                {
                    FramesEntry frameEntry = Instantiate(framesEntryPrefab, container);
                    frameEntry.SetFrameInfo(item.frameId);
                    string frameNameTranslatedName = GetTranslatedString(item.frameNameTranslated,item.frameName, currentLang);
                    frameEntry.icon.sprite = item.icon;
                    frameEntry.frameName.text = frameNameTranslatedName;
                    framesEntries.Add(frameEntry);
                }
            }
        }

        /// <summary>
        /// Loads the player's favorite character data including mastery progress and 3D model.
        /// </summary>
        public void LoadFavoriteCharacter()
        {
            int favouriteCharacterId = PlayerSave.GetFavouriteCharacter();
            int currentMasteryLevel = PlayerSave.GetCharacterMasteryLevel(favouriteCharacterId);
            int currMasteryExp = PlayerSave.GetCharacterCurrentMasteryExp(favouriteCharacterId);

            CharacterMasteryLevel masteryInfo = GameInstance.Singleton.GetMasteryLevel(currentMasteryLevel);
            string masteryTranslatedName = GetTranslatedString(masteryInfo.masteryNameTranslated, masteryInfo.masteryName, currentLang);

            if (masteryName != null) masteryName.text = masteryTranslatedName;
            if (masteryIcon != null) masteryIcon.sprite = masteryInfo.masteryIcon;

            if (currentMasteryLevel < GameInstance.Singleton.characterMastery.maxMasteryLevel)
            {
                int requiredMasteryExp = GameInstance.Singleton.GetMasteryExpForLevel(currentMasteryLevel);
                if (currentMasteryExp != null) currentMasteryExp.text = $"{currMasteryExp}/{requiredMasteryExp}";
                if (masteryProgressBar != null) masteryProgressBar.fillAmount = (float)currMasteryExp / requiredMasteryExp;
            }
            else
            {
                if (currentMasteryExp != null) currentMasteryExp.text = $"{currMasteryExp}/MAX";
                if (masteryProgressBar != null) masteryProgressBar.fillAmount = 1f;
            }

            foreach (Transform child in tempCharacterContainer)
            {
                Destroy(child.gameObject);
            }

            CharacterData cd = GetCharacterDataById(favouriteCharacterId);
            if (cd != null && tempCharacterContainer != null)
            {
                int skinIndex = PlayerSave.GetCharacterSkin(cd.characterId);
                if (cd.characterSkins != null && cd.characterSkins.Length > 0 && skinIndex >= 0 && skinIndex < cd.characterSkins.Length)
                {
                    CharacterSkin skin = cd.characterSkins[skinIndex];
                    if (skin.skinCharacterModel != null)
                        Instantiate(skin.skinCharacterModel, tempCharacterContainer);
                }
                else if (cd.characterModel != null)
                {
                    Instantiate(cd.characterModel, tempCharacterContainer);
                }
            }
        }

        /// <summary>
        /// Handles the click event to open the name change UI.
        /// </summary>
        public void OnClickChangeName()
        {
            if (needTicket && MonetizationManager.GetCurrency(changeNameTick) < ticketsToChange)
            {
                DisplayStatusMessage(GetTranslatedString(notEnoughTicketsTranslated, notEnoughTickets, currentLang), Color.red);
                return;
            }

            changeNamePref.SetActive(true);
        }

        /// <summary>
        /// Processes the new name input and starts the coroutine to change the player's name.
        /// </summary>
        public void ProcessChangeName()
        {
            string newName = changeNameInput.text;

            if (string.IsNullOrEmpty(newName) || newName.Length < minNameLength || newName.Length > maxNameLength)
            {
                DisplayStatusMessage(GetTranslatedString(nameLengthErrorTranslated, nameLengthError, currentLang), Color.red);
                return;
            }

            StartCoroutine(ChangePlayerName(newName));
        }

        /// <summary>
        /// Coroutine to change the player's name, including validation and database update.
        /// </summary>
        /// <param name="newName">The new name to set.</param>
        private IEnumerator ChangePlayerName(string newName)
        {
            Task<bool> checkNameTask = BackendManager.Singleton.CheckIfNameExists(newName);
            yield return new WaitUntil(() => checkNameTask.IsCompleted);

            if (checkNameTask.Result)
            {
                DisplayStatusMessage(GetTranslatedString(nameAlreadyTakenTranslated, nameAlreadyTaken, currentLang), Color.red);
            }
            else
            {
                Task updateNameTask = BackendManager.Singleton.UpdatePlayerName(newName);
                yield return new WaitUntil(() => updateNameTask.IsCompleted);

                if (updateNameTask.Exception == null)
                {
                    DisplayStatusMessage(GetTranslatedString(nameChangeSuccessTranslated, nameChangeSuccess, currentLang), Color.white);
                    playerName.text = newName;
                    UIMainMenu.Singleton.LoadPlayerInfo();
                    OnChangeNickname.Invoke(); // Invoke event for successful name change

                    if (needTicket)
                    {
                        int currentTickets = MonetizationManager.GetCurrency(changeNameTick);
                        int newTickets = currentTickets - ticketsToChange;
                        MonetizationManager.SetCurrency(changeNameTick, newTickets);
                    }
                    changeNamePref.SetActive(false);
                }
                else
                {
                    DisplayStatusMessage(GetTranslatedString(nameChangeFailTranslated, nameChangeFail, currentLang), Color.red);
                }
            }
        }

        /// <summary>
        /// Retrieves character data by its ID.
        /// </summary>
        /// <param name="characterId">The ID of the character to retrieve.</param>
        /// <returns>Character data if found, otherwise null.</returns>
        private CharacterData GetCharacterDataById(int characterId)
        {
            if (GameInstance.Singleton == null || GameInstance.Singleton.characterData == null)
                return null;

            foreach (CharacterData item in GameInstance.Singleton.characterData)
                if (item.characterId == characterId)
                    return item;

            return null;
        }

        /// <summary>
        /// Destroys any temporary character models currently instantiated.
        /// </summary>
        private void DestroyTemporaryModel()
        {
            if (tempCharacterContainer == null) return;
            for (int i = tempCharacterContainer.childCount - 1; i >= 0; i--)
                Destroy(tempCharacterContainer.GetChild(i).gameObject);
        }

        /// <summary>
        /// Returns the translated string for the current language, or a fallback value if no translation is found.
        /// </summary>
        /// <param name="translations">Array of NameTranslatedByLanguage entries.</param>
        /// <param name="fallback">Fallback text in case the translation is not found.</param>
        /// <param name="currentLang">The current language ID.</param>
        /// <returns>A translated string if found, otherwise the fallback.</returns>
        private string GetTranslatedString(NameTranslatedByLanguage[] translations, string fallback, string currentLang)
        {
            if (translations != null)
            {
                foreach (var translation in translations)
                {
                    if (!string.IsNullOrEmpty(translation.LanguageId)
                        && translation.LanguageId.Equals(currentLang)
                        && !string.IsNullOrEmpty(translation.Translate))
                    {
                        return translation.Translate;
                    }
                }
            }
            return fallback;
        }

        /// <summary>
        /// Displays a status message with the specified color.
        /// </summary>
        /// <param name="message">The message to display.</param>
        /// <param name="color">The color of the message text.</param>
        private void DisplayStatusMessage(string message, Color color)
        {
            statusText.text = message;
            statusText.color = color;
            StartCoroutine(HideStatusMessageAfterDelay(statusText, 2f));
        }

        /// <summary>
        /// Coroutine to hide the status message after a specified delay.
        /// </summary>
        /// <param name="statusText">The UI text component used to display the message.</param>
        /// <param name="delay">Time in seconds before hiding the message.</param>
        private IEnumerator HideStatusMessageAfterDelay(TextMeshProUGUI statusText, float delay)
        {
            yield return new WaitForSeconds(delay);
            statusText.text = string.Empty;
        }

        /// <summary>
        /// Sets the player's icon based on the provided iconId.
        /// </summary>
        /// <param name="iconId">The ID of the icon to set.</param>
        private void SetPlayerIcon(string iconId)
        {
            foreach (IconItem item in GameInstance.Singleton.iconItems)
            {
                if (item.iconId == iconId)
                {
                    playerIcon.sprite = item.icon;
                    break;
                }
            }
        }

        /// <summary>
        /// Sets the player's frame based on the provided frameId.
        /// </summary>
        /// <param name="frameId">The ID of the frame to set.</param>
        private void SetPlayerFrame(string frameId)
        {
            foreach (FrameItem item in GameInstance.Singleton.frameItems)
            {
                if (item.frameId == frameId)
                {
                    playerFrame.sprite = item.icon;
                    break;
                }
            }
        }
    }
}