using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Snxxz.UI;
using TableConfig;
using LitJson;

public class ComposeWinModel : Model, IBeforePlayerDataInitialize,IPlayerLoginOk
{
    private Dictionary<int, Dictionary<int, List<ItemCompoundConfig>>> firstTypeDict = null;
    private Dictionary<int, List<ItemCompoundConfig>> secondTypeDict = null;
    private Dictionary<int, List<int>> composeJobLimitDict = new Dictionary<int, List<int>>();
    private FuncConfigConfig addonsFormulaModel;
    public event Action ResetModelEvent;
    SelectEquipModel _selectModel;
    SelectEquipModel selectModel
    {
        get { return _selectModel ?? (_selectModel = ModelCenter.Instance.GetModel<SelectEquipModel>()); }
    }

    PlayerPackModel _playerPack;
    PlayerPackModel playerPack
    {
        get { return _playerPack ?? (_playerPack = ModelCenter.Instance.GetModel<PlayerPackModel>()); }
    }

    ItemTipsModel _itemTipsModel;
    ItemTipsModel itemTipsModel { get { return _itemTipsModel ?? (_itemTipsModel = ModelCenter.Instance.GetModel<ItemTipsModel>()); } }

    GetItemPathModel _itemPathModel;
    GetItemPathModel itemPathModel
    {
        get { return _itemPathModel ?? (_itemPathModel = ModelCenter.Instance.GetModel<GetItemPathModel>()); }
    }

    public override void Init()
    {
        addonsFormulaModel = Config.Instance.Get<FuncConfigConfig>("ComposeAddonsFormula");
        composeJobLimitDict.Clear();
        FuncConfigConfig funcConfig = Config.Instance.Get<FuncConfigConfig>("ComposeJobLimit");
        JsonData limitData = JsonMapper.ToObject(funcConfig.Numerical1);
        foreach(var job in limitData.Keys)
        {
            List<int> idlist = new List<int>();
            composeJobLimitDict.Add(int.Parse(job),idlist);
            if(limitData[job].IsArray)
            {
                for(int i= 0; i < limitData[job].Count; i++)
                {
                    int id = int.Parse(limitData[job][i].ToString());
                    idlist.Add(id);
                }
            }
        }
    }

    public override void UnInit()
    {

    }

    public void OnBeforePlayerDataInitialize()
    {
        firstTypeDict = null;
        secondTypeDict = null;
        secondType = 0;
        thirdType = 0;
    }

    public void OnPlayerLoginOk()
    {
        SetComposeTypeRed();
        RefreshComposeRed();
        playerPack.RefreshItemCountAct -= OnItemCntRefresh;
        playerPack.RefreshItemCountAct += OnItemCntRefresh;
        PlayerDatas.Instance.PlayerDataRefreshInfoEvent -= PlayerLvUpdate;
        PlayerDatas.Instance.PlayerDataRefreshInfoEvent += PlayerLvUpdate;
    }

    public void ResetModel()
    {
        if (ResetModelEvent != null)
        {
            ResetModelEvent();
        }
    }


    private void PlayerLvUpdate(PlayerDataRefresh type)
    {
        if (type != PlayerDataRefresh.LV) return;

        SetComposeTypeRed();
        RefreshComposeRed();
    }

    public bool IsComposeJobLimit(int composeId)
    {
        int playerJob = PlayerDatas.Instance.baseData.Job;
       if (composeJobLimitDict.ContainsKey(playerJob))
        {
            if(composeJobLimitDict[playerJob].Contains(composeId))
            {
                return true;
            }
        }
        return false;
    }

    public Dictionary<int, Dictionary<int, List<ItemCompoundConfig>>> GetFirstTypeModel(int firstType)
    {
        firstTypeDict = null;
        firstTypeDict = ItemCompoundConfig.GetFirstComposeTypeDict((int)firstType);
        return firstTypeDict;
    }

    public Dictionary<int, List<ItemCompoundConfig>> GetSecondTypeModel(int firstType,int secondType)
    {
        GetFirstTypeModel(firstType);
        secondTypeDict = null;
        if (firstTypeDict != null)
        {
            firstTypeDict.TryGetValue(secondType, out secondTypeDict);
        }
        return secondTypeDict;
    }

    public List<ItemCompoundConfig> GetThirdTypeModellist(int firstType,int secondType,int thirdType)
    {
        List<ItemCompoundConfig> modellist = null;
        GetSecondTypeModel(firstType, secondType);
        if(secondTypeDict != null)
        {
            secondTypeDict.TryGetValue(thirdType, out modellist);
        }
        return modellist;
    }

    public int GetTicketId(int firstType, int secondType, int thirdType)
    {
        var itemId = 0;
        var dict = ItemCompoundConfig.GetFirstComposeTypeDict(firstType);
        Dictionary<int, List<ItemCompoundConfig>> _secondTypeDict = null;
        dict.TryGetValue(secondType, out _secondTypeDict);
        if (_secondTypeDict != null)
        {
            List<ItemCompoundConfig> modellist = null;
            _secondTypeDict.TryGetValue(thirdType, out modellist);
            if (modellist != null && modellist.Count > 0)
            {
                int.TryParse(modellist[0].makeID, out itemId);
            }
        }
        return itemId;
    }

    public ItemCompoundConfig CurComposeModel { get; private set; }
    public void SetCurComposeModel(ItemCompoundConfig compoundModel)
    {
        CurComposeModel = compoundModel;
    }

    public bool IsEnoughUnfixedMat(ItemCompoundConfig compoundModel)
    {
        if (selectModel.GetHaveUnfixedSelectItem().Count < compoundModel.unfixedItemCount)
        {
            return false;
        }
        return true;
    }

    public bool IsEnoughFixedMat(ItemCompoundConfig config)
    {
        if (config == null) return false;
        int[] fixedIds = ItemCompoundConfig.GetDisplayArrayByType(config.id,DisplayItemArray.FixedIds);
        int[] fixedCounts = ItemCompoundConfig.GetDisplayArrayByType(config.id, DisplayItemArray.FixedCounts);
        for ( int i = 0; i < fixedCounts.Length; i++)
        {
            int haveCount = playerPack.GetItemCountByID(PackType.rptItem,fixedIds[i]);
            if (haveCount < fixedCounts[i])
            {
                return false;
            }
        }

        return true;
    }

    public bool IsEnoughMoney(ItemCompoundConfig compoundModel)
    {
        ulong needMoney = (ulong)compoundModel.money;
        if (UIHelper.GetMoneyCnt(3) < needMoney)
        {
            return false;
        }
        return true;
    }
    /// <summary>
    /// 发送合成请求
    /// </summary>
    private byte[] fixedIndexArray = null;
    private byte[] addonsReduceArray = null;
    private byte[] unfixedIndexArray = null;
    Dictionary<int, Dictionary<int, int>> fixedMatIsBindDict = new Dictionary<int, Dictionary<int, int>>();  //id , isBind, count
    Dictionary<int, Dictionary<int, int>> unfixedMatIsBindDict = new Dictionary<int, Dictionary<int, int>>();

    public void SendComposeRequest(ItemCompoundConfig compoundModel, Dictionary<int, List<int>> fixedItemIndexDict,UIEffect composEffect,int composeCount = 1,int successRate = 10000)
    {
        fixedMatIsBindDict.Clear();
        unfixedMatIsBindDict.Clear();

        if (compoundModel == null)
        {
            return;
        }

        int i = 0;
        if (!IsEnoughUnfixedMat(compoundModel))
        {
            MessageWin.Inst.ShowFixedTip(Language.Get("Compose101"));
            return;
        }

        int[] fixedIds = ItemCompoundConfig.GetDisplayArrayByType(compoundModel.id, DisplayItemArray.FixedIds);
        int[] fixedCounts = ItemCompoundConfig.GetDisplayArrayByType(compoundModel.id, DisplayItemArray.FixedCounts);
        for (i = 0; i < fixedCounts.Length; i++)
        {
            int haveCount = playerPack.GetItemCountByID(PackType.rptItem,fixedIds[i]);
            if (haveCount < fixedCounts[i])
            {
                ItemConfig fixedConfig = Config.Instance.Get<ItemConfig>(fixedIds[i]);
                if (fixedConfig.GetWay.Length < 1)
                {
                    ItemAttrData attrData = new ItemAttrData(fixedConfig.ID);
                    itemTipsModel.SetItemTipsModel(attrData);
                }
                else
                {
                    itemPathModel.SetChinItemModel(fixedConfig.ID);
                }
                return;
            }
        }
      
        if(!IsEnoughMoney(compoundModel))
        {
            ItemConfig fixedConfig = Config.Instance.Get<ItemConfig>(2100);
            if (fixedConfig.GetWay.Length < 1)
            {
                ItemAttrData attrData = new ItemAttrData(fixedConfig.ID);
                itemTipsModel.SetItemTipsModel(attrData);
            }
            else
            {
                itemPathModel.SetChinItemModel(fixedConfig.ID);
            }
            return;
        }

        fixedIndexArray = DictToArray(fixedItemIndexDict);
        addonsReduceArray = new byte[selectModel.GetHaveAddSelectItem().Count];
        for (i = 0; i < addonsReduceArray.Length; i++)
        {
            addonsReduceArray[i] = 1;
        }

        if(fixedIndexArray != null)
        {
            for(i= 0; i < fixedIndexArray.Length;i++ )
            {
                ItemModel itemModel = playerPack.GetItemModelByIndex(PackType.rptItem,fixedIndexArray[i]);
                SetMatIsBindDict(itemModel,fixedMatIsBindDict);
            }
        }

        if(compoundModel.unfixedItemCount > 0)
        {
            unfixedIndexArray = DictToArray(selectModel.GetHaveUnfixedSelectItem());
        }
        else
        {
            unfixedIndexArray = null;
        }

        if (unfixedIndexArray != null)
        {
            for (i = 0; i < unfixedIndexArray.Length; i++)
            {
                ItemModel itemModel = playerPack.GetItemModelByIndex(PackType.rptItem, unfixedIndexArray[i]);
                SetMatIsBindDict(itemModel,unfixedMatIsBindDict);
            }
        }

        if(composeCount < 2)
        {
            bool isBind = IsBindByFixedAndUnFixedMat(fixedMatIsBindDict, unfixedMatIsBindDict);
            bool isHaveRefineMat = IsEatHaveRefineMat();
            if (compoundModel.successUpper > 0)
            {
                if (successRate < compoundModel.successUpper)
                {
                    ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), Language.Get("ComposeSucRate"),
                        (bool isOk) =>
                        {
                            if (isOk)
                            {
                                if (isBind)
                                {
                                    ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), Language.Get("Compose104"),
                                        (bool isCompose) =>
                                        {
                                            if (isCompose)
                                            {
                                                if (successRate < 10000)
                                                {
                                                    if (isHaveRefineMat)
                                                    {
                                                        ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), Language.Get("Compose108"), (bool sure) =>
                                                        {
                                                            if (sure)
                                                            {
                                                                SendComposeQuest(compoundModel, composEffect, unfixedIndexArray, composeCount);
                                                            }
                                                        });
                                                        return;
                                                    }
                                                    else
                                                    {
                                                        SendComposeQuest(compoundModel, composEffect, unfixedIndexArray, composeCount);
                                                    }
                                                }
                                                else
                                                {
                                                    SendComposeQuest(compoundModel, composEffect, unfixedIndexArray, composeCount);
                                                }
                                            }
                                               
                                        });
                                    return;
                                }
                                else
                                {
                                    if (successRate < 10000)
                                    {
                                        if (isHaveRefineMat)
                                        {
                                            ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), Language.Get("Compose108"), (bool sure) =>
                                            {
                                                if (sure)
                                                {
                                                    SendComposeQuest(compoundModel, composEffect, unfixedIndexArray, composeCount);
                                                }
                                            });
                                            return;
                                        }
                                        else
                                        {
                                            SendComposeQuest(compoundModel, composEffect, unfixedIndexArray, composeCount);
                                        }
                                    }
                                    else
                                    {
                                        SendComposeQuest(compoundModel, composEffect, unfixedIndexArray, composeCount);
                                    }
                                }
                            }
                        });
                    return;
                }
            }

            if (isBind)
            {
                ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), Language.Get("Compose104"),
                    (bool isCompose) =>
                    {
                        if (isCompose)
                        {
                            SendComposeQuest(compoundModel, composEffect, unfixedIndexArray, composeCount);
                        }
                    });
            }
            else
            {
                SendComposeQuest(compoundModel, composEffect, unfixedIndexArray, composeCount);
            }
        }
        else
        {
            List<int> idlist = fixedMatIsBindDict.Keys.ToList();
            if(idlist.Count > 1)
            {
                int minBindCnt = 0;
                int startBindCnt = 0;
                int nextBindCnt = 0;
                if(fixedMatIsBindDict[idlist[0]].ContainsKey(1))
                {
                    startBindCnt = fixedMatIsBindDict[idlist[0]][1];
                }
                if(fixedMatIsBindDict[idlist[1]].ContainsKey(1))
                {
                    nextBindCnt = fixedMatIsBindDict[idlist[1]][1];
                }
                minBindCnt = startBindCnt > nextBindCnt ?  nextBindCnt : startBindCnt;

                int minNoBindCnt = 0;
                int startNoBindCnt = 0;
                int nextNoBindCnt = 0;
                if (fixedMatIsBindDict[idlist[0]].ContainsKey(0))
                {
                    startNoBindCnt = fixedMatIsBindDict[idlist[0]][0];
                }
                if (fixedMatIsBindDict[idlist[1]].ContainsKey(0))
                {
                    nextNoBindCnt = fixedMatIsBindDict[idlist[1]][0];
                }
                minNoBindCnt = startNoBindCnt > nextNoBindCnt ? nextNoBindCnt : startNoBindCnt;

                int remainNum = composeCount - minBindCnt - minNoBindCnt;

                if(startBindCnt > minBindCnt)
                {
                    if(remainNum > startBindCnt - minBindCnt)
                    {
                        minBindCnt = startBindCnt;
                    }
                    else
                    {
                        minBindCnt += remainNum;
                    }
                }
                else if(nextBindCnt > minBindCnt)
                {
                    if (remainNum > nextBindCnt - minBindCnt)
                    {
                        minBindCnt = nextBindCnt;
                    }
                    else
                    {
                        minBindCnt += remainNum;
                    }
                }

                minNoBindCnt = composeCount - minBindCnt;

                ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), Language.Get("Compose107",GetComposeInfoStr(minBindCnt,minNoBindCnt)),
                   (bool isCompose) =>
                   {
                       if (isCompose)
                       {
                           SendComposeQuest(compoundModel, composEffect, unfixedIndexArray, composeCount);
                       }
                   });
            }
            else
            {
                int bindCnt = 0;
                int noBindCnt = 0;
                if(fixedMatIsBindDict[idlist[0]].ContainsKey(1))
                {
                    bindCnt = fixedMatIsBindDict[idlist[0]][1];
                }

                if(fixedMatIsBindDict[idlist[0]].ContainsKey(0))
                {
                    noBindCnt = fixedMatIsBindDict[idlist[0]][0];
                }
               
                int remainBind = bindCnt % fixedCounts[0];
                int remainNOBind = noBindCnt % fixedCounts[0];
                bindCnt = bindCnt / fixedCounts[0];
                noBindCnt = noBindCnt / fixedCounts[0];
                if (bindCnt + noBindCnt < composeCount)
                {
                    bindCnt = composeCount - noBindCnt;
                }
                ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), Language.Get("Compose107",GetComposeInfoStr(bindCnt,noBindCnt)),
                   (bool isCompose) =>
                   {
                       if (isCompose)
                       {
                           SendComposeQuest(compoundModel, composEffect, unfixedIndexArray, composeCount);
                       }
                   });
            }
        }
    }

    public void SendComposeQuest(ItemCompoundConfig compoundModel,UIEffect composEffect,byte[] unfixedIndexArray, int composeCount)
    {
        composEffect.Play();
        CA303_tagCMItemCompound itemCompose = null;
        itemCompose = new CA303_tagCMItemCompound();
        itemCompose.ID = (uint)compoundModel.id;
        itemCompose.CompoundCnt = (ushort)composeCount;
        itemCompose.UnfixedItemIndexCnt = (byte)selectModel.GetHaveUnfixedSelectItem().Count;
        itemCompose.UnfixedItemIndex = unfixedIndexArray;
        itemCompose.FixedItemIndexCnt = (byte)fixedIndexArray.Length;
        itemCompose.FixedItemIndex = fixedIndexArray;
        itemCompose.AddonsItemIndexCnt = (byte)selectModel.GetHaveAddSelectItem().Count;
        itemCompose.AddonsItemIndex = DictToArray(selectModel.GetHaveAddSelectItem());
        itemCompose.AddonsItemCount = addonsReduceArray;
        GameNetSystem.Instance.SendInfo(itemCompose);
    }

    public bool IsBindByFixedAndUnFixedMat(Dictionary<int, Dictionary<int, int>> fixedMat, Dictionary<int, Dictionary<int, int>>unfixedMat)
    {
        bool isFixedBind = false;
        bool fixedNoBindRecord = false;
        foreach (var id in fixedMat.Keys)
        {
            foreach (var bind in fixedMat[id].Keys)
            {
                if (bind == 1)
                {
                    isFixedBind = true;
                }
                else
                {
                    fixedNoBindRecord = true;
                }
            }
        }

        bool isUnFixedBind = false;
        bool unfixedNoBindRecord = false;
        foreach (var id in unfixedMat.Keys)
        {
            foreach (var bind in unfixedMat[id].Keys)
            {
                if (bind == 1)
                {
                    isUnFixedBind = true;
                }
                else
                {
                    unfixedNoBindRecord = true;
                }
            }
        }

        if(fixedMat.Count > 0 && unfixedMat.Count  > 0)
        {
            if(isFixedBind && isUnFixedBind)
            {
                return false;
            }
            else
            {
                if (isFixedBind || isUnFixedBind)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
           
        }
        else if(fixedMat.Count > 0)
        {
            if(isFixedBind && fixedNoBindRecord)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        else if(unfixedMat.Count > 0)
        {
            if (isUnFixedBind && unfixedNoBindRecord)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        return false;
    }

    private bool IsEatHaveRefineMat()
    {
        Dictionary<int,ItemModel> unfixedDic = selectModel.GetHaveUnfixedSelectItem();
        bool isRefineMat = false;
        foreach(var model in unfixedDic.Values)
        {
            if(model.GetUseDataModel((int)ItemUseDataKey.Def_IudetWingMaterialItemID) != null)
            {
                isRefineMat = true;
                break;
            }
        }
        return isRefineMat;
    }

    private void SetMatIsBindDict(ItemModel itemModel,Dictionary<int, Dictionary<int, int>> matDict)
    {
        if (itemModel == null) return;

        if (!matDict.ContainsKey(itemModel.itemId))
        {
            Dictionary<int, int> bindDict = new Dictionary<int, int>();
            if (!bindDict.ContainsKey(itemModel.itemInfo.IsBind))
            {
                bindDict.Add(itemModel.itemInfo.IsBind, itemModel.itemInfo.ItemCount);
            }
            matDict.Add(itemModel.itemId, bindDict);
        }
        else
        {
            if (!matDict[itemModel.itemId].ContainsKey(itemModel.itemInfo.IsBind))
            {
                matDict[itemModel.itemId].Add(itemModel.itemInfo.IsBind, itemModel.itemInfo.ItemCount);
            }
            else
            {
                matDict[itemModel.itemId][itemModel.itemInfo.IsBind] += itemModel.itemInfo.ItemCount;
            }
        }
    }

    private string GetComposeInfoStr(int bindCnt,int noBindCnt)
    {
        if (CurComposeModel == null) return string.Empty;
        int[] makeIds = ItemCompoundConfig.GetDisplayArrayByType(CurComposeModel.id,DisplayItemArray.MakeIds);
        ItemConfig config = Config.Instance.Get<ItemConfig>(makeIds[0]);
        StringBuilder stringBuilder = new StringBuilder();
        if (bindCnt > 0)
        {
            string s = StringUtility.Contact(config.ItemName,Language.Get("Compose105"), "x", bindCnt, "</r>");
            stringBuilder.Append(s);
        }

        if (noBindCnt > 0)
        {
            string s = StringUtility.Contact(config.ItemName,Language.Get("Compose106"), "x", noBindCnt);
            stringBuilder.Append(s);
        }

        return stringBuilder.ToString();
    }

    private byte[] DictToArray(Dictionary<int, ItemModel> itemDict)
    {
        byte[] itemArray = new byte[itemDict.Count];
        int[] itemIndexs = itemDict.Keys.ToArray();
        int i = 0;
        for (i = 0; i < itemIndexs.Length; i++)
        {
            itemArray[i] = (byte)itemIndexs[i];
        }

        return itemArray;
    }

    private byte[] DictToArray(Dictionary<int, List<int>> itemDict)
    {
        int itemArrayLength = 0;
        foreach (List<int> list in itemDict.Values)
        {
            itemArrayLength += list.Count;
        }
        byte[] itemArray = new byte[itemArrayLength];
        int i = 0;
        foreach (List<int> list in itemDict.Values)
        {
            int j = 0;
            for (j = 0; j < list.Count; j++)
            {
                itemArray[i] = (byte)list[j];
                i++;
            }


        }
        return itemArray;
    }

    public void GetBindOrNoBindMinCnt(out int minBindCnt,out int minNoBindCnt)
    {
        minBindCnt = 0;
        minNoBindCnt = 0;
        if (CurComposeModel == null) return;

        Dictionary<int, int> bindCntDic = new Dictionary<int, int>();
        Dictionary<int, int> noBindCntDic = new Dictionary<int, int>();
        int[] fixedIds = ItemCompoundConfig.GetDisplayArrayByType(CurComposeModel.id,DisplayItemArray.FixedIds);
        for (int i = 0; i < fixedIds.Length;i++)
        {
            List<ItemModel> list = null;
            playerPack.GetSinglePackModel(PackType.rptItem).GetItemCountByID(fixedIds[i],out list);
            if(list != null)
            {
                int bindCnt = 0;
                int noBindCnt = 0;
                for (int j = 0; j < list.Count;j++)
                {
                    if (list[j].itemInfo.IsBind == 1)
                    {
                        bindCnt += list[j].itemInfo.ItemCount;

                    }
                    else if (list[j].itemInfo.IsBind == 0)
                    {
                        noBindCnt += list[j].itemInfo.ItemCount;
                    }
                }
                bindCntDic.Add(fixedIds[i], bindCnt);
                noBindCntDic.Add(fixedIds[i], noBindCnt);
            }
        }

        List<int> bindCntlist = bindCntDic.Values.ToList();
        bindCntlist.Sort();
        if(bindCntlist.Count > 0)
        {
            minBindCnt = bindCntlist[0];
        }

        List<int> noBindCntlist = noBindCntDic.Values.ToList();
        noBindCntlist.Sort();
        if (noBindCntlist.Count > 0)
        {
            minNoBindCnt = noBindCntlist[0];
        }

    }

    /// <summary>
    /// 计算附加材料增加的成功率
    /// </summary>
    /// <param name="tagItemCompound"></param>
    /// <param name="itemModel"></param>
    /// <param name="successRate"></param>
    /// <param name="addRate"></param>
    /// <returns></returns>
    public int GetComposeSuccessRate(ItemCompoundConfig tagItemCompound, ItemModel itemModel, int successRate)
    {
        Equation.Instance.Clear();
        Equation.Instance.AddKeyValue("itemClassLV", itemModel.chinItemModel.LV);
        Equation.Instance.AddKeyValue("itemColor", itemModel.chinItemModel.ItemColor);
        int minRate = Equation.Instance.Eval<int>(addonsFormulaModel.Numerical1);
        if (tagItemCompound.successUpper != 0)
        {
            if (successRate < tagItemCompound.successUpper)
            {
                successRate += minRate;
            }

            if (successRate >= tagItemCompound.successUpper)
            {
                successRate = tagItemCompound.successUpper;
            }
        }
        else
        {
            successRate += minRate;
        }

        return successRate;
    }

    /// <summary>
    /// 判断是否可以合成门票
    /// </summary>
    /// <param name="composeItemID"></param>
    /// <returns></returns>
    public bool IsComposeTicketByType(int secondType)
    {
        bool isEnough = true;
        Dictionary<int, Dictionary<int, List<ItemCompoundConfig>>> getFirstModel = ItemCompoundConfig.GetFirstComposeTypeDict((int)ComposeFuncType.Ticket);
        if (getFirstModel.ContainsKey(secondType))
        {
            if (getFirstModel[secondType].ContainsKey(0))
            {
                ItemCompoundConfig compoundConfig = getFirstModel[secondType][0][0];
                int[] fixedIDs = ConfigParse.GetMultipleStr<int>(compoundConfig.itemID);
                int[] fixedCnt = ConfigParse.GetMultipleStr<int>(compoundConfig.itemCount);
                for (int i = 0; i < fixedIDs.Length; i++)
                {
                    int haveCnt = playerPack.GetItemCountByID(PackType.rptItem, fixedIDs[i]);
                    if (fixedCnt[i] > haveCnt)
                    {
                        isEnough = false;
                        break;
                    }
                }
            }
            else
            {
                isEnough = false;
            }
        }
        else
        {
            isEnough = false;
        }
        return isEnough;
    }

    #region 处理跳转界面数据

    public bool CheckComposeItemById(int itemId,out int jumpId)
    {
        jumpId = 0;
        ItemConfig itemConfig = Config.Instance.Get<ItemConfig>(itemId);
        if (itemConfig == null) return false;

        int[] composeCondi = itemConfig.JumpComposeCondi;
        if (composeCondi.Length < 3) return false;
        ItemCompoundConfig itemCompound = GetThirdTypeModellist(composeCondi[0],composeCondi[1],composeCondi[2])[0];
        if(itemCompound.levelNeed <= PlayerDatas.Instance.baseData.LV)
        {
            switch (itemCompound.firstType)
            {
                case 1:
                    jumpId = (int)JumpUIType.ComposeFunc1;
                    break;
                case 2:
                    jumpId = (int)JumpUIType.ComposeFunc2;
                    break;
                case 3:
                    jumpId = (int)JumpUIType.ComposeFunc3;
                    break;
                case 4:
                    jumpId = (int)JumpUIType.ComposeFunc4;
                    break;
                case 5:
                    jumpId = (int)JumpUIType.ComposeFunc5;
                    break;
            }
            this.secondType = itemCompound.secondType;

            if(itemCompound.firstType == 5 && itemCompound.secondType == 3)
            {
                this.thirdType = PlayerDatas.Instance.baseData.Job;
            }
            else
            {
                this.thirdType = itemCompound.thirdType;
            }
            return true;
        }
        else
        {
            SysNotifyMgr.Instance.ShowTip("TicketComposeUnlock", itemCompound.levelNeed, itemCompound.secondTypeName);
            return false;
        }
    }

    public int secondType { get; private set; }
    public int thirdType { get; private set;}
    public void SetJumpToModel(ComposeFuncType type,int secondType,int thirdType)
    {
        this.secondType = secondType;
        this.thirdType = thirdType;
        GetFirstTypeModel((int)type);
        Dictionary<int, List<ItemCompoundConfig>> dict = GetSecondTypeModel((int)type,secondType);
        if(dict == null)
        {
            SysNotifyMgr.Instance.ShowTip("FuncLimit_Level");
            ResetJumpToModel();
        }
    }

    public void ResetJumpToModel()
    {
        this.secondType = 0;
        this.thirdType = 0;
        AchievementGoto.guideAchievementId = 0;
    }
    #endregion

    #region 红点逻辑
    public const int COMPOSE_REDKEY = 109;
    public const int COMPOSETOOL_REDKEY = 10905;
    public const int COMPOSEBTN_REDKEY = 10910;
    public Redpoint composeRed = new Redpoint(MainRedDot.RedPoint_key,COMPOSE_REDKEY);
    public Redpoint composeBtnRed = new Redpoint(COMPOSEBTN_REDKEY);
    public Redpoint composeToolRed = new Redpoint(COMPOSE_REDKEY,COMPOSETOOL_REDKEY);
    public Dictionary<int, Redpoint> secondTypeRedDict = new Dictionary<int, Redpoint>();
    public Dictionary<string, Redpoint> thirdTypeRedDict = new Dictionary<string, Redpoint>();
    public void SetComposeTypeRed()
    {
        secondTypeRedDict.Clear();
        thirdTypeRedDict.Clear();
        Dictionary<int, Dictionary<int, List<ItemCompoundConfig>>> firstDict = ItemCompoundConfig.GetFirstComposeTypeDict((int)ComposeFuncType.Item);
        if (firstDict == null) return;

        foreach(var secondType in firstDict.Keys)
        {
            int secondRedKey = COMPOSETOOL_REDKEY * 100 + secondType;
            Redpoint secondRed = new Redpoint(COMPOSETOOL_REDKEY, secondRedKey);
            secondTypeRedDict.Add(secondType, secondRed);
            foreach(var thirdType in firstDict[secondType].Keys)
            {
                int thirdRedKey = secondRedKey*100 + thirdType;
                Redpoint thirdRed = new Redpoint(secondRedKey,thirdRedKey);
                string key = StringUtility.Contact(secondType,10,thirdType);
                thirdTypeRedDict.Add(key,thirdRed);
            }
        }
    }

    private void OnItemCntRefresh(PackType type, int index, int id)
    {
        if (type != PackType.rptItem) return;

        ItemConfig itemConfig = Config.Instance.Get<ItemConfig>(id);
        if(itemConfig != null && itemConfig.Type == (int)ItemType.ComposeSuitStone)
        {
            RefreshComposeRed();
        }
    }

    public void RefreshComposeRed()
    {
        Dictionary<int, Dictionary<int, List<ItemCompoundConfig>>> firstDict = ItemCompoundConfig.GetFirstComposeTypeDict((int)ComposeFuncType.Item);
        if (firstDict == null || !FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Compose)) return;

        if (firstDict.ContainsKey(3))
        {
           foreach(var thirdType in firstDict[3].Keys)
            {
                List<ItemCompoundConfig> compoundlist = firstDict[3][thirdType];
                for(int i = 0; i < compoundlist.Count; i++)
                {
                    int makeID = ConfigParse.GetMultipleStr<int>(compoundlist[i].makeID)[i];
                    string key = StringUtility.Contact(3, 10, thirdType);
                    if (IsComposeJobLimit(makeID) && IsEnoughFixedMat(compoundlist[i]))
                    {
                        if (thirdTypeRedDict[key].state != RedPointState.Simple)
                        {
                            thirdTypeRedDict[key].state = RedPointState.Simple;
                        } 
                    }
                    else
                    {
                        if (thirdTypeRedDict[key].state != RedPointState.None)
                        {
                            thirdTypeRedDict[key].state = RedPointState.None;
                        }
                    }
                }
               
            }
        }
    }
    #endregion

}

public enum ComposeFuncType
{
    Wings = 1,
    Ticket = 2,
    Fairy = 3,
    Equip = 4,
    Item = 5,
    MountDogz = 6,
}

public enum NeedMatType
{
    Nothing,
    MakeItem,
    fixedItem,
    unfixedItem,
    addItem,
}

public enum DisplayItemArray
{
    MakeIds,
    UnfixedIds,
    FixedIds,
    FixedCounts,
    UnfixedDisplay,
    FixedDisplay,
}