using System;
using System.Collections;
using System.Collections.Generic;
using PixelCrushers;
using PixelCrushers.DialogueSystem;
using Sirenix.OdinInspector;
using Sirenix.Utilities;
using UnityEngine;
using Random = UnityEngine.Random;

namespace Beyond
{
    public class BarkManager : Saver
    {
        [Serializable]
        public class Bark
        {
            [Tooltip("Conversation to get bark content from.")]
            [ConversationPopup(false)]
             public string barkConversation = string.Empty;
            public string barkText;
            public AudioClip clip;
        }

        [Serializable]
        public class BarkEntry
        {
            public bool playOnce = true;
            public float delayToStart = 0f;
            public Bark[] barks;
        }

        [ListDrawerSettings(DraggableItems = true, Expanded = false, ShowIndexLabels = true, ShowPaging = false, ShowItemCount = true, HideRemoveButton = true)]
        public BarkEntry[] m_barks;

        [Serializable]
        public class SaveData
        {
            public bool[] wasPlayed;
        }

        public SaveData m_saveData = new SaveData();
        public Queue<int> m_barkQueue = new Queue<int>();
        public AudioSource m_audioSource;

        private Dictionary<string, int> m_conversationToEntry = new Dictionary<string, int>();

        private static BarkManager s_instance;

        public static BarkManager Instance => s_instance;

        public override void Awake()
        {
            base.Awake();
            if (s_instance != null) 
            {
                Debug.LogError("BarkManager instance already exists! destroying...");
                Destroy(this);
            }
            else
            {
                s_instance = this;
            }
        }

        public void PlayBark(int num)
        {
            m_barkQueue.Enqueue(num);
            /*
            if (num >= 0 && num < m_barks.Length)
            {
                if (Player.Instance == null)
                    return;
                var bark = m_barks[num];
                if (bark.playOnce && m_saveData.wasPlayed[num])
                {
                    return;
                }

                if (bark.barks != null && m_barks.Length > 0)
                {
                    var b = bark.barks[Random.Range(0, bark.barks.Length)];
                    if (b.clip != null)
                    {
                        Player.Instance.AudioSource.clip = b.clip;
                        Player.Instance.AudioSource.Play();
                    }
                    if (!string.IsNullOrEmpty(b.barkText))
                    {
                        DialogueManager.BarkString(b.barkText, Player.Instance.transform);
                    }
                }

                m_saveData.wasPlayed[num] = true;
            }
            */
        }

        public void PlayBark(string conversation)
        {
            if (m_conversationToEntry.ContainsKey(conversation))
            {
                m_barkQueue.Enqueue(m_conversationToEntry[conversation]);

            }
            else
            {
                Debug.LogError("BarkManager: Conversation not found: "+conversation, this);
            }
        }

        //private AudioSource audioSourceLast;
        //private GameObject audioSource => Player.Instance.audioSource;

        private void PlayInternal(int num)
        {
            if (num >= 0 && num < m_barks.Length)
            {
                if (Player.Instance == null)
                    return;
                var bark = m_barks[num];
                if (bark.playOnce && m_saveData.wasPlayed[num])
                {
                    return;
                }

                if (bark.barks != null && m_barks.Length > 0)
                {
                    if (bark.delayToStart > 0)
                    {
                        StartCoroutine(PlayBarkWithDelayCoroutine(bark));
                    }
                    else
                    {
                        PlayBarkImmediately(bark);
                    }
                }

                m_saveData.wasPlayed[num] = true;
            }
        }

        private IEnumerator PlayBarkWithDelayCoroutine(BarkEntry bark)
        {
            yield return new WaitForSecondsRealtime(bark.delayToStart);
            PlayBarkImmediately(bark);
        }

        private void PlayBarkImmediately(BarkEntry bark)
        {
            var b = bark.barks[Random.Range(0, bark.barks.Length)];
            if (b.clip != null)
            {
                //GameObject audioObject = Instantiate(audioSource, Player.Instance.transform.position, transform.rotation) as GameObject;
                //audioSourceLast = audioObject.GetComponent<AudioSource>();
                m_audioSource.PlayOneShot(b.clip);
            }
            if (!string.IsNullOrWhiteSpace(b.barkConversation))
            {
                DialogueManager.Bark(b.barkConversation,  Player.Instance.transform);
            }
            if (!string.IsNullOrEmpty(b.barkText))
            {
                DialogueManager.BarkString(b.barkText, Player.Instance.transform);
            }
        }

        public bool CanBarkBeStillPlayed(int barkNum)
        {
            return !(m_saveData.wasPlayed[barkNum] && m_barks[barkNum].playOnce);
        }

        // Start is called before the first frame update
        private void Start()
        {
            if (m_audioSource == null)
            {
                m_audioSource = GetComponent<AudioSource>();
            }

            if (m_audioSource == null)
            {
                m_audioSource = gameObject.AddComponent<AudioSource>();
            }
            
            m_saveData.wasPlayed = new bool[m_barks.Length];
            for (int i = 0; i < m_saveData.wasPlayed.Length; i++)
                m_saveData.wasPlayed[i] = false;
            for  (int i=0; i<m_barks.Length; i++)
            {
                var b = m_barks[i];
                if (b.barks.Length == 1 && !b.barks[0].barkConversation.IsNullOrWhitespace())
                {
                    m_conversationToEntry[b.barks[0].barkConversation] = i;
                }
            }
        }

        public override string RecordData()
        {
            return SaveSystem.Serialize(m_saveData);
        }

        public override void ApplyData(string s)
        {
            var sd = SaveSystem.Deserialize<SaveData>(s);
            if (sd != null)
            {
                m_saveData = sd;
            }
        }

        private void Update()
        {
            if (m_audioSource && m_audioSource.isPlaying)
                return;
            if (m_barkQueue.Count > 0)
            {
                int barkId = m_barkQueue.Dequeue();
                PlayInternal(barkId);
            }
        }
    }
}