//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Monday, November 27, 2017
//--------------------------------------------------------
using UnityEngine;
using System.Collections;
using UnityEngine.UI;
using System.Collections.Generic;
using System;

namespace vnxbqy.UI
{
    
    public class FunctionalGuideCenter : Singleton<FunctionalGuideCenter>
    {
        public event Action<int> beginGuideEvent;
        public event Action<int> finishGuideEevent;
        public event Action<int> removeGuideEvent;

        List<int> underwayGuides = new List<int>();
        Dictionary<int, float> guideStartTimes = new Dictionary<int, float>();
        List<int> unfoldAreas = new List<int>();

        TaskModel taskmodel { get { return ModelCenter.Instance.GetModel<TaskModel>(); } }
        TreasureModel treasureModel { get { return ModelCenter.Instance.GetModel<TreasureModel>(); } }
        PlayerMainDate onMainModel { get { return ModelCenter.Instance.GetModel<PlayerMainDate>(); } }

        LogicUpdate update = new LogicUpdate();
        public FunctionalGuideCenter()
        {
            TaskModel.tryGetTaskAwardEvent += OnTryGetMainLineTaskReward;
            TaskModel.Event_MainlineTask += OnMainLineTaskUpdate;
            TaskModel.CardLevelChange += OnQuestLimitStateChange;
            TaskModel.SideQuestChangeEvent += OnBranchQuestStateChange;
            treasureModel.treasureStateChangeEvent += OnTreasureStateChange;
            taskmodel.taskDescriptionRefresh += OnMainLineDescriptionChange;
            update.Start(OnUpdate);
        }

        public void CheckGuides(int[] _guides)
        {
            for (int i = 0; i < _guides.Length; i++)
            {
                var guideId = _guides[i];
                if (NewBieCenter.Instance.completeGuidesBuf.Contains(guideId))
                {
                    continue;
                }

                if (underwayGuides.Contains(guideId))
                {
                    continue;
                }

                if (CheckGuideCondition(guideId))
                {
                    StartGuide(guideId);
                }
            }

        }

        public List<int> GetUnderwayGuides()
        {
            return new List<int>(underwayGuides);
        }

        public bool ExistAnyUnderwayGuide()
        {
            return underwayGuides != null && underwayGuides.Count > 0;
        }

        public bool ExistUnderwayGuide(int _guidId)
        {
            return underwayGuides != null && underwayGuides.Contains(_guidId);
        }

        public void StartGuide(int _id)
        {
            RemoveAllUnderWayGuide();
            underwayGuides.Add(_id);
            guideStartTimes[_id] = Time.time;
            UpdateUnfoldAreas();
            if (beginGuideEvent != null)
            {
                beginGuideEvent(_id);
            }
        }

        public void FinishGuide(int _id)
        {
            RecordCompletedGuide(_id);

            if (finishGuideEevent != null)
            {
                finishGuideEevent(_id);
            }
        }

        public void RemoveGuide(int _guideId)
        {
            RecordCompletedGuide(_guideId);

            if (removeGuideEvent != null)
            {
                removeGuideEvent(_guideId);
            }
        }

        public void RemoveAllUnderWayGuide()
        {
            for (int i = underwayGuides.Count - 1; i >= 0; i--)
            {
                var guideId = underwayGuides[i];
                var config = GuideConfig.Get(guideId);
                if (config.RemoveWhenOtherGuide == 1)
                {
                    RemoveGuide(guideId);
                }
            }
        }

        private void OnMainLineTaskUpdate(int _taskId, int _state)
        {
            for (int i = underwayGuides.Count - 1; i >= 0; i--)
            {
                var guideId = underwayGuides[i];
                var config = GuideConfig.Get(guideId);

                if (config.Condition != _taskId)
                {
                    continue;
                }

                switch ((GuideTriggerType)config.TriggerType)
                {
                    case GuideTriggerType.QuestCanAccept:
                        if (_state > 0)
                        {
                            RemoveGuide(guideId);
                        }
                        break;
                    case GuideTriggerType.MainLineQuestCanDo:
                        if (_state > 1)
                        {
                            RemoveGuide(guideId);
                        }
                        break;
                }
            }
        }

        private void OnQuestLimitStateChange(int _taskId)
        {
            for (int i = underwayGuides.Count - 1; i >= 0; i--)
            {
                var guideId = underwayGuides[i];
                var config = GuideConfig.Get(guideId);

                if (config.Condition != _taskId)
                {
                    continue;
                }

                var limitState = taskmodel.GetTaskStatus(config.Condition);

                switch ((GuideTriggerType)config.TriggerType)
                {
                    case GuideTriggerType.MainLineQuestLimit:
                    case GuideTriggerType.BranchQuestLimit:
                        if (limitState != TaskModel.TaskStatus.CardLevel || limitState != TaskModel.TaskStatus.TreasureCardLevel)
                        {
                            RemoveGuide(guideId);
                        }
                        break;
                }
            }
        }

        private void OnMainLineDescriptionChange(int taskId)
        {
            for (int i = underwayGuides.Count - 1; i >= 0; i--)
            {
                var guideId = underwayGuides[i];
                var config = GuideConfig.Get(guideId);

                if (config.Condition != taskId)
                {
                    continue;
                }

                switch ((GuideTriggerType)config.TriggerType)
                {
                    case GuideTriggerType.MainLineQuestCanDo:
                        MissionDetailDates datas;
                        if (taskmodel.TryGetTaskData(config.Condition, out datas))
                        {
                            var descriptionIndex = datas.descIndex;
                            if (descriptionIndex != config.SupplementCondition)
                            {
                                RemoveGuide(guideId);
                            }
                        }
                        break;
                }
            }
        }

        private void OnBranchQuestStateChange(int _taskId)
        {
            for (int i = underwayGuides.Count - 1; i >= 0; i--)
            {
                var guideId = underwayGuides[i];
                var config = GuideConfig.Get(guideId);

                if (config.Condition != _taskId)
                {
                    continue;
                }

                var state = taskmodel.SideQuestState(config.Condition);
                switch ((GuideTriggerType)config.TriggerType)
                {
                    case GuideTriggerType.BranchQuestCando:
                        if (state != 1)
                        {
                            RemoveGuide(guideId);
                        }
                        break;
                    case GuideTriggerType.BranchQuestCanAward:
                        if (state != 2)
                        {
                            RemoveGuide(guideId);
                        }
                        break;
                }
            }
        }

        private void OnTryGetMainLineTaskReward()
        {
            for (int i = underwayGuides.Count - 1; i >= 0; i--)
            {
                var guideId = underwayGuides[i];
                var config = GuideConfig.Get(guideId);
                switch ((GuideTriggerType)config.TriggerType)
                {
                    case GuideTriggerType.MainLineQuestCanAward:
                    case GuideTriggerType.MainLineQuestCanDo:
                    case GuideTriggerType.QuestCanAccept:
                    case GuideTriggerType.MainLineQuestContinue:
                    case GuideTriggerType.MainLineQuestLimit:
                    case GuideTriggerType.BranchQuestLimit:
                    case GuideTriggerType.BranchQuestContinue:
                        RemoveGuide(guideId);
                        break;
                }
            }
        }

        private void OnTreasureStateChange(int _treasureId)
        {
            for (int i = underwayGuides.Count - 1; i >= 0; i--)
            {
                var guideId = underwayGuides[i];
                var config = GuideConfig.Get(guideId);
                switch ((GuideTriggerType)config.TriggerType)
                {
                    case GuideTriggerType.TreasureDungeon:
                        Treasure treasure;
                        treasureModel.TryGetTreasure(config.Condition, out treasure);
                        if (treasure != null && treasure.state != TreasureState.Collecting)
                        {
                            RemoveGuide(guideId);
                        }
                        break;
                }
            }
        }

        private bool CheckGuideCondition(int _guideId)
        {
            var config = GuideConfig.Get(_guideId);

            if (config.PreGuideId != 0 && !NewBieCenter.Instance.completeGuidesBuf.Contains(config.PreGuideId))
            {
                return false;
            }

            var mainTaskId = taskmodel.currentMission;
            switch ((GuideTriggerType)config.TriggerType)
            {
                case GuideTriggerType.MainLineQuestCanDo:
                    if (config.SupplementCondition == 0)
                    {
                        return mainTaskId == config.Condition && taskmodel.currentMissionState == 1;
                    }
                    else
                    {
                        MissionDetailDates datas;
                        if (taskmodel.TryGetTaskData(config.Condition, out datas))
                        {
                            return mainTaskId == config.Condition && datas.descIndex == config.SupplementCondition;
                        }
                        else
                        {
                            return false;
                        }
                    }
                case GuideTriggerType.MainLineQuestCanAward:
                    // 支线第一次引导领取特殊处理
                    if (taskmodel.SideQuestsDic.ContainsKey(config.Condition) && taskmodel.SideQuestState(config.Condition) == 2)
                    {
                        return true;
                    }
                    return mainTaskId == config.Condition && taskmodel.currentMissionState == 2;
                case GuideTriggerType.MainLineQuestLimit:
                case GuideTriggerType.BranchQuestLimit:
                    return taskmodel.GetTaskStatus(config.Condition) == TaskModel.TaskStatus.CardLevel
                        || taskmodel.GetTaskStatus(config.Condition) == TaskModel.TaskStatus.TreasureCardLevel;
                case GuideTriggerType.MainLineQuestContinue:
                case GuideTriggerType.BranchQuestContinue:
                    var questState = taskmodel.SideQuestState(config.Condition);
                    var taskStatus = taskmodel.GetTaskStatus(config.Condition);
                    return questState == 1 && (taskStatus == TaskModel.TaskStatus.Normal);
                case GuideTriggerType.Treasure:
                    if (!treasureModel.newGotShowing)
                    {
                        Treasure treasure1;
                        return treasureModel.TryGetTreasure(config.Condition, out treasure1) && treasure1.state == TreasureState.Collected;
                    }
                    else
                    {
                        return false;
                    }
                case GuideTriggerType.TreasureDungeon:
                    Treasure treasure2;
                    treasureModel.TryGetTreasure(config.Condition, out treasure2);
                    return treasure2 != null && treasure2.state == TreasureState.Collecting;
                case GuideTriggerType.TreasureCollectSoul:
                    return IsTreasureCollectSoul(config.Condition);
                case GuideTriggerType.TreasureAwaken:
                    return false;
                case GuideTriggerType.Map:
                    return PlayerDatas.Instance.baseData.MapID == config.Condition;
                case GuideTriggerType.BranchQuestCando:
                    return taskmodel.SideQuestState(config.Condition) == 1;
                case GuideTriggerType.BranchQuestCanAward:
                    return taskmodel.SideQuestState(config.Condition) == 2;
                default:
                    return false;
            }
        }

        private void RecordCompletedGuide(int _guideId)
        {
            if (underwayGuides.Contains(_guideId))
            {
                underwayGuides.Remove(_guideId);
                guideStartTimes.Remove(_guideId);
                UpdateUnfoldAreas();
            }

            var send = new CA222_tagCMSetGuideOK();
            send.GuideIndex = (byte)_guideId;
            send.IsOK = 1;
            GameNetSystem.Instance.SendInfo(send);

            if (!NewBieCenter.Instance.completeGuidesBuf.Contains(_guideId) && onMainModel.createAwardState > 0)
            {
                NewBieCenter.Instance.completeGuidesBuf.Add(_guideId);
            }
        }

        private bool IsTreasureCollectSoul(int _treasureId)
        {
            return false;
        }

        public bool IsAreaNeedUnflod(int area)
        {
            return unfoldAreas.Contains(area);
        }

        private void UpdateUnfoldAreas()
        {
            unfoldAreas.Clear();
            foreach (var guid in underwayGuides)
            {
                var config = GuideConfig.Get(guid);
                foreach (var unfoldArea in config.UnfoldAreas)
                {
                    if (!unfoldAreas.Contains(unfoldArea))
                    {
                        unfoldAreas.Add(unfoldArea);
                    }
                }
            }
        }

        private void OnUpdate()
        {
            for (var i = underwayGuides.Count - 1; i >= 0; i--)
            {
                var guideId = underwayGuides[i];
                var config = GuideConfig.Get(guideId);
                if (config.AutoCompleteTime != 0)
                {
                    var startTime = guideStartTimes.ContainsKey(guideId) ? guideStartTimes[guideId] : Time.time;
                    if (Time.time > startTime + config.AutoCompleteTime)
                    {
                        RemoveGuide(guideId);
                    }
                }
            }
        }

        public struct UnderWayGuide
        {
            public int guideId;
            public float startTime;
        }

    }

}