using System;
using System.Collections;
using System.Collections.Generic;
using PixelCrushers.QuestMachine;
using Sirenix.OdinInspector;
using UnityEngine;
using UnityEngine.Events;

namespace Beyond
{
    public class PlayerConfessionController : MonoBehaviour
    {
        [SerializeField] private List<Quest> m_guilts = new List<Quest>();

        private QuestJournal m_questJournal;

        private List<string> m_guiltsToBeForgiven = new List<string>();
        private List<string> m_guiltsNotForgiven = new List<string>();
        private static readonly string BP_STR = "BrightnessPoints";

        public List<Quest> Guilts
        {
            get { return m_guilts; }
        }

        public void LoadGuilts()
        {
            m_guilts = GetRedeemableGuiltsFromQuestDB();
        }

        private void Awake()
        {
            m_questJournal = GetComponent<QuestJournal>();
        }

        private void OnEnable()
        {
            StartCoroutine(AddGuiltAddedListenerCoroutine());
        }

        //because saver on each load would remove bp as quests are added per load
        private IEnumerator AddGuiltAddedListenerCoroutine()
        {
            yield return null;
            yield return null;
            yield return null;
            m_questJournal.questAdded += AddGuiltInternal;
        }

        private void OnDisable()
        {
            m_questJournal.questAdded -= AddGuiltInternal;
        }

        private List<Quest> GetAllGuiltsFromQuestDB()
        {
            if (!m_questJournal)
            {
                Debug.LogError("There is no Players Journal component on player game object");
                return null;
            }

            List<Quest> guilts = new List<Quest>();

            for (int i = 0; i < m_questJournal.questList.Count; i++)
            {
                Quest quest = m_questJournal.questList[i];
                if (quest.isTrackable == false) // if in future will be not trackable quest we also should check quest group
                {
                    guilts.Add(m_questJournal.questList[i]);
                    //m_guilts.Add(quest);
                    //AddGuilt(m_questJournal.questList[i]);
                }
            }

            return guilts;
        }

        public List<Quest> GetRedeemableGuiltsFromQuestDB()
        {
            if (!m_questJournal)
            {
                Debug.LogError("There is no Players Journal component on player game object");
                return null;
            }

            List<Quest> guilts = new List<Quest>();

            for (int i = 0; i < m_questJournal.questList.Count; i++)
            {
                Quest quest = m_questJournal.questList[i];
                if (quest.isTrackable == false && quest.GetState() != QuestState.Abandoned)
                {
                    Debug.Log(quest.GetState());
                    guilts.Add(m_questJournal.questList[i]);
                    // AddGuiltInternal(quest);
                }
            }

            return guilts;
        }

        private int GetBrightnessPoints(Quest guilt)
        {
            var ctr = guilt.GetCounter(BP_STR);
            if (ctr == null)
            {
                Debug.LogError("No BrightnessPoints set for guilt: " + guilt.name);
                return 0;
            }

            return ctr.currentValue;
        }

        public Quest GetGuilt(string id)
        {
            return m_guilts.Find(guilt => guilt.id.text == id && guilt.GetState() != QuestState.Abandoned);
        }

        [Button]
        public void RedeemGuilt(string id)
        {
            Quest guilt = GetGuilt(id);
            if (guilt)
            {
                m_guiltsToBeForgiven.Add(guilt.id.value);
            }
        }

        [Button]
        public void RememberGuilt(string id)
        {
            Quest guilt = GetGuilt(id);
            if (guilt)
            {
                m_guiltsNotForgiven.Add(guilt.id.value);
            }
        }

        [Button]
        public void SummarizeGuilts()
        {
            //total value of all guilts, used to calculate weighted avarage
            //  float totalBrightnessLost = 0f;
            float totalBrightnessToForgive = 0f;

            for (int i = 0; i < m_guiltsToBeForgiven.Count; i++)
            {
                var guilt = GetGuilt(m_guiltsToBeForgiven[i]);
                if (guilt)
                {
                    var bp = (float)GetBrightnessPoints(guilt);
                    //  totalBrightnessLost += bp;
                    totalBrightnessToForgive += bp;
                    guilt.SetState(QuestState.Abandoned);
                }
            }

            //for (int i = 0; i < m_guiltsNotForgiven.Count; i++)
            //{
            //    var guilt = GetGuilt(m_guiltsNotForgiven[i]);
            //    if (guilt)
            //    {
            //        totalBrightnessLost += (float)GetBrightnessPoints(guilt);
            //        // guilt.SetState(QuestState.Failed);
            //    }
            //}
            double playerBP = Player.Instance.GetBrightness();
            double bPToGain = 0;
            double bPRest = 0;

            //give halved bp over 50
            if ((playerBP + totalBrightnessToForgive) > 50)
            {
                bPToGain = 50 - playerBP;
                bPRest = totalBrightnessToForgive - bPToGain;
                bPRest /= 2;
                bPToGain += bPRest;
            }
            else
            {
                bPToGain = totalBrightnessToForgive;
            }
            //  Debug.LogError("player bp: " + playerBP + " total bp to forgive " + totalBrightnessToForgive + " final gain " + bPToGain);
            Player.Instance.SetBrightness(playerBP + bPToGain);
            //  Player.Instance.UpdateBrightnessCurrentValue((float)bPToGain);

            m_guiltsToBeForgiven.Clear();
            m_guiltsNotForgiven.Clear();
        }

        public void AddGuilt(Quest quest)
        {
            m_questJournal.AddQuest(quest);
        }

        private void AddGuiltInternal(Quest quest)
        {
            if (quest.isTrackable  /*|| m_guilts.ContainsKey(quest.id.value)*/)
            {
                return;
            }

            quest.stateChanged += OnGuiltStateChanged;
            quest.SetState(QuestState.Active);
        }

        [Button]
        public void OnGuiltStateChanged(Quest guilt)
        {
            switch (guilt.GetState())
            {
                case QuestState.WaitingToStart:
                    break;

                case QuestState.Active:
                    //remove brightness points for this guilt
                    var bp = GetBrightnessPoints(guilt);
                    if (bp != 0)
                    {
                        Player.Instance.UpdateBrightnessCurrentValue(-bp);
                        guilt.stateChanged -= OnGuiltStateChanged;
                    }

                    break;

                case QuestState.Successful:
                    break;

                case QuestState.Failed:
                    break;

                case QuestState.Abandoned:
                    break;

                case QuestState.Disabled:
                    break;
            }
        }
    }
}