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

namespace Snxxz.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>();
        List<int> allGuides = new List<int>();

        bool inited = false;

        TreasureModel model { get { return ModelCenter.Instance.GetModel<TreasureModel>(); } }
        PlayerTaskDatas taskmodel { get { return ModelCenter.Instance.GetModel<PlayerTaskDatas>(); } }
        TreasureModel treasureModel { get { return ModelCenter.Instance.GetModel<TreasureModel>(); } }
        AchievementModel achievementModel { get { return ModelCenter.Instance.GetModel<AchievementModel>(); } }

        public FunctionalGuideCenter()
        {
            PlayerTaskDatas.tryGetTaskAwardEvent += OnTryGetMainLineTaskReward;
            PlayerTaskDatas.Event_MainlineTask += OnMainLineTaskUpdate;
            PlayerTaskDatas.CardLevelChange += OnMainLineLimitStateChange;
            PlayerTaskDatas.SideQuestChangeEvent += OnBranchQuestStateChange;
            treasureModel.treasureStateChangeEvent += OnTreasureStateChange;
        }

        public void CheckGuides(int[] _guides)
        {
            if (!inited)
            {
                var allGuideConfigs = Config.Instance.GetAllValues<GuideConfig>();
                foreach (var config in allGuideConfigs)
                {
                    if (config.Type == (int)GuideType.Functional)
                    {
                        allGuides.Add(config.ID);
                    }
                }

                inited = true;
            }

            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 void StartGuide(int _id)
        {
            RemoveAllUnderWayGuide();

            underwayGuides.Add(_id);

            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 = Config.Instance.Get<GuideConfig>(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 = Config.Instance.Get<GuideConfig>(guideId);

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

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

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

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

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

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

        private void OnBranchQuestStateChange(int _taskId)
        {
            for (int i = underwayGuides.Count - 1; i >= 0; i--)
            {
                var guideId = underwayGuides[i];
                var config = Config.Instance.Get<GuideConfig>(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 = Config.Instance.Get<GuideConfig>(guideId);
                switch ((GuideTriggerType)config.TriggerType)
                {
                    case GuideTriggerType.QuestCanAward:
                    case GuideTriggerType.QuestCanDo:
                    case GuideTriggerType.QuestCanAccept:
                    case GuideTriggerType.QuestContinue:
                    case GuideTriggerType.QuestLimit:
                        RemoveGuide(guideId);
                        break;
                }
            }
        }

        private void OnTreasureStateChange(int _treasureId)
        {
            for (int i = underwayGuides.Count - 1; i >= 0; i--)
            {
                var guideId = underwayGuides[i];
                var config = Config.Instance.Get<GuideConfig>(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 = Config.Instance.Get<GuideConfig>(_guideId);

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

            var mainTaskId = taskmodel.currentMission;
            switch ((GuideTriggerType)config.TriggerType)
            {
                case GuideTriggerType.QuestCanDo:
                    return mainTaskId == config.Condition && taskmodel.currentMissionState == 1;
                case GuideTriggerType.QuestCanAward:
                    return mainTaskId == config.Condition && taskmodel.currentMissionState == 2;
                case GuideTriggerType.QuestLimit:
                    return taskmodel.currentMission == config.Condition &&
                        (taskmodel.GetTaskStatus(config.Condition) == PlayerTaskDatas.TaskStatus.CardLevel || taskmodel.GetTaskStatus(config.Condition) == PlayerTaskDatas.TaskStatus.TreasureCardLevel);
                case GuideTriggerType.QuestContinue:
                    return taskmodel.currentMission == config.Condition && (taskmodel.GetTaskStatus(config.Condition) == PlayerTaskDatas.TaskStatus.Normal);
                case GuideTriggerType.Treasure:
                    if (!model.newGotShowing)
                    {
                        Treasure treasure1;
                        return model.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.isChallengeDungeonAble;
                case GuideTriggerType.TreasureCollectSoul:
                    return IsTreasureCollectSoul(config.Condition);
                case GuideTriggerType.TreasureAwaken:
                    Treasure treasureAwaken;
                    if (treasureModel.TryGetTreasure(config.Condition, out treasureAwaken))
                    {
                        var humanTreasure = treasureAwaken as HumanTreasure;
                        return humanTreasure != null && humanTreasure.castSoulRedpoint != null && humanTreasure.castSoulRedpoint.state == RedPointState.Simple;
                    }
                    else
                    {
                        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);
            }

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

            if (!NewBieCenter.Instance.completeGuidesBuf.Contains(_guideId))
            {
                NewBieCenter.Instance.completeGuidesBuf.Add(_guideId);
            }
        }

        private bool IsTreasureCollectSoul(int _treasureId)
        {
            Treasure treasure;
            if (treasureModel.TryGetTreasure(_treasureId, out treasure))
            {
                var humanTreasure = treasure as HumanTreasure;
                if (humanTreasure != null && humanTreasure.humanState == HumanTreasureState.CastSoul)
                {
                    foreach (var achievementGroup in treasure.achievementGroups.Values)
                    {
                        if (achievementGroup.IsAwardable())
                        {
                            return true;
                        }
                    }
                }

                return false;
            }
            else
            {
                return false;
            }
        }

    }

}