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

public class BlastFurnaceModel : Model, IBeforePlayerDataInitialize, IAfterPlayerDataInitialize, IPlayerLoginOk
{
    public BlastFurnaceFuncTitle funcTitle = BlastFurnaceFuncTitle.MakeDan;

    public Action<AlchemySpecConfig> RefreshAddSpecMatEvent;

    private TreasureModel _model;
    public TreasureModel sTreasureModel
    {
        get
        {
            return _model ?? (_model = ModelCenter.Instance.GetModel<TreasureModel>());
        }
    }

    private FuncConfigConfig _upTreasureRateModel;
    private FuncConfigConfig _blastFurnaceExpModel;
    private ItemConfig chinItemModel;
    private Dictionary<int, int> _blastFurnaceExpDict;
    public int[] extraMats { get; private set; }

    public int MaxStoveLv { get; private set; }
    public List<AlchemyConfig> alchemyModellist { get; private set; }

    public int jumpToPrescripe { get; set; }

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

    public override void Init()
    {
        _blastFurnaceExpDict = new Dictionary<int, int>();
        extraMats = null;
        alchemyModellist = null;
        _upTreasureRateModel = Config.Instance.Get<FuncConfigConfig>("TreasureUpRateItem");
        if (_upTreasureRateModel != null)
            extraMats = ConfigParse.GetMultipleStr<int>(_upTreasureRateModel.Numerical2);


        List<RefineStoveConfig> stovelist = Config.Instance.GetAllValues<RefineStoveConfig>();
        MaxStoveLv = 0;
        if (stovelist != null)
        {
            for (int i = 0; i < stovelist.Count; i++)
            {
                _blastFurnaceExpDict.Add(stovelist[i].LV, stovelist[i].Exp);
            }

            MaxStoveLv = stovelist[stovelist.Count - 1].LV;
        }

        alchemyModellist = Config.Instance.GetAllValues<AlchemyConfig>();
        SetDandrugRedPointlist();
        GlobalTimeEvent.Instance.secondEvent += SecondUpdate;
    }

    public override void UnInit()
    {
        GlobalTimeEvent.Instance.secondEvent -= SecondUpdate;
    }

    public void OnBeforePlayerDataInitialize()
    {
        isFirstGet = true;
        isMakeDan = false;
        _stovelv = 1;
        _stoveExp = 0;
        addExp = 0;
        preStoveLv = 1;
        jumpToPrescripe = 0;
        treasureRefineDict.Clear();
        FuncOpen.Instance.OnFuncStateChangeEvent -= RefreshFuncOpenState;
        playerPack.RefreshItemCountAct -= RefreshMat;
        playerPack.ItemCntReduceAct -= RefreshDanReduce;
        playerPack.RefreshItemSumUseCntAct -= RefreshItemUsce;
        WindowCenter.Instance.windowAfterCloseEvent -= StoveUpgradAfterClose;

    }
    public void OnAfterPlayerDataInitialize()
    {
        playerPack.RefreshItemCountAct += RefreshMat;
        FuncOpen.Instance.OnFuncStateChangeEvent += RefreshFuncOpenState;
        playerPack.RefreshItemSumUseCntAct += RefreshItemUsce;
        WindowCenter.Instance.windowAfterCloseEvent += StoveUpgradAfterClose;
        playerPack.ItemCntReduceAct += RefreshDanReduce;
    }

    private void RefreshFuncOpenState(int funcId)
    {
        if (funcId != (int)FuncOpenEnum.BlastFurnace) return;

        CheckMakerDandrugCondition();
        CheckRecycleStoreRed();
    }

    public void OnPlayerLoginOk()
    {
        CheckMakerDandrugCondition();
        CheckRecycleStoreRed();
    }

    public void RefreshAddSpecMat(AlchemySpecConfig alchemySpecModel)
    {
        if (RefreshAddSpecMatEvent != null)
            RefreshAddSpecMatEvent(alchemySpecModel);
    }

    public bool isMakeDan { get; set; }
    public bool isFirstGet { get; private set;}
    private void SecondUpdate()
    {
        if (makerItemID == 0) return;

        if(isMakeDan)
        {
            if(!WindowCenter.Instance.CheckOpen<MakerDrugSuccessWin>())
            {
                WindowCenter.Instance.Open<MakerDrugSuccessWin>();
            }
            isMakeDan = false;
        }
        else
        {
            if (WindowCenter.Instance.CheckOpen<MakerDrugSuccessWin>())
            {
                WindowCenter.Instance.CloseImmediately<MakerDrugSuccessWin>();
            }
        }
    }

    /// <summary>
    /// 得到服务端的炼丹炉数据
    /// </summary>
    private int _stovelv = 1;
    private int preStoveLv = 1;
    public int StoveLV { get { return _stovelv; } }    // 炼丹炉等级
    private int _stoveExp = 0;
    public int StoveExp { get { return _stoveExp; } }    // 炼丹炉经验 
    public int addExp = 0;
    public event Action RefreshStoveModelEvent;
    public int makerItemID { get; private set; }
    public bool StoveIsUpGrade { get; private set; }
    public void RefreshBlastFurnaceModel(HA3BF_tagMCPlayerStoveMsg data)
    {
        DebugEx.Log("RefreshBlastFurnaceModel");
        addExp = (int)data.StoveExp - _stoveExp;
        if (addExp < 0)
        {
            addExp = GetBlastFurnaceUpgradExp() - _stoveExp + (int)data.StoveExp;
        }
        _stovelv = data.StoveLV;
        _stoveExp = (int)data.StoveExp;
        makerItemID = (int)data.ItemID;
        CheckMakerDandrugCondition();
        if(!isFirstGet)
        {
            isMakeDan = true;
            if(preStoveLv < data.StoveLV)
            {
                preStoveLv = data.StoveLV;
                StoveIsUpGrade = true;
            }
            else
            {
                preStoveLv = data.StoveLV;
                StoveIsUpGrade = false;
            }
            PlayRecycleGuid();
        }
        else
        {
            isFirstGet = false;
            preStoveLv = data.StoveLV;
        }
        if (RefreshStoveModelEvent != null)
            RefreshStoveModelEvent();

        if(makerItemID == 0 && addExp > 0)
        {
            SysNotifyMgr.Instance.ShowTip("RecyclingElixir", addExp);
        }
    }

    public bool IsReachMaxStoveLv()
    {
        bool isReach = false;
        if (StoveLV >= MaxStoveLv)
        {
            if (StoveExp >= GetBlastFurnaceUpgradExp())
            {
                isReach = true;
            }
        }
        return isReach;
    }

    public Dictionary<uint, byte> treasureRefineDict = new Dictionary<uint, byte>(); //key 法宝ID value 等级
    public event Action RefreshTreasureRefineEvent;
    public Treasure treasureData { get; private set; }
    public void RefreshTreasureRefineModel(HA3BE_tagMCMagicWeaponMsg data)
    {
    }

    public int GetAllTreasureRefineLv()
    {
        int sumLv = 0;
        foreach (var value in treasureRefineDict.Values)
        {
            sumLv += value;
        }
        return sumLv;
    }

    /// <summary>
    /// 判断法宝是否精炼到满级
    /// </summary>
    /// <param name="treasureId"></param>
    /// <param name="lv"></param>
    /// <returns></returns>
    public bool TreasureIsFullLv(int treasureId, int lv)
    {
        if (_tagTreasureRefineModeDict == null)
            return false;

        if (_tagTreasureRefineModeDict.ContainsKey(treasureId))
        {
            if (_tagTreasureRefineModeDict[treasureId][_tagTreasureRefineModeDict[treasureId].Count - 1].TreasureLV <= lv)
            {
                return true;
            }
        }
        return false;
    }

    /// <summary>
    /// 得到炼丹和铸炼的结果
    /// </summary>
    public event Action<MakeType,int> RefreshMakeItemAnswerAct;
    public void GetMakerResult(H0721_tagMakeItemAnswer answer)
    {
        DebugEx.Log("GetMakerResult" + answer.Result);
        switch((MakeType)answer.MakeType)
        {
            case MakeType.Def_mitRefine:
                if (answer.Result == 1)
                {
                    if (makerItemID != 0)
                    {
                        if (!WindowCenter.Instance.CheckOpen<MakerDrugSuccessWin>())
                        {
                            WindowCenter.Instance.Open<MakerDrugSuccessWin>();
                        }
                    }
                }
                else
                {
                    if (!WindowCenter.Instance.CheckOpen<MakerDrugFailWin>())
                    {
                        WindowCenter.Instance.Open<MakerDrugFailWin>();
                    }
                }
                break;
            case MakeType.Def_mitMWUpLevel:
                if (answer.Result == 1)
                {
                    if (!WindowCenter.Instance.CheckOpen<TreasureRefineSuccessWin>())
                    {
                        WindowCenter.Instance.Open<TreasureRefineSuccessWin>();
                    }
                }
                else
                {
                    if (!WindowCenter.Instance.CheckOpen<TreasureRefineFailWin>())
                    {
                        WindowCenter.Instance.Open<TreasureRefineFailWin>();
                    }
                }
                break;
        }
        if(RefreshMakeItemAnswerAct != null)
        {
            RefreshMakeItemAnswerAct((MakeType)answer.MakeType,answer.Result);
        }
    }

    #region 灵丹和玄丹的逻辑处理

    /// <summary>
    /// 得到升级到下一级炼丹炉所需要的等级
    /// </summary>
    /// <returns></returns>
    public int GetBlastFurnaceUpgradExp()
    {
        int exp = 0;
        _blastFurnaceExpDict.TryGetValue(StoveLV, out exp);
        return exp;
    }

    /// <summary>
    /// 设置当前丹药所需材料
    /// </summary>
    private int[] materialIds;
    private int[] materialNums;
    private AlchemyConfig _tagAlchemyModel;
    private Dictionary<int, int> _alchemyMaterialDict;
    public void SetAlchemyMaterial(int alchemyId)
    {
        materialIds = null;
        materialNums = null;
        _tagAlchemyModel = Config.Instance.Get<AlchemyConfig>(alchemyId);
        if (_tagAlchemyModel == null)
            return;

        _alchemyMaterialDict = ConfigParse.GetDic<int, int>(_tagAlchemyModel.MaterialAll);
        materialIds = _alchemyMaterialDict.Keys.ToArray();
        materialNums = _alchemyMaterialDict.Values.ToArray();
    }

    /// <summary>
    /// 得到每个位置对应的材料
    /// </summary>
    public int materialId { get; private set; }
    public int materialNum { get; private set; }
    public void GetAlchemyMaterial(int pos)
    {
        materialId = 0;
        materialNum = 0;
        if (materialIds == null)
            return;
        if (pos < materialIds.Length)
        {
            materialId = materialIds[pos];
            materialNum = materialNums[pos];
        }
    }

    /// <summary>
    /// 得到预览合成丹药的列表
    /// </summary>
    public Dictionary<int, int> GetPreviewMakeDruglist(AlchemyConfig alchemyModel)
    {
        JsonData jsonData = JsonMapper.ToObject(alchemyModel.AlchemPreviewItem);
        PreviewItemDict.Clear();
        if (jsonData.IsArray)
        {
            for (int i = 0; i < jsonData.Count; i++)
            {
                if (jsonData[i].IsArray)
                {
                    int itemId = int.Parse(jsonData[i][0].ToString());
                    if (jsonData[i].Count > 1)
                    {
                        int effectId = int.Parse(jsonData[i][1].ToString());
                        PreviewItemDict.Add(itemId, effectId);
                    }
                    else
                    {
                        PreviewItemDict.Add(itemId, 0);
                    }
                }
            }
        }
        return PreviewItemDict;
    }

    Dictionary<int, int> PreviewItemDict = new Dictionary<int, int>();
    public Dictionary<int, int> GetPreviewSpecMakeDruglist(AlchemySpecConfig alchemyModel)
    {
        JsonData jsonData = JsonMapper.ToObject(alchemyModel.AlchemPreviewItem);
        PreviewItemDict.Clear();
        if (jsonData.IsArray)
        {
            for (int i = 0; i < jsonData.Count; i++)
            {
                if(jsonData[i].IsArray)
                {
                    int itemId = int.Parse(jsonData[i][0].ToString());
                    if (jsonData[i].Count > 1)
                    {
                        int effectId = int.Parse(jsonData[i][1].ToString());
                        PreviewItemDict.Add(itemId,effectId);
                    }
                    else
                    {
                        PreviewItemDict.Add(itemId,0);
                    }
                }
            }
        }
        return PreviewItemDict;
    }

    public int GetEffectIdByItemId(int itemId)
    {
        int effectId = 0;
        PreviewItemDict.TryGetValue(itemId,out effectId);
        return effectId;
    }

    /// <summary>
    /// 设置特殊材料的数据
    /// </summary>
    private List<AlchemySpecConfig> _alchemySpecModellist = new List<AlchemySpecConfig>();
    private AlchemySpecConfig _alchemySpecModel;
    public void SetAlchemySpecModellist(int[] models)
    {
        _alchemySpecModellist.Clear();
        if (models == null)
            return;
        int i = 0;
        for (i = 0; i < models.Length; i++)
        {
            _alchemySpecModel = Config.Instance.Get<AlchemySpecConfig>(models[i]);
            if (_alchemySpecModel != null)
            {
                _alchemySpecModellist.Add(_alchemySpecModel);
            }
        }
    }

    public List<AlchemySpecConfig> GetAlchemySpecModellist()
    {
        return _alchemySpecModellist;
    }
    #endregion

    #region 法宝的逻辑处理
    private List<int> collectedTreasurelist = new List<int>();
    private Dictionary<int, List<TreasureRefineConfig>> _tagTreasureRefineModeDict;
    public List<int> GetCollectedTreasureList()
    {
        collectedTreasurelist.Clear();
        _tagTreasureRefineModeDict = TreasureRefineConfig.GetTreasureRefineDict();
        foreach (var key in _tagTreasureRefineModeDict.Keys)
        {
            Treasure treasure = null;
            sTreasureModel.TryGetTreasure(key, out treasure);
            if (treasure != null)
            {
                if (treasure.state == TreasureState.Collected)
                {
                    collectedTreasurelist.Add(key);
                }
            }
        }
        return collectedTreasurelist;
    }

    /// <summary>
    /// 设置法宝铸炼的属性 材料
    /// </summary>

    public int[] attrIDs { get; private set; }
    public int[] attrValues { get; private set; }
    private Dictionary<int, int> _treasureAttrDict;

    public void SetTreasureRefineModel(TreasureRefineConfig model)
    {
        _treasureAttrDict = null;
        attrIDs = null;
        attrValues = null;

        if (model == null)
            return;
        _treasureAttrDict = ConfigParse.GetDic<int, int>(model.TreasureLVStatus);
        attrIDs = _treasureAttrDict.Keys.ToArray();
        attrValues = _treasureAttrDict.Values.ToArray();

    }

    public int[] nextAttrIDs { get; private set; }
    public int[] nextAttrValues { get; private set; }
    public int nextRefineMaterialID { get; private set; }
    public int nextRefineMaterialNum { get; private set; }
    private string[] arrays;
    private Dictionary<int, int> _nextTreasureAttrDict;
    public void SetNextTreasureRefineModel(TreasureRefineConfig model)
    {
        _nextTreasureAttrDict = null;
        nextAttrIDs = null;
        nextAttrValues = null;

        if (model == null)
            return;
        _nextTreasureAttrDict = ConfigParse.GetDic<int, int>(model.TreasureLVStatus);
        nextAttrIDs = _nextTreasureAttrDict.Keys.ToArray();
        nextAttrValues = _nextTreasureAttrDict.Values.ToArray();
        arrays = model.TreasureUpItems.Split('_');
        nextRefineMaterialID = int.Parse(arrays[0]);
        nextRefineMaterialNum = int.Parse(arrays[1]);
    }

    /// <summary>
    /// 得到当前法宝的所有技能
    /// </summary>
    public Dictionary<int, TreasureSkillData> treasureSkillDict = new Dictionary<int, TreasureSkillData>(); // key 技能ID
    private List<TreasureRefineConfig> _tagTreasureRefineModellist;
    public void SetTreasureSkillDict(int treasureId, int lv)
    {
        treasureSkillDict.Clear();
        _tagTreasureRefineModellist = TreasureRefineConfig.GetTreasureRefineList(treasureId);
        if (_tagTreasureRefineModellist == null)
            return;

        int i = 0;
        int length = _tagTreasureRefineModellist.Count;
        for (i = 0; i < length; i++)
        {
            if (_tagTreasureRefineModellist[i].OpenSkill != 0)
            {

                if (lv >= _tagTreasureRefineModellist[i].TreasureLV)
                {
                    TreasureSkillData skillData = new TreasureSkillData(_tagTreasureRefineModellist[i].TreasureLV, false);
                    AddTreasureSkillDict(_tagTreasureRefineModellist[i].OpenSkill, skillData);
                }
                else
                {
                    TreasureSkillData skillData = new TreasureSkillData(_tagTreasureRefineModellist[i].TreasureLV, true);
                    AddTreasureSkillDict(_tagTreasureRefineModellist[i].OpenSkill, skillData);
                }
            }
        }
    }
    private void AddTreasureSkillDict(int skillId, TreasureSkillData skillData)
    {
        if (treasureSkillDict.ContainsKey(skillId))
            treasureSkillDict[skillId] = skillData;
        else
            treasureSkillDict.Add(skillId, skillData);
    }

    /// <summary>
    /// 预览法宝属性值
    /// </summary>
    private PlayerPropertyConfig _playerProModel;
    public string GetTreasureAttrStr(int proID, int value, bool showName)
    {
        _playerProModel = Config.Instance.Get<PlayerPropertyConfig>(proID);
        if (_playerProModel == null)
            return "";
        string s = "";
        if (showName)
        {
            if (_playerProModel.Name.Contains("%s"))
                s = _playerProModel.Name.Replace("%s", GetProValueTypeStr(_playerProModel.ISPercentage, value));
            else
                s = _playerProModel.Name + ":" + GetProValueTypeStr(_playerProModel.ISPercentage, value);

        }
        else
        {
            s = GetProValueTypeStr(_playerProModel.ISPercentage, value);
        }
        return s;
    }

    public string GetFireSuccessRate(int proID, int value)
    {
        if (proID != 226)
            return "";

        string s = Language.Get("Supplement1006", Mathf.RoundToInt(value / 100));
        return s;
    }

    public int fireId { get; private set; }
    public event Action<float> RefreshSuccessRateEvent;
    public void SetCurUseFire(int fireId, float value)
    {
        this.fireId = fireId;
        if (RefreshSuccessRateEvent != null)
            RefreshSuccessRateEvent(value);
    }

    #endregion

    /// <summary>
    /// 得到可以选择炉火的丹药
    /// </summary>
    public List<int> canUseFireDandrugIDs { get; private set; }
    public void GetBlastFurnaceRecipe()
    {
        canUseFireDandrugIDs = null;
        _tagfuncModel = Config.Instance.Get<FuncConfigConfig>("BlastFurnaceRecipe");
        if (_tagfuncModel == null)
            return;
        canUseFireDandrugIDs = ConfigParse.GetMultipleStr<int>(_tagfuncModel.Numerical1).ToList();
    }

    #region 选择炉火逻辑处理

    /// <summary>
    /// 得到炼丹炉火和条件限制
    /// </summary>
    private FuncConfigConfig _tagfuncModel;
    public int[] fireIds { get; private set; }
    public int openBlastFurnaceLv { get; private set; }
    public void GetRefineStoveConditions()
    {
        fireIds = null;
        openBlastFurnaceLv = 0;
        _tagfuncModel = Config.Instance.Get<FuncConfigConfig>("RefineStove");
        if (_tagfuncModel == null)
            return;
        fireIds = ConfigParse.GetMultipleStr<int>(_tagfuncModel.Numerical1);
        openBlastFurnaceLv = int.Parse(_tagfuncModel.Numerical2);

    }



    #endregion

    public string GetProValueTypeStr(int isPercentage, int value)
    {
        string s = "";
        if (isPercentage == 0)
        {
            s = value.ToString();
        }
        else if (isPercentage == 1)
        {
            s = (float)Math.Round(value / 100f, 1) + "%";
        }
        else if (isPercentage == 2)
        {
            s = ((float)Math.Round(value / 100f, 1)).ToString();
        }
        return s;
    }

    #region 发送请求
    public void SendRefineTreasureQuest(uint treasureId, uint materId)
    {
        CA577_tagCMMWRefine cMMWRefine = new CA577_tagCMMWRefine();
        cMMWRefine.MWID = treasureId;
        cMMWRefine.MaterialID = materId;
        GameNetSystem.Instance.SendInfo(cMMWRefine);
        fireId = 0;
    }

    public void SendMakerDrugQuest(ushort drugId, uint specConfigID)
    {
        CA576_tagCMPlayerRefine cMPlayerRefine = new CA576_tagCMPlayerRefine();
        cMPlayerRefine.RefineNum = drugId;
        cMPlayerRefine.UseRateItem = specConfigID;
        GameNetSystem.Instance.SendInfo(cMPlayerRefine);
        fireId = 0;
    }

    #endregion

    public event Action<bool> OnMakeDrugSuccess;
    public void SetMakeDrugSuccessEvent(bool isClick)
    {
        if (OnMakeDrugSuccess != null)
        {
            OnMakeDrugSuccess(isClick);
        }
    }

    #region 红点逻辑处理
    public const int BLASTREDPOINT_KEY = 110;
    public Redpoint blastRedpoint = new Redpoint(MainRedDot.RedPoint_key, BLASTREDPOINT_KEY);
    public const int LINGDANREDPOINT_KEY = 11001;
    public Redpoint lingDanRedpoint = new Redpoint(BLASTREDPOINT_KEY, LINGDANREDPOINT_KEY);
    public const int SPECMATREDPOINT_KEY = 110011000;
    private Redpoint specMatRedpoint = new Redpoint(SPECMATREDPOINT_KEY);
    public const int RECYCLESTORE_KEY = 11003;
    public Redpoint recycleStoreRedpoint = new Redpoint(BLASTREDPOINT_KEY, RECYCLESTORE_KEY);
    public const int RECYCLEBTN_KEY = 110031000;
    private Redpoint recycleBtnRedpoint = new Redpoint(RECYCLESTORE_KEY, RECYCLEBTN_KEY);

    public List<Redpoint> danDrugRedPointlist { get; private set; }
    public void SetDandrugRedPointlist()
    {
        if (alchemyModellist == null) return;

        danDrugRedPointlist = new List<Redpoint>();
        int i = 0;
        for (i = 0; i < alchemyModellist.Count; i++)
        {
            int id = LINGDANREDPOINT_KEY * 1000 + i;
            Redpoint danRedPoint = new Redpoint(LINGDANREDPOINT_KEY, id);
            danDrugRedPointlist.Add(danRedPoint);
        }
    }


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

        CheckMakerDandrugCondition();
        CheckRecycleStoreRed();
    }

    private void RefreshItemUsce(int id)
    {
        if(playerPack.CheckIsDrugById(id))
        {
            CheckMakerDandrugCondition();
            CheckRecycleStoreRed();
            StoveIsUpGrade = false;
            PlayRecycleGuid();
        }
    }

    public void CheckMakerDandrugCondition()
    {
        for (int i = alchemyModellist.Count - 1; i > -1; i--)
        {
            danDrugRedPointlist[i].state = RedPointState.None;
        }

        if (alchemyModellist == null || !FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.BlastFurnace)) return;

        for (int i = alchemyModellist.Count - 1; i > -1; i--)
        {
            if (StoveLV >= alchemyModellist[i].BlastFurnaceLV)
            {
                if (IsSpecMatEnough(alchemyModellist[i]) && IsNormalMatEnough(alchemyModellist[i]))
                {
                    danDrugRedPointlist[i].state = RedPointState.Simple;
                    return;
                }
            }
        }

        for (int i = alchemyModellist.Count - 1; i > -1; i--)
        {
            if (StoveLV >= alchemyModellist[i].BlastFurnaceLV)
            {
                if(!CheckNormalAlchemyIsReachMaxUse(alchemyModellist[i]))
                {
                    if (IsNormalMatEnough(alchemyModellist[i]) && !IsHaveReachFull(alchemyModellist[i]))
                    {
                        danDrugRedPointlist[i].state = RedPointState.Simple;
                        return;
                    }
                }
            }
        }

    }

    public bool IsSpecMatEnough(AlchemyConfig alchemyConfig)
    {
        if (alchemyConfig == null) return false;
        if (alchemyConfig.SpecialItem == null || alchemyConfig.SpecialItem.Length < 1) return false;

        bool isEnough = false;
        for (int i = 0; i < alchemyConfig.SpecialItem.Length; i++)
        {
            AlchemySpecConfig specConfig = Config.Instance.Get<AlchemySpecConfig>(alchemyConfig.SpecialItem[i]);
            int haveCnt = playerPack.GetItemCountByID(PackType.rptItem, specConfig.SpecialMaterialD);
            if (haveCnt >= specConfig.SpecialMateriaNUM)
            {
                isEnough = true;
                break;
            }
        }
        return isEnough;
    }

    public bool IsNormalMatEnough(AlchemyConfig alchemyConfig)
    {
        if (alchemyConfig == null) return false;
        bool isEnough = true;
        Dictionary<int, int> matDict = ConfigParse.GetDic<int, int>(alchemyConfig.MaterialAll);
        foreach (var id in matDict.Keys)
        {
            int haveCnt = playerPack.GetItemCountByID(PackType.rptItem, id);
            if (haveCnt < matDict[id])
            {
                isEnough = false;
                break;
            }
        }
        return isEnough;
    }

    public bool IsHaveReachFull(AlchemyConfig alchemyConfig)
    {
        if (alchemyConfig == null) return false;
        List<int> previewlist = GetPreviewMakeDruglist(alchemyConfig).Keys.ToList();
        for(int i = 0; i < previewlist.Count; i++)
        {
            if(playerPack.CheckIsDrugById(previewlist[i]))
            {
                AttrFruitConfig fruitConfig = Config.Instance.Get<AttrFruitConfig>(previewlist[i]);
                if(playerPack.IsReachMaxUseDrug(fruitConfig))
                {
                    return true;
                }
            }
        }
        return false;
    }

    public bool CheckNormalAlchemyIsReachMaxUse(AlchemyConfig alchemyConfig)
    {
        if (alchemyConfig == null) return false;

        List<int> previewlist = GetPreviewMakeDruglist(alchemyConfig).Keys.ToList();
        for(int i = 0; i < previewlist.Count; i++)
        {
            if(playerPack.CheckIsDrugById(previewlist[i]))
            {
                AttrFruitConfig fruitConfig = Config.Instance.Get<AttrFruitConfig>(previewlist[i]);
                if(!playerPack.IsReachMaxUseDrug(fruitConfig))
                {
                    return false;
                }
            }
        }

        return true;
    }

    public void SpecMatRedPointCtrl(AlchemyConfig alchemyConfig, bool isShow = true)
    {
        if (alchemyConfig == null) return;

        specMatRedpoint.state = RedPointState.None;
        if (isShow)
        {
            if (IsSpecMatEnough(alchemyConfig) && alchemyConfig.BlastFurnaceLV <= StoveLV)
            {
                specMatRedpoint.state = RedPointState.Simple;
            }
        }
    }

    public void CheckRecycleStoreRed()
    {
        if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.BlastFurnace)) return;

        if(IsRecycleDanDrug())
        {
            recycleBtnRedpoint.state = RedPointState.Simple;
        }
        else
        {
            recycleBtnRedpoint.state = RedPointState.None;
        }
    }

    public bool IsRecycleDanDrug()
    {
        List<ItemModel> itemModels = GetRecycleDanlist();
        if(itemModels != null && itemModels.Count > 0)
        {
            return true;
        }
        return false;
    }


    private void StoveUpgradAfterClose(Window win)
    {
        if (win.name != "StoveUpgradWin") return;
        StoveIsUpGrade = false;
        PlayRecycleGuid();
    }


    private void RefreshDanReduce(PackType type, int index, int id)
    {
        if (type != PackType.rptItem || !playerPack.CheckIsDrugById(id)) return;
        StoveIsUpGrade = false;
        PlayRecycleGuid();
    }

    public void PlayRecycleGuid()
    {
        if (IsRecycleDanDrug() 
            && !NewBieCenter.Instance.completeGuidesBuf.Contains(93)
            && !StoveIsUpGrade)
        {
            NewBieCenter.Instance.StartNewBieGuide(93);
        }
    }
    #endregion

    #region 回收丹药逻辑处理
    private bool isOpenPrompting = true;
    /// <summary>
    /// 回收丹药
    /// </summary>
    /// <param name="itemId"></param>
    public void RecycleDrug(int itemId,int exp)
    {
        ItemConfig itemConfig = Config.Instance.Get<ItemConfig>(itemId);
        if (isOpenPrompting)
        {
            int recycleNum = playerPack.GetItemCountByID(PackType.rptItem,itemId);
            ConfirmCancel.IconConfirmCancel(Language.Get("Mail101"), Language.Get("BlastFurnace114",recycleNum ,UIHelper.GetTextColorByItemColor(itemConfig.ItemColor, itemConfig.ItemName),exp*recycleNum), itemConfig.ID,
             playerPack.GetItemCountByID(PackType.rptItem, itemConfig.ID), 0,"", Language.Get("ConfirmCancel102"), (bool isOk, bool isToggle) =>
             {
                 if (isOk)
                 {
                     int noBindNum = 0;
                     List<int> indexs = null;
                     List<int> nums = null;
                     if(CheckIsNoBindDrug(itemId,out noBindNum,out indexs,out nums))
                     {
                         ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"),Language.Get("BlastFurnace115",noBindNum, UIHelper.GetTextColorByItemColor(itemConfig.ItemColor, itemConfig.ItemName)),
                             (bool isRecycle)=>
                             {
                                 if(isRecycle)
                                 {
                                     SendRecycleDrugQuest(indexs,nums);
                                 }
                             });
                     }
                     else
                     {
                         SendRecycleDrugQuest(indexs, nums);
                     }
                 }
                 isOpenPrompting = !isToggle;
             });
        }
        else
        {
            int noBindNum = 0;
            List<int> indexs = null;
            List<int> nums = null;
            if (CheckIsNoBindDrug(itemId, out noBindNum, out indexs, out nums))
            {
                ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), Language.Get("BlastFurnace115", noBindNum, UIHelper.GetTextColorByItemColor(itemConfig.ItemColor, itemConfig.ItemName)),
                    (bool isRecycle) =>
                    {
                        if (isRecycle)
                        {
                            SendRecycleDrugQuest(indexs, nums);
                        }
                    });
            }
            else
            {
                SendRecycleDrugQuest(indexs, nums);
            }
        }

    }

    private bool CheckIsNoBindDrug(int itemId,out int nobindNums,out List<int> indexs,out List<int> nums)
    {
        indexs = new List<int>();
        nums = new List<int>();
        nobindNums = 0;
       SinglePackModel singlePack = playerPack.GetSinglePackModel(PackType.rptItem);
       if (singlePack == null) return false;

        List<ItemModel> items;
        singlePack.GetItemCountByID(itemId,out items);
        for(int i = 0; i < items.Count; i++)
        {
            indexs.Add(items[i].itemInfo.ItemPlace);
            nums.Add(items[i].itemInfo.ItemCount);
            if (items[i].itemInfo.IsBind == 0)
            {
                nobindNums += items[i].itemInfo.ItemCount;
            }
        }
        if(nobindNums > 0)
        {
            return true;
        }

        return false;
    }

    /// <summary>
    /// 获得所有可回收丹药
    /// </summary>
    /// <returns></returns>
    private List<ItemModel> GetRecycleDanlist()
    {
        SinglePackModel singlePack = playerPack.GetSinglePackModel(PackType.rptItem);
        if (singlePack == null) return null;

        List<ItemModel> itemModels = new List<ItemModel>();
        List<AttrFruitConfig> fruitlist = playerPack.makeDruglist;
        Dictionary<int, ItemModel> itemDict = singlePack.GetPackModelIndexDict();
        foreach (var index in itemDict.Keys)
        {
            if (playerPack.CheckIsDrugById(itemDict[index].itemId))
            {
                AttrFruitConfig fruitConfig = Config.Instance.Get<AttrFruitConfig>(itemDict[index].itemId);
                if (playerPack.IsReachMaxUseDrug(fruitConfig))
                {
                    itemModels.Add(itemDict[index]);
                }
            }
        }

        return itemModels;
    }

    Dictionary<string, List<ItemModel>> lookRecycleDict = new Dictionary<string, List<ItemModel>>();
    public Dictionary<string,List<ItemModel>> GetLookRecycleDanlist()
    {
        lookRecycleDict.Clear();
        recycleStrlist.Clear();
        List<ItemModel> itemModels = GetRecycleDanlist();
        if (itemModels == null) return lookRecycleDict;

        itemModels.Sort(CompareByDanBindAndLv);

        for(int i = 0; i < itemModels.Count; i++)
        {
            string key = StringUtility.Contact(itemModels[i].itemId,"IsBind",itemModels[i].itemInfo.IsBind);
            if(!lookRecycleDict.ContainsKey(key))
            {
                List<ItemModel> modellist = new List<ItemModel>();
                modellist.Add(itemModels[i]);
                lookRecycleDict.Add(key,modellist);
                if(itemModels[i].itemInfo.IsBind == 1)
                {
                    AddSelectRecycleDan(itemModels[i]);
                }
            }
            else
            {
                lookRecycleDict[key].Add(itemModels[i]);
            }
        }

        return lookRecycleDict;
    }

    private int CompareByDanBindAndLv(ItemModel start,ItemModel end)
    {
        bool isBindStart = start.itemInfo.IsBind == 1 ? true : false;
        bool isBindEnd = end.itemInfo.IsBind == 1 ? true : false;
        if (isBindStart.CompareTo(isBindEnd) != 0) return -isBindStart.CompareTo(isBindEnd);

        int startLv = start.chinItemModel.LV;
        int endLv = end.chinItemModel.LV;
        if (startLv.CompareTo(endLv) != 0) return startLv.CompareTo(endLv);

        return 0;
    }

    Dictionary<int, int> recycleDanDict = new Dictionary<int, int>();
    public List<string> recycleStrlist = new List<string>();
    public event Action RefreshSelectRecycleAct;
    public void AddSelectRecycleDan(ItemModel itemModel)
    {
        string key = StringUtility.Contact(itemModel.itemId, "IsBind", itemModel.itemInfo.IsBind);
        if(!recycleStrlist.Contains(key))
        {
            recycleStrlist.Add(key);
        }

        if(RefreshSelectRecycleAct != null)
        {
            RefreshSelectRecycleAct();
        }
    }

    public void RemoveSelectRecycleDan(ItemModel itemModel)
    {
        string key = StringUtility.Contact(itemModel.itemId, "IsBind", itemModel.itemInfo.IsBind);
        if (recycleStrlist.Contains(key))
        {
            recycleStrlist.Remove(key);
        }

        if (RefreshSelectRecycleAct != null)
        {
            RefreshSelectRecycleAct();
        }
    }

    public int GetRecycleMoney()
    {
        int money = 0;
        foreach(var key in lookRecycleDict.Keys)
        {
            if(recycleStrlist.Contains(key))
            {
                List<ItemModel> itemModels = lookRecycleDict[key];
                for(int i = 0; i < itemModels.Count; i++)
                {
                    AttrFruitConfig fruitConfig = Config.Instance.Get<AttrFruitConfig>(itemModels[i].itemId);
                    money = money + fruitConfig.RecycleExp * itemModels[i].itemInfo.ItemCount;
                }
            }
        }
        return money;
    }

    public void SetSelectRecycleDan()
    {
        if(recycleStrlist.Count < 1)
        {
            SysNotifyMgr.Instance.ShowTip("AlchemyRecycling");
            return;
        }
        #region 设置回收数据
        int unBindCnt = 0;
        int sumCnt = 0;
        int getMoney = 0;
        recycleDanDict.Clear();
        for (int i = 0; i < recycleStrlist.Count; i++)
        {
            List<ItemModel> modellist = null;
            lookRecycleDict.TryGetValue(recycleStrlist[i],out modellist);
            if(modellist != null)
            {
                for(int j = 0; j < modellist.Count; j++)
                {
                    sumCnt += modellist[j].itemInfo.ItemCount;
                    if(modellist[j].itemInfo.IsBind == 0)
                    {
                        unBindCnt += modellist[j].itemInfo.ItemCount;
                    }

                    if(playerPack.CheckIsDrugById(modellist[j].itemId))
                    {
                        AttrFruitConfig fruitConfig = Config.Instance.Get<AttrFruitConfig>(modellist[j].itemId);
                        getMoney = getMoney + fruitConfig.RecycleExp * modellist[j].itemInfo.ItemCount;
                    }

                    if(!recycleDanDict.ContainsKey(modellist[j].itemInfo.ItemPlace))
                    {
                        recycleDanDict.Add(modellist[j].itemInfo.ItemPlace,modellist[j].itemInfo.ItemCount);
                    }
                    else
                    {
                        recycleDanDict[modellist[j].itemInfo.ItemPlace] += modellist[j].itemInfo.ItemCount;
                    }
                }
            }
        }
        #endregion

        if (isOpenPrompting)
        {
            ConfirmCancel.ToggleConfirmCancel(Language.Get("Mail101"), Language.Get("BlastFurnace114",sumCnt,getMoney,string.Format("<Img chat={0}/>",StringUtility.Contact("Money_Type_",27))),
                Language.Get("ConfirmCancel102"),(bool isOk, bool isToggle) =>
               {
                 if (isOk)
                 {
                       if(unBindCnt > 0)
                       {
                           ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), Language.Get("BlastFurnace115", unBindCnt),
                          (bool isRecycle) =>
                          {
                             if (isRecycle)
                             {
                                 SendRecycleDrugQuest(recycleDanDict.Keys.ToList(), recycleDanDict.Values.ToList());
                             }
                         });
                       }
                       else
                       {
                           SendRecycleDrugQuest(recycleDanDict.Keys.ToList(), recycleDanDict.Values.ToList());
                       }
                 }
                 isOpenPrompting = !isToggle;
             });
        }
        else
        {
            if (unBindCnt > 0)
            {
               ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), Language.Get("BlastFurnace115", unBindCnt),
               (bool isRecycle) =>
               {
                   if (isRecycle)
                   {
                       SendRecycleDrugQuest(recycleDanDict.Keys.ToList(), recycleDanDict.Values.ToList());
                   }
               });
            }
            else
            {
                SendRecycleDrugQuest(recycleDanDict.Keys.ToList(), recycleDanDict.Values.ToList());
            }
        }

    }

    public void SendRecycleDrugQuest(List<int> indexs,List<int> nums)
    {
        CA32A_tagCMRecycleAttrFruit recycleAttrFruit = new CA32A_tagCMRecycleAttrFruit();
        recycleAttrFruit.IndexCount = (byte)indexs.Count;
        byte[] indexByte = new byte[indexs.Count];
        ushort[] numShort = new ushort[indexs.Count];
        for (int i = 0; i < indexs.Count; i++)
        {
            indexByte[i] = (byte)indexs[i];
            numShort[i] = (ushort)nums[i];
        }
        recycleAttrFruit.IndexList = indexByte;
        recycleAttrFruit.RecycleCountList = numShort;
        GameNetSystem.Instance.SendInfo(recycleAttrFruit);
    }
    #endregion
}

public struct TreasureSkillData
{
    public int treasureLv { get; private set; }
    public bool islock { get; private set; }

    public TreasureSkillData(int lv, bool islock)
    {
        this.treasureLv = lv;
        this.islock = islock;
    }
}

public struct PreviewXuanDan
{
    public int code { get; private set; }
    public int id { get; private set; }
    public int count { get; private set; }
    public bool isUpgrade { get; private set; }

    public PreviewXuanDan(int code, int id, int count, bool upgrade = false)
    {
        this.code = code;
        this.id = id;
        this.count = count;
        this.isUpgrade = upgrade;
    }
}

public struct UpgradeDan
{
    public int id { get; private set; }
    public int lv { get; private set; }
    public int code { get; private set; }

    public UpgradeDan(int code, int id, int lv)
    {
        this.id = id;
        this.lv = lv;
        this.code = code;
    }
}

public enum BlastFurnaceFuncTitle
{
    MakeDan,  //炼丹
    AttrDan,  //丹药属性
}