using Kryz.CharacterStats.Examples;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class BuildLibrary : MonoBehaviour
{
    #region Singleton
    private static BuildLibrary _instance;

    // Public reference to the singleton instance
    public static BuildLibrary Instance
    {
        get
        {
            // If the instance doesn't exist, try to find it in the scene
            if (_instance == null)
            {
                _instance = FindObjectOfType<BuildLibrary>();

                // If it's still null, create a new GameObject and add the component
                if (_instance == null)
                {
                    GameObject singletonObject = new GameObject(typeof(BuildLibrary).Name);
                    _instance = singletonObject.AddComponent<BuildLibrary>();
                }
            }
            return _instance;
        }
    }
    #endregion

    [SerializeField] private GameEvent_Int onAbilityTomePageLearned;
    [SerializeField] private GameEvent_Int onAbilityUnlocked;

    [SerializeField] private Item abilityTomePageTemplate;

    [SerializeField] private GameEventListener onPlayerNameConfirmed;
    [SerializeField] private GameEventListener_PhotonView onPlayerSpawned;

    public List<ClassBuildLibrary> classBuildLibraries = new List<ClassBuildLibrary>();


    public List<AbilityTomePageInstance> abilityTomeInstances = new List<AbilityTomePageInstance>();

    public Dictionary<GameTag, List<AbilityTomePageInstance>> classSpecificTomeInstances = new Dictionary<GameTag, List<AbilityTomePageInstance>>();

    private List<AbilityTomePageInstance> stillLockedAbilityTomePages = new List<AbilityTomePageInstance>();

    AbilityTomePageInstance initAbilityTomePageInstance;

    public GameTag currentPlayerClass;

    //runtime optimized search helper
    private Dictionary<GameTag, List<BaseAbility>> classAbilitiesDictionary = new Dictionary<GameTag, List<BaseAbility>>();
    private List<BaseAbility> unlockedAbilities = new List<BaseAbility>();

    private void Awake()
    {
        onPlayerNameConfirmed.Response.AddListener(SetupPlayerLibrary);
        onPlayerSpawned.Response.AddListener((photonView) =>
        {
            if (!photonView.IsMine) return;

            currentPlayerClass = photonView.GetComponent<RiftPlayer>().classTag;
        });
    }

    public void OnAbilityUnlocked(int abilityIndex)
    {
        Debug.Log("Unlocked new ability: " + AbilityIndexer.Instance.Abilities[abilityIndex].displayName);
        onAbilityUnlocked.Raise(abilityIndex);
    }

    private void SetupPlayerLibrary()
    {
        for (int i = 0; i < classBuildLibraries.Count; i++)
        {
            classSpecificTomeInstances.Add(classBuildLibraries[i].characterClass, new List<AbilityTomePageInstance>());
            classAbilitiesDictionary.Add(classBuildLibraries[i].characterClass, classBuildLibraries[i].possibleClassAbilities);

            for (int j = 0; j < classBuildLibraries[i].possibleClassAbilities.Count; j++)
            {
                if (j == 0)
                {
                    PlayerDataHandler.Instance.SaveAbilityTomeProgress(PlayerDataHandler.Instance.currentPlayerName.Value, AbilityIndexer.Instance.Abilities.IndexOf(classBuildLibraries[i].possibleClassAbilities[j]), 10, true);
                }
                initAbilityTomePageInstance = new AbilityTomePageInstance(classBuildLibraries[i].possibleClassAbilities[j], abilityTomePageTemplate, onAbilityTomePageLearned);
                abilityTomeInstances.Add(initAbilityTomePageInstance);
                classSpecificTomeInstances[classBuildLibraries[i].characterClass].Add(initAbilityTomePageInstance);

                if(i != 0) //add non-human to possible human playable abilities
                {
                    classAbilitiesDictionary[classBuildLibraries[0].characterClass].Add(classBuildLibraries[i].possibleClassAbilities[j]);
                }
            }
        }
    }

    public AbilityTomePageInstance GetRandomLockedAbilityTomePageInstance()
    {
        stillLockedAbilityTomePages.Clear();

        for (int i = 0; i < abilityTomeInstances.Count; i++)
        {
            if (PlayerDataHandler.Instance.AbilityTomeUnlocked(PlayerDataHandler.Instance.currentPlayerName.Value, abilityTomeInstances[i].abilityIndex))
            {
                continue;
            }
            else
            {
                stillLockedAbilityTomePages.Add(abilityTomeInstances[i]);
            }
        }
        if (stillLockedAbilityTomePages.Count <= 0)
            return null;

        return stillLockedAbilityTomePages[Random.Range(0, stillLockedAbilityTomePages.Count)];
    }
    public AbilityTomePageInstance GetRandomLockedAbilityTomePageInstanceFromSpecificClass()
    {
        //if (currentPlayerClass.name.ToLower().Contains("human"))
        //    return GetRandomLockedAbilityTomePageInstance();

        stillLockedAbilityTomePages.Clear();

        for (int i = 0; i < classSpecificTomeInstances[currentPlayerClass].Count; i++)
        {
            if (PlayerDataHandler.Instance.AbilityTomeUnlocked(PlayerDataHandler.Instance.currentPlayerName.Value, classSpecificTomeInstances[currentPlayerClass][i].abilityIndex))
            {
                continue;
            }
            else
            {
                stillLockedAbilityTomePages.Add(classSpecificTomeInstances[currentPlayerClass][i]);
            }
        }

        if (stillLockedAbilityTomePages.Count <= 0)
            return GetRandomLockedAbilityTomePageInstance();

        return stillLockedAbilityTomePages[Random.Range(0, stillLockedAbilityTomePages.Count)];
    }

   /* public List<BaseAbility> GetBaseAbilities(GameTag characterClass)
    {
        for (int i = 0; i < classBuildLibraries.Count; i++)
        {
            if (classBuildLibraries[i].characterClass == characterClass)
                return classBuildLibraries[i].possibleClassAbilities;
        }
        return null;
    }*/

    public List<BaseAbility> GetUnlockedBaseAbilities(GameTag characterClass)
    {
        unlockedAbilities.Clear();

        for (int i = 0; i < classAbilitiesDictionary[characterClass].Count; i++)
        {
            if (PlayerDataHandler.Instance.AbilityTomeUnlocked(PlayerDataHandler.Instance.currentPlayerName.Value, AbilityIndexer.Instance.Abilities.IndexOf(classAbilitiesDictionary[characterClass][i])))
            {
                unlockedAbilities.Add(classAbilitiesDictionary[characterClass][i]);
            }
        }

        return unlockedAbilities;
    }

    public GameTag GetClassBasedOnAbility(BaseAbility classAbility)
    {
        foreach (GameTag gameTag in classAbilitiesDictionary.Keys)
        {
            if (gameTag.name.ToLower().Contains("human")) continue;

            if(classAbilitiesDictionary[gameTag].Contains(classAbility))
            {
                return gameTag;
            }
        }
        return null;
    }
}