//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Saturday, December 09, 2017
//--------------------------------------------------------
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using UnityEngine.UI;
using TableConfig;

namespace Snxxz.UI
{

    public class NPCDialogueBubble : DialogueBubble
    {
        static Dictionary<int, Dictionary<int, NpcDialogue>> npcDialogues = new Dictionary<int, Dictionary<int, NpcDialogue>>();

        static DungeonModel m_DungeonModel;
        static DungeonModel dungeonModel {
            get { return m_DungeonModel ?? (m_DungeonModel = ModelCenter.Instance.GetModel<DungeonModel>()); }
        }

        public static DialogueBubble TimingShow(int _npcId, Transform _target, Camera _camera)
        {
            var dataMapId = dungeonModel.GetDataMapIdByMapId(PlayerDatas.Instance.baseData.MapID);
            var dialogue = GetDialogue(_npcId, dataMapId);
            if (dialogue == null)
            {
                dialogue = GetDialogue(_npcId, 0);
            }

            if (dialogue == null)
            {
                return null;
            }

            if (!dialogue.hasDialogue)
            {
                return null;
            }

            DialogueBubble bubble = null;
            if (dialogue.timeAble && Random.Range(0, dialogue.countInterval) == 0)
            {
                bubble = PackageDialogue(_npcId);
                bubble.Show(dialogue.config.Dialogues[dialogue.index], _target, _camera);
                dialogue.index++;
                dialogue.lastDialogueTime = Time.time;
            }

            dialogue.intervalBuf++;
            return bubble;
        }

        static NpcDialogue GetDialogue(int _npcId, int _dataMapId)
        {
            if (FindConfig(_npcId, _dataMapId) == null)
            {
                return null;
            }

            NpcDialogue dialogue = null;
            if (npcDialogues.ContainsKey(_npcId))
            {
                var dataMapDialogues = npcDialogues[_npcId];
                if (dataMapDialogues.ContainsKey(_dataMapId))
                {
                    dialogue = dataMapDialogues[_dataMapId];
                }
                else
                {
                    dialogue = dataMapDialogues[_dataMapId] = new NpcDialogue(_npcId, _dataMapId);
                }
            }
            else
            {
                var dataMapDialogues = npcDialogues[_npcId] = new Dictionary<int, NpcDialogue>();
                dialogue = dataMapDialogues[_dataMapId] = new NpcDialogue(_npcId, _dataMapId);
            }

            return dialogue;
        }

        static DialogueBubble PackageDialogue(int _npcId)
        {
            DialogueBubble bubble = null;
            bubble = DialogueBubblePool.Require(Pattern.NPC);
            bubble.transform.SetParentEx(WindowCenter.Instance.uiRoot.nameCanvas, Vector3.zero, Vector3.zero, Vector3.one);
            bubble.gameObject.SetActive(true);

            return bubble;
        }

        public static void Recyle(DialogueBubble _bubble)
        {
            DialogueBubblePool.Recycle(_bubble);
        }

        static List<NPCDialogueConfig> m_NpcDialogueConfigs;
        static List<NPCDialogueConfig> npcDialogueConfigs { get { return m_NpcDialogueConfigs ?? (m_NpcDialogueConfigs = Config.Instance.GetAllValues<NPCDialogueConfig>()); } }

        public static NPCDialogueConfig FindConfig(int _npcId, int _dataMapId)
        {
            foreach (var config in npcDialogueConfigs)
            {
                if (config.NPCID == _npcId && config.DataMapId == _dataMapId)
                {
                    return config;
                }
            }

            return null;
        }

    }

    class NpcDialogue
    {
        public readonly bool hasDialogue = false;

        int dialogueContentLength;
        public int countInterval;
        float timeInterval = 5f;

        int m_Index = 0;
        public int index {
            get { return m_Index; }
            set {
                if (value >= dialogueContentLength)
                {
                    m_Index = 0;
                }
                else
                {
                    m_Index = value;
                }
            }
        }

        int m_IntervalBuf = 0;
        public int intervalBuf {
            get { return m_IntervalBuf; }
            set {
                if (value >= countInterval)
                {
                    m_IntervalBuf = 0;
                }
                else
                {
                    m_IntervalBuf = value;
                }
            }
        }

        float m_LastDialogueTime = 0f;
        public float lastDialogueTime {
            get { return m_LastDialogueTime; }
            set { m_LastDialogueTime = value; }
        }

        public NPCDialogueConfig config { get; private set; }

        public NpcDialogue(int _npcId, int _dataMapId)
        {
            config = NPCDialogueBubble.FindConfig(_npcId, _dataMapId);
            hasDialogue = config != null && config.Interval != 0;
            if (config != null)
            {
                timeInterval = config.NextTime;
                countInterval = config.Interval;
                dialogueContentLength = config.Dialogues.Length;
            }
            else
            {
                timeInterval = 5f;
                countInterval = 10;
                dialogueContentLength = 0;
            }

            index = 0;
            m_IntervalBuf = 0;
        }

        public bool countAble {
            get { return m_IntervalBuf == 0; }
        }

        public bool timeAble {
            get { return Time.time > lastDialogueTime + timeInterval; }
        }

    }

}