using UnityEngine;
using UnityEngine.UI;
using System.Collections;
using Games.Item;
using System.Collections.Generic;
using GCGame.Table;
using Games.GlobeDefine;

public class GuideLogic : UIControllerBase<GuideLogic>
{

    public GameObject _Back;
    public Button _BtnBackClose;
    public RectTransform _GuideInfo;
    public Text _GuideTips;
    public GameObject _GuideArrawLeft;
    public GameObject _GuideArrawRight;
    public GameObject _NewFuncInfo;
    public Text _NewFunTips;
    public Image _FuncImage;
    public GameObject _BtnEffect;
    public RectTransform _GuidePos;

    private List<BtnFunc> _BtnFuncs = new List<BtnFunc>();
    public List<BtnFunc> BtnFuncs
    {
        get
        {
            return _BtnFuncs;
        }
    }

    private int _NextMissionID;
    public int NextMissionID
    {
        get
        {
            return _NextMissionID;
        }
        set
        {
            _NextMissionID = value;
        }
    }

    public void Awake()
    {
        SetInstance(this);

        UpdateFunBtns();
    }

    public void SetForceBackActive(bool isActive)
    {
        _BtnBackClose.gameObject.SetActive(false);
        if (isActive)
        {
            _Back.SetActive(true);
            _Back.GetComponent<Image>().raycastTarget = true;
        }
        else
        {
            _Back.SetActive(false);
        }
    }

    public void SetClickBack()
    {
        _BtnBackClose.gameObject.SetActive(true);
        _Back.SetActive(false);
    }

    public void OnEnable()
    {
        _Back.SetActive(false);
        _BtnBackClose.gameObject.SetActive(false);
        _GuideInfo.gameObject.SetActive(false);
        _NewFuncInfo.SetActive(false);

        UpdateFunBtns();

        InitGuideItems();
    }

    public void OnDestory()
    {
        SetInstance(null);
    }

    public void ShowGuideInfo()
    {
        _GuideInfo.gameObject.SetActive(true);
        _NewFuncInfo.SetActive(false);
    }

    public void ShowNewFuncInfo()
    {
        _GuideInfo.gameObject.SetActive(false);
        _NewFuncInfo.SetActive(true);
    }

    public void ShowGuideLeft()
    {
        _GuideArrawLeft.SetActive(true);
        _GuideArrawRight.SetActive(false);
    }

    public void ShowGuideRight()
    {
        _GuideArrawLeft.SetActive(false);
        _GuideArrawRight.SetActive(true);
    }

    public void ShowEffect(Vector3 pos)
    {
        //_BtnEffect.gameObject.SetActive(true);
        //_BtnEffect.transform.position = pos;
    }

    public void HideEffect()
    {
        //_BtnEffect.transform.position = new Vector3(2000, 2000);
    }

    public void UpdateFunBtns()
    {
        if (Singleton<ObjManager>.Instance.MainPlayer == null || Singleton<ObjManager>.Instance.MainPlayer.BaseAttr.Level == 0)
        {
            Invoke("UpdateFunBtns", 1);
            return;
        }

        _BtnFuncs = new List<BtnFunc>();
        if (_BtnFuncs == null || _BtnFuncs.Count == 0)
        {
            if (FunctionButtonLogic.Instance())
            {
                _BtnFuncs.AddRange(FunctionButtonLogic.Instance().gameObject.GetComponentsInChildren<BtnFunc>(true));
            }
            if (FunctionExLogic.Instance())
            {
                _BtnFuncs.AddRange(FunctionExLogic.Instance().gameObject.GetComponentsInChildren<BtnFunc>(true));
            }
        }

        CancelInvoke("UpdateFunBtns");
        foreach (var btnFunc in GuideLogic.Instance().BtnFuncs)
        {
            //if (btnFunc._BtnList == null)
            {
                btnFunc.UpdateFuncState(btnFunc._functionOpenId);
            }
        }

        if (ExtraFunTipRoot.Instance())
        {
            ExtraFunTipRoot.Instance().UpdateEquipEnhance();
        }
    }

    #region start guide

    private List<GuideItem> GuideItems = null;
    private GuideItem _ActingGuideItem;

    public bool IsActingGuide()
    {
        return _ActingGuideItem != null;
    }

    public void FinishGuide(GuideItem guideItem)
    {
        if (_ActingGuideItem == guideItem)
        {
            _ActingGuideItem = null;
        }
    }

    public void InitGuideItems()
    {
        if (GuideItems != null)
            return;

        var items = GetComponentsInChildren<GuideItem>(true);
        GuideItems = new List<GuideItem>(items);
        for(int i = 0; i< GuideItems.Count; ++i)
        {
            GuideItems[i].InitSteps();
            GuideItems[i].gameObject.SetActive(false);
            //GuideItems[i]._GuideID = i + 1;
        }

        if (GameManager.gameManager.MissionManager.IsHaveMission(0) 
            && Singleton<ObjManager>.GetInstance().MainPlayer != null
            && GameManager.gameManager.PlayerDataPool.MainPlayerBaseAttr.Level == 1)
        {
            OnMissionAccept(0);
        }
    }

    public static void OnMissionAcceptStatic(int missionID)
    {
        if (!GuideLogic.Instance())
        {
            return;
        }
        
        Hashtable hash = new Hashtable();
        hash.Add("AcceptMissionID", missionID);
        UIManager.ShowUI(UIInfo.GuideRoot, ShowUIOver, hash);
    }

    public static void OnMissionComplateStatic(int missionID,int nextMissionID)
    {
        if (!GuideLogic.Instance())
        {
            Debug.LogError("GuideLogic is null");
            return;
        }
        Hashtable hash = new Hashtable();
        hash.Add("ComplateMissionID", missionID);
        hash.Add("NextMissionID", nextMissionID);
        UIManager.ShowUI(UIInfo.GuideRoot, ShowUIOver, hash);
    }

    public static void MissionFindNext(int nextMissionID)
    {
        //原地寻路的话好像进不去 这边直接判断距离吧
        GameManager.gameManager.MissionManager.MissionPathFinder(nextMissionID);

        //这个不能放在前面，不然寻路逻辑有不执行的可能
        if (!GuideLogic.Instance())
        {
            return;
        }

        if (_isShowCompleteMissionGuide)
             _isShowCompleteMissionGuide = false; //完成任务时的指引解释后之后重置

        GuideLogic.Instance().NextMissionID = -1;
        GuideLogic._isSyncMisisonStateWhenShowCompleteMissionGuide = false;
    }

    public static void OnMissionStateStatic(int missionID)
    {
        if (!GuideLogic.Instance())
            return;
        Hashtable hash = new Hashtable();
        hash.Add("MissionStateID", missionID);
        UIManager.ShowUI(UIInfo.GuideRoot, ShowUIOver, hash);
    }

    public static void OnLevelUpStatic(int missionID)
    {
        if (!GuideLogic.Instance())
            return;
        Hashtable hash = new Hashtable();
        hash.Add("LevelUp", missionID);
        UIManager.ShowUI(UIInfo.GuideRoot, ShowUIOver, hash);
    }

    public static void OnOpenUIStatic(string uiName)
    {
        if (!GuideLogic.Instance())
            return;

        Hashtable hash = new Hashtable();
        hash.Add("OpenUI", uiName);
        UIManager.ShowUI(UIInfo.GuideRoot, ShowUIOver, hash);
    }

    public static void StartGuide(int idx)
    {
        if (idx == 0)
        {
            FinishGuide();
        }
        else
        {
            Hashtable hash = new Hashtable();
            hash.Add("StartGuide", idx);
            UIManager.ShowUI(UIInfo.GuideRoot, ShowUIOver, hash);
        }
    }

    public static void FinishGuide()
    {
        if (!GuideLogic.Instance())
            return;

        GuideLogic.Instance().OnFinishGuide();
        GuideLogic.Instance().FinishGuide(GuideLogic.Instance()._ActingGuideItem);
    }

    private static void ShowUIOver(bool sucess, object param)
    {
        if (!sucess)
            return;

        Hashtable hash = param as Hashtable;
        if (hash == null)
            return;

        if (hash.ContainsKey("AcceptMissionID"))
        {
            GuideLogic.Instance().OnMissionAccept((int)hash["AcceptMissionID"]);
        }
        else if (hash.ContainsKey("ComplateMissionID"))
        {
            GuideLogic.Instance().OnMissionComplate((int)hash["ComplateMissionID"], (int)hash["NextMissionID"]);
        }
        else if (hash.ContainsKey("MissionStateID"))
        {
            GuideLogic.Instance().OnMissionState((int)hash["MissionStateID"]);
        }
        else if (hash.ContainsKey("LevelUp"))
        {
            GuideLogic.Instance().OnMissionLevelUp((int)hash["LevelUp"]);
        }
        else if (hash.ContainsKey("OpenUI"))
        {
            GuideLogic.Instance().OnOpenUI((string)hash["OpenUI"]);
        }
        else if (hash.ContainsKey("StartGuide"))
        {
            GuideLogic.Instance().OnStartGuide((int)hash["StartGuide"]);
        }
    }

    public void OnFinishGuide()
    {
        if (_ActingGuideItem != null)
        {
            _ActingGuideItem.FinishGuide();
            FinishGuide(GuideLogic.Instance()._ActingGuideItem);
        }
    }

    public void OnMissionState(int missionID)
    {
        var missionState = (Games.Mission.MissionState)GameManager.gameManager.MissionManager.GetMissionState(missionID);
        var trigGuide = GuideItems.Find((guideItem) =>
        {
            if (guideItem._TriggerMissionID == missionID)
            {
                if (missionState == Games.Mission.MissionState.Mission_None && guideItem._TriggerType == TriggerType.FinishMission)
                {
                    return true;
                }
            }
                
            return false;
        });

        if(trigGuide == null)
        {
            if(missionState == Games.Mission.MissionState.Mission_NotAccept)
            {
                if (_isShowCompleteMissionGuide)
                {
                    NextMissionID = missionID;
                    return;
                }
                else
                {
                    MissionFindNext(missionID);
                }
            }
        }
    }

    public void OnMissionAccept(int missionID)
    {
        var trigGuide = GuideItems.Find((guideItem) =>
        {
            if (guideItem._TriggerType == TriggerType.AcceptMission && guideItem._TriggerMissionID == missionID)
                return true;
            return false;
        });

        if (trigGuide == null)
            return;

        if (_ActingGuideItem != null)
        {
            for (int i = 0; i < _ActingGuideItem._GuideSteps.Count; ++i)
            {
                _ActingGuideItem._GuideSteps[i].StopGuideStep();
            }
        }
        _ActingGuideItem = trigGuide;
        trigGuide.StartGuide();
    }

    public static bool _isSyncMisisonStateWhenShowCompleteMissionGuide = false;  //是否正在显示指引的时候同步了任务状态（记录起来，在指引结束之后调用状态同步）
    ///完成任务的时候如果开启了指引，那么AccpetMission的时候不能自动寻路，要等指引结束 
    public static bool _isShowCompleteMissionGuide = false;
    public void OnMissionComplate(int missionID, int nextMissionID)
    {
        var trigGuide = GuideItems.Find((guideItem) =>
        {
            if (guideItem._TriggerType == TriggerType.ComplateMission && guideItem._TriggerMissionID == missionID)
            {
                return true;
            }
            return false;
        });

        if (trigGuide == null)
        {
            //if(GuideLogic._isSyncMisisonStateWhenShowCompleteMissionGuide)  //需要调用状态改变的处理 
            //{
            //    GuideLogic._isSyncMisisonStateWhenShowCompleteMissionGuide = false;
            //    GuideLogic.OnMissionStateStatic(nextMissionID);
            //}
            return;
        }

        _isShowCompleteMissionGuide = true;
        if (_ActingGuideItem != null)
        {
            for (int i = 0; i < _ActingGuideItem._GuideSteps.Count; ++i)
            {
                _ActingGuideItem._GuideSteps[i].StopGuideStep();
            }
        }
        _ActingGuideItem = trigGuide;
        trigGuide.StartGuide();
    }

    public void OnMissionLevelUp(int missionID)
    {
        UpdateFunBtns();

        var trigGuide = GuideItems.Find((guideItem) =>
        {
            if (guideItem._TriggerType == TriggerType.LevelUp && guideItem._TriggerMissionID == missionID)
                return true;
            return false;
        });

        if (trigGuide == null)
            return;

        if (_ActingGuideItem != null)
        {
            for (int i = 0; i < _ActingGuideItem._GuideSteps.Count; ++i)
            {
                _ActingGuideItem._GuideSteps[i].StopGuideStep();
            }
        }
        _ActingGuideItem = trigGuide;
        trigGuide.StartGuide();
        
    }

    public void OnOpenUI(string uiName)
    {
        UpdateFunBtns();

        var trigGuide = GuideItems.Find((guideItem) =>
        {
            if (guideItem._TriggerType == TriggerType.UIOpen && guideItem._TriggetParam == uiName)
                return true;
            return false;
        });

        if (trigGuide == null)
            return;

        if (!trigGuide._RepeatGuide)
        {
            if (!Guide.Instance.IsCanActGuide(trigGuide._GuideID))
                return;
        }

        if (trigGuide._LimitLv < GameManager.gameManager.PlayerDataPool.MainPlayerBaseAttr.Level)
        {
            return;
        }

        if (_ActingGuideItem != null)
        {
            for (int i = 0; i < _ActingGuideItem._GuideSteps.Count; ++i)
            {
                _ActingGuideItem._GuideSteps[i].StopGuideStep();
            }
        }
        _ActingGuideItem = trigGuide;
        trigGuide.StartGuide();

    }

    public void OnStartGuide(int missionID)
    {
        var trigGuide = GuideItems.Find((guideItem) =>
        {
            if (guideItem._GuideID == missionID)
                return true;
            return false;
        });

        if (trigGuide == null)
            return;

        if (_ActingGuideItem != null)
        {
            for (int i = 0; i < _ActingGuideItem._GuideSteps.Count; ++i)
            {
                _ActingGuideItem._GuideSteps[i].StopGuideStep();
            }
        }
        _ActingGuideItem = trigGuide;
        trigGuide.StartGuide();
        
    }

    public void UIClose(string uiName)
    {
        foreach (var guide in GuideItems)
        {
            if (uiName == guide._CloseUIFinish)
            {
                guide.CloseUI(uiName);
            }
        }
    }
    #endregion

}