//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Wednesday, March 14, 2018
//--------------------------------------------------------
using UnityEngine;
using System.Collections;
using UnityEngine.UI;
using vnxbqy.UI;
using System;
using LitJson;
using System.Collections.Generic;
using System.Linq;

public class CutTreeModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk
{
    //砍树速度
    public int cutTreeSpeed = 1; //月卡开启加速, 速度越大越快

    public event Action OnSelectMainType;

    //0:主界面砍树 1:战斗界面
    private int m_SelectMainType = 0;
    public int SelectMainType
    {
        get
        {
            return m_SelectMainType;
        }
        set
        {
            if (m_SelectMainType != value)
            {
                m_SelectMainType = value;
                OnSelectMainType?.Invoke();
            }
        }

    }

    public event Action OnCutTreeResult;
    public Action AfterPlayCutTreeAnimEvent; //砍树动画播放完毕后的事件
    public List<Item> m_ExItemList = new List<Item>(); // 砍树获得额外物品奖励（非装备） 存储起来统一展示
    public int m_EquipCount;
    public int[] equipUIEffectLights;  //砍树装备掉落特效
    public int[] cutTreeAtkEffects; //砍树攻击特效
    public int upgradeTreeMoneyType; //升级仙树消耗的货币类型
    public int timeUpTreeItemID; //加速仙树升级的道具ID
    public int timeUpTreeItemSubTime; //减少仙树升级时间的道具减少的时间

    public Dictionary<int, int> taskClickGuide = new Dictionary<int, int>(); //点击任务引导 任务类型-引导id
    public Dictionary<int, int> realmWinClickGuide = new Dictionary<int, int>(); //点击境界窗口引导 境界类型-引导id
    public Dictionary<int, int> defeadWinClickGuide = new Dictionary<int, int>(); //点击副本战败引导 副本id-引导id
    public int[] autoGuideList; //小于x级y秒内无任何点击自动引导【等级，秒】
    public Dictionary<int, int> newEquipIDToGuideID = new Dictionary<int, int>(); //新装备id对应的引导id
    public ItemModel selectFloorEquip; //选中的地板装备
    public bool dontNotifyDecompose = false;    // 是否提示更好装备分解警告
    public bool dontNotifyExchangeDecompose = false;     // 是否提示更好装备替换会被分解警告
    public bool waitEquipOPPack = false;    //等待装备操作（分解/替换）包返回
    public bool waitCutTreePack = false;    //等待砍树结果包返回
    public event Action OnEquipOPResultAction;
    public float lastModelAnimateTime = 0; //上次模型最后一次砍树动画时间
    public bool isPlayCutTreeAnim = false; //是否正在播放砍树动画，用于重复点击砍树按钮的判断

    //仙树信息
    int m_TreeLV;    // 当前仙树等级
    public int m_LVUPState;    // 0-非升级中；1-升级中
    int m_LVUPRemainTime;    // 升级剩余时间，秒；当升级中且倒计时为0时可发送B223执行升级包进行升级
    int m_LVPackTime; //收包时间用于计算剩余时间m_LVUPRemainTime
    public float cutTreeDuration = 0.8f; //砍树动画基础不加速的单次间隔
    public event Action UpdateTreeLVEvent;
    bool loginOKTreePack = false; //登录时是否已经收到仙树信息包,用于判定是否仙树升级
    public bool isCreateNewUIModel = true; //砍树界面是否创建新的UI模型，用于换模型功能或者重登时刷新界面模型

    //砍树任务 另外一套逻辑
    public int m_CutTreeTaskID = 0;
    public int m_CutTreeTaskValue = 0;
    public int m_CutTreeTaskState = 0; // 任务状态 1-进行中 2-可领取
    public event Action OnCutTreeTaskEvent;

    public bool clickEquipTipOnMain = false; //主界面点击在身上装备的tip显示

    //功能入口
    public int[] dongfuFuncArr;
    public int[] tiaozhanFuncArr;
    public Dictionary<int, int> funcIDToDailyIDDic = new Dictionary<int, int>(); //功能id对应的日常id, 用于进度完成显示
    public Dictionary<int, int> funcShowLVDic = new Dictionary<int, int>(); //功能显示的最低等级 不是开启功能的等级
    public Dictionary<int, int> funcRedpointDic = new Dictionary<int, int>();
    public int selectFuncArrNum = 0; //选择的功能组序号 0-洞府 1-挑战

    PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
    EquipModel equipModel { get { return ModelCenter.Instance.GetModel<EquipModel>(); } }
    AutoCutTreeModel autoCutTreeModel { get { return ModelCenter.Instance.GetModel<AutoCutTreeModel>(); } }
    TaskModel taskModel { get { return ModelCenter.Instance.GetModel<TaskModel>(); } }
    DungeonModel dungeonModel { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } }

    public override void Init()
    {
        DTC0721_tagMakeItemAnswer.MakeItemAnswerEvent += OnEquipResult;
        GlobalTimeEvent.Instance.secondEvent += OnSecondEvent;
        PlayerDatas.Instance.playerDataRefreshEvent += OnPlayerDataRefreshEvent;
        ParseConfig();
    }

    void ParseConfig()
    {
        var config = FuncConfigConfig.Get("CutTreeEquip");
        equipUIEffectLights = JsonMapper.ToObject<int[]>(config.Numerical1);
        var json = JsonMapper.ToObject(config.Numerical2);
        foreach (var key in json.Keys)
        {
            taskClickGuide.Add(int.Parse(key), int.Parse(json[key].ToString()));
        }
        autoGuideList = JsonMapper.ToObject<int[]>(config.Numerical3);
        json = JsonMapper.ToObject(config.Numerical4);
        foreach (var key in json.Keys)
        {
            newEquipIDToGuideID.Add(int.Parse(key), int.Parse(json[key].ToString()));
        }

        cutTreeAtkEffects = JsonMapper.ToObject<int[]>(config.Numerical5);

        config = FuncConfigConfig.Get("TreeLVUP");
        upgradeTreeMoneyType = int.Parse(config.Numerical1);
        var arr = config.Numerical2.Split('|');
        timeUpTreeItemID = int.Parse(arr[0]);
        timeUpTreeItemSubTime = int.Parse(arr[1]);

        config = FuncConfigConfig.Get("CutTreePanel1");
        dongfuFuncArr = JsonMapper.ToObject<int[]>(config.Numerical1);
        tiaozhanFuncArr = JsonMapper.ToObject<int[]>(config.Numerical2);
        json = JsonMapper.ToObject(config.Numerical3);
        foreach (var key in json.Keys)
        {
            funcIDToDailyIDDic.Add(int.Parse(key), int.Parse(json[key].ToString()));
        }
        json = JsonMapper.ToObject(config.Numerical4);
        foreach (var key in json.Keys)
        {
            funcShowLVDic.Add(int.Parse(key), int.Parse(json[key].ToString()));
        }
        json = JsonMapper.ToObject(config.Numerical5);
        foreach (var key in json.Keys)
        {
            funcRedpointDic.Add(int.Parse(key), int.Parse(json[key].ToString()));
        }

        config = FuncConfigConfig.Get("CutTreePanel2");
        json = JsonMapper.ToObject(config.Numerical1);
        foreach (var key in json.Keys)
        {
            realmWinClickGuide.Add(int.Parse(key), int.Parse(json[key].ToString()));
        }
        json = JsonMapper.ToObject(config.Numerical2);
        foreach (var key in json.Keys)
        {
            defeadWinClickGuide.Add(int.Parse(key), int.Parse(json[key].ToString()));
        }
    }

    public void OnBeforePlayerDataInitialize()
    {
        if (WindowCenter.Instance.IsOpen<EquipExchangeWin>())
            WindowCenter.Instance.Close<EquipExchangeWin>();
        selectFloorEquip = null;
        m_ExItemList.Clear();
        dontNotifyDecompose = false;
        dontNotifyExchangeDecompose = false;
        waitEquipOPPack = false;
        waitCutTreePack = false;
        m_TreeLV = 0;
        m_LVUPState = 0;
        m_LVUPRemainTime = 0;
        m_CutTreeTaskID = 0;
        m_CutTreeTaskValue = 0;
        m_CutTreeTaskState = 0;
        loginOKTreePack = false;
        isCreateNewUIModel = true;
        isPlayCutTreeAnim = false;

    }



    public void OnPlayerLoginOk()
    {
        var _mapConfig = MapConfig.Get(PlayerDatas.Instance.baseData.MapID);
        if (_mapConfig.MapFBType == (int)MapType.OpenCountry)
        {
            SelectMainType = 0; //后续根据具体情况调整
        }
    }

    public override void UnInit()
    {
        DTC0721_tagMakeItemAnswer.MakeItemAnswerEvent -= OnEquipResult;
        GlobalTimeEvent.Instance.secondEvent -= OnSecondEvent;
        PlayerDatas.Instance.playerDataRefreshEvent -= OnPlayerDataRefreshEvent;
    }

    //是否休息时间
    public bool IsRestTime()
    {
        if (Time.realtimeSinceStartup - lastModelAnimateTime > 10)
            return true;
        return false;
    }

    private void OnEquipResult(H0721_tagMakeItemAnswer info)
    {
        if (info.MakeType != (int)MakeType.default1)
            return;

        waitEquipOPPack = false;
        OnEquipOPResultAction?.Invoke();
    }

    public void SendCutTree(int count)
    {
        var pack = new CB221_tagCMCutTree();
        pack.CutCount = (byte)count;
        GameNetSystem.Instance.SendInfo(pack);
        lastModelAnimateTime = Time.realtimeSinceStartup;
        isPlayCutTreeAnim = true;
    }

    public void CutTreeResult(HB122_tagMCCutTreeResult vNetData)
    {
        waitCutTreePack = false;
        lastModelAnimateTime = Time.realtimeSinceStartup;
        m_EquipCount = vNetData.EquipCount;
        if (vNetData.ExItemList.Length != 0)
        {
            for (int i = 0; i < vNetData.ExItemList.Length; i++)
            {
                m_ExItemList.Add(new Item() { 
                    id = (int)vNetData.ExItemList[i].ItemID,
                    count = (int)vNetData.ExItemList[i].ItemCount
                });
            }
            if (SelectMainType == 0)
            {
                ItemLogicUtility.Instance.ShowGetItem(m_ExItemList, Language.Get("CutTree1"), func: () => {
                    m_ExItemList.Clear();
                });
            }
        }
        //1.没有界面表现的砍树结果 2.有界面表现的砍树结果
        if (SelectMainType == 0 && WindowCenter.Instance.IsOpen<MainInterfaceWin>())
        {
            

            OnCutTreeResult?.Invoke();
        }
        else
        {
            ProcessEquipOnFloor();
        }
        
    }

    //不展示界面的时候按间隔时间处理地板装备
    public void ProcessEquipOnFloor()
    {
        //时间顺序：砍树动作-掉落-分解/替换
        var quality = GetStartEquipQuality();
        var betterQuality = GetBetterEquipQuality(quality);
        var cutCount = betterQuality - quality + 1;
        float delayTime = Math.Max(cutTreeDuration / cutTreeSpeed * cutCount / (1 + Math.Max(cutCount - 2, 0) * 0.3f), 0.5f);
        Clock.AlarmAfter(delayTime, () =>
        {
            if (!autoCutTreeModel.isAutoCutTree)
            {
                var betterEquip = GetBetterFloorEquip();
                if (betterEquip != null)
                {
                    OpenEquipExchangeWin(betterEquip);
                }
            }
            else
            {
                isPlayCutTreeAnim = false;
            }
        });
    }

    //砍树动作对应装备品质的起始表现,最小1
    public int GetStartEquipQuality()
    {
        var rateList = TreeLVConfig.Get(m_TreeLV).EquipColorRateList;
        for (int i = 0;i< rateList.Length; i++)
        {
            if (rateList[i] != 0)
                return i + 1;
        }
        return 1;
    }


    public int GetBetterEquipQuality(int quality = 1)
    {
        var items = packModel.GetItems(PackType.EquipOnFloor);
        if (items == null || items.Count == 0)
            return quality;

        for (int i = 0; i < items.Count; i++)
        {
            var equip = items[i];
            if (equip == null)
                continue;
            if (quality < equip.config.ItemColor)
                quality = equip.config.ItemColor;
        }
        return quality;
    }

    public ItemModel GetBetterFloorEquip()
    {
        var items = packModel.GetItems(PackType.EquipOnFloor);
        if (items == null || items.Count == 0)
            return null;

        ItemModel betterEquip = null;
        for (int i = 0; i < items.Count; i++)
        {
            var equip = items[i];
            if (equip == null)
                continue;

            var equipOn = equipModel.GetEquipItemModel(new Int2(PlayerDatas.Instance.baseData.suitLevel, equip.config.EquipPlace));
            if (equipOn == null)
                continue;
            //后续要处理自动功能的战斗属性对比
            if (betterEquip.score > equipOn.score)
                betterEquip = equip;
        }
        return betterEquip;
    }


    public void SendCutTreeEquipOP(byte[] itemIndexList, byte opType, bool autoDecompose = false)
    {
        if (waitEquipOPPack) return;

        NoteFloorEquip(itemIndexList, opType);
        var pack = new CB222_tagCMCutTreeEquipOP();
        pack.IndexCount = (byte)itemIndexList.Length;
        pack.ItemIndexList = itemIndexList;
        pack.OPType = opType;   // 操作类型：1-替换；2-分解
        pack.AutoDecompose = (byte)(autoDecompose ? 1 : 0); // 替换后是否自动分解原装备：0否1是，仅替换操作下有用

        waitEquipOPPack = true;
        GameNetSystem.Instance.SendInfo(pack);
    }

    //equipFloorInfo记录地板装备的最新一次信息，不作清除可能地板上的装备已经消失,用于替换和分解装备的表现
    public void NoteFloorEquip(byte[] itemIndexList, int opType)
    {
        equipFloorInfo.Clear();
        foreach (var girdIndex in itemIndexList)
        {
            var equip = packModel.GetItemByIndex(PackType.EquipOnFloor, girdIndex);
            if (equip == null) continue;
            equipFloorInfo[girdIndex] = new EquipOnFloorInfo()
            {
                equipID = equip.itemId,
                posX = equipOnFloorBtn[girdIndex].transform.position.x,
                posY = equipOnFloorBtn[girdIndex].transform.position.y,
                opType = opType
            };
        }

    }


    public void OpenEquipExchangeWin(ItemModel equip)
    {
        isPlayCutTreeAnim = false;
        if (SelectMainType == 1)
            return;

        //未回复装备操作结果，否则会显示旧装备
        if (waitEquipOPPack) 
            return;

        if (TurnFightModel.Instance.IsTurnFight())
            return;

        if (WindowCenter.Instance.IsOpen<EquipExchangeWin>())
            return;

        if (NewBieCenter.Instance.inGuiding)
            return;

        selectFloorEquip = equip;
        WindowCenter.Instance.Open<EquipExchangeWin>();
    }

    //用于飘动逻辑
    public Dictionary<int, EquipOnFloorInfo> equipFloorInfo = new Dictionary<int, EquipOnFloorInfo>(); //真实背包的索引，对应地板装备的信息
    public List<Button> equipOnFloorBtn = new List<Button>();

    public struct EquipOnFloorInfo
    {
        public int equipID;
        public float posX;  //全局坐标 表现再转成local
        public float posY;
        public int opType;  //操作类型：1-替换；2-分解
    }

    public EquipOnFloorInfo FindExchangeEquipInfo()
    {
        foreach (var info in equipFloorInfo)
        {
            if (info.Value.opType == 1)
                return info.Value;
        }
        return new EquipOnFloorInfo();
    }



    public void UpdateTreeInfo(HB121_tagMCTreeInfo pack)
    {
        if (!loginOKTreePack)
        {
            loginOKTreePack = true;
        }
        else if (m_TreeLV < pack.TreeLV)
        {
            //播放仙树升级特效
            EffectMgr.Instance.PlayUIEffect(7118, 1800, WindowCenter.Instance.uiRoot.baseCanvas, false);
        }
        m_TreeLV = pack.TreeLV;
        m_LVUPState = pack.LVUPState;
        m_LVUPRemainTime = (int)pack.LVUPRemainTime;
        m_LVPackTime = TimeUtility.AllSeconds;
        UpdateTreeLVEvent?.Invoke();
        UpdateTreeRedpoint();
    }

    public void UpdateCutTreeTaskInfo(HB110_tagMCTaskInfo pack)
    {
        for (int i = 0; i < pack.TaskCount; i++)
        {
            var task = pack.TaskList[i];
            if (task.TaskGroup == 0)
            {
                m_CutTreeTaskID = (int)task.TaskID;
                m_CutTreeTaskValue = (int)task.CurValue;
                m_CutTreeTaskState = task.State;
                OnCutTreeTaskEvent?.Invoke();
                taskModel.TreeTask(m_CutTreeTaskID, m_CutTreeTaskState);
            }
        }
    }

    //仙树等级
    public int GetTreeLV()
    {
        return m_TreeLV;
    }

    //仙树等级显示，如果服务端从0开始 需加1，根据项目情况调整
    public int GetUIShowTreeLV()
    {
        return m_TreeLV;
    }

    public int GetLVUPRemainTime()
    {
        if (m_LVUPState == 0)
            return 0;
        return m_LVUPRemainTime - (TimeUtility.AllSeconds - m_LVPackTime);
    }

    public void SendUpgradeTreeLV(int type)
    {
        var pack = new CB223_tagCMTreeLVUP();
        pack.Type = (byte)type;  // 0-开始升级（请求扣除消耗，开始升级倒计时）；1-执行升级（前端自行倒计时，时间到后发送该类型）
        GameNetSystem.Instance.SendInfo(pack);
    }

    void OnSecondEvent()
    {
        //自动发送砍树升级
        if (m_LVUPState == 1 && GetLVUPRemainTime() <= 0)
        {
            SendUpgradeTreeLV(1);
        }
    }

    //还需多少个任务完成
    public int GetTaskCountToFinish(int taskID)
    {
        var config = TaskConfig.Get(taskID);
        if (config == null)
            return 9999;
        var curConfig = TaskConfig.Get(m_CutTreeTaskID);
        if (curConfig.Index >= config.Index)
            return 0;

        return config.Index - curConfig.Index;
    }

    //冒险已通过到达的当前关卡，比如第四关打过了 返回5
    public int GetAdventureFBID()
    {
        DungeonRecord dungeonRecord;
        if (dungeonModel.TryGetRecord(TurnFightModel.AdventureMapID, out dungeonRecord))
        {
            return dungeonRecord.passLineID + 1;
        }

        return 1;
    }

    private void OnPlayerDataRefreshEvent(PlayerDataType type)
    {
        if (type == HeroControler.Instance.GetMoneyPlayerDataType(upgradeTreeMoneyType))
        {
            UpdateTreeRedpoint();
        }
    }

    Redpoint redpointTree = new Redpoint(MainRedDot.FairyTreeRedpoint);
    void UpdateTreeRedpoint()
    {
        redpointTree.state = RedPointState.None;
        if (m_LVUPState != 0) return;
        var config = TreeLVConfig.Get(GetTreeLV());
        if (config == null) return;
        if (UIHelper.GetMoneyCnt(upgradeTreeMoneyType) >= (ulong)config.LVUPNeedMoney)
        {
            redpointTree.state = RedPointState.Simple;
        }
    }
    //!!!功能入口的红点，仙盟107，洞府1，挑战3
}