using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
namespace vnxbqy.UI
{
    
    public class AlchemyModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk
    {
        Dictionary<int, AlchemyTime> m_AlchemyTimes = new Dictionary<int, AlchemyTime>();
        Dictionary<int, Dictionary<int, AlchemyCount>> m_AlchemyCounts = new Dictionary<int, Dictionary<int, AlchemyCount>>();
        Dictionary<int, int> m_AlchemyQualityLucks = new Dictionary<int, int>();
        Dictionary<int, List<Item>> m_AlchemyMaterials = new Dictionary<int, List<Item>>();
        Dictionary<int, AlchemyDrugUseLimit> m_AlchemyDrugUseLimits = new Dictionary<int, AlchemyDrugUseLimit>();
        List<int> m_AlchemyDrugs = new List<int>();
        List<int> m_AlchemyDrugQualitys = new List<int>();
        List<int> m_AssociationItems = new List<int>();

        public readonly Redpoint redpoint = new Redpoint(MainRedDot.RedPoint_key, 110);
        public readonly Redpoint alchemyDrugRedpoint1 = new Redpoint(110, 11001);
        public readonly Redpoint alchemyDrugRedpoint2 = new Redpoint(110, 11002);
        public readonly Redpoint alchemyDrugRedpoint3 = new Redpoint(110, 11003);
        public readonly Redpoint alchemyDrugRedpoint4 = new Redpoint(110, 11004);
        Dictionary<int, AlchemyRedpoint> alchemyRedpoints = new Dictionary<int, AlchemyRedpoint>();

        public static int redpointIndex = 110010000;

        int m_SelectAlchemy = 0;
        public int selectAlchemy
        {
            get { return m_SelectAlchemy; }
            set
            {
                if (m_SelectAlchemy != value)
                {
                    m_SelectAlchemy = value;
                    if (selectAlchemyRefresh != null)
                    {
                        selectAlchemyRefresh();
                    }
                }
            }
        }

        public AlchemyType selectAlchemyType { get; set; }

        public int stoveLevel { get; private set; }
        public int stoveExp { get; private set; }
        public string alchemySuccRate { get; private set; }

        public int jumpAlchemy { get; set; }

        public bool alchemyNormalNotifySymbol { get; set; }
        public bool alchemyFairyNotifySymbol { get; set; }

        public int maxBatchAlchemyCount { get; private set; }

        public int normalBatchAlchemyLevel { get; private set; }
        Dictionary<int, int> alchemyRedpointLevelLimits;

        public int autoFunctionGuideLevel { get; private set; }

        public bool isServerPrepare { get; private set; }

        public event Action selectAlchemyRefresh;
        public event Action alchemyStateRefresh;
        public event Action alchemyDrugUseRefresh;

        PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
        ReikiRootModel reikiRootModel { get { return ModelCenter.Instance.GetModel<ReikiRootModel>(); } }

        public override void Init()
        {
            FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;
            PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshEvent;
            packModel.refreshItemCountEvent += RefreshItemCountEvent;
            GlobalTimeEvent.Instance.secondEvent += PerSecond;
            reikiRootModel.onReikiRootPointRefresh += OnReikiRootPointRefresh;

            ParseConfig();
        }

        public void OnBeforePlayerDataInitialize()
        {
            m_AlchemyTimes.Clear();
            stoveLevel = 1;
            stoveExp = 0;
            foreach (var item in m_AlchemyDrugUseLimits.Values)
            {
                item.SetTimes(0, 0, 0);
            }
            isServerPrepare = false;
        }

        public void OnPlayerLoginOk()
        {
            isServerPrepare = true;
            CheckRedpoint();
        }

        public override void UnInit()
        {
            FuncOpen.Instance.OnFuncStateChangeEvent -= OnFuncStateChangeEvent;
            PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshEvent;
            packModel.refreshItemCountEvent -= RefreshItemCountEvent;
            GlobalTimeEvent.Instance.secondEvent -= PerSecond;
            reikiRootModel.onReikiRootPointRefresh -= OnReikiRootPointRefresh;
        }

        private void RefreshItemCountEvent(PackType packType, int arg2, int itemId)
        {
            if (m_AssociationItems.Contains(itemId))
            {
                CheckRedpoint();
            }

            if (AttrFruitConfig.Has(itemId))
            {
                CheckRedpoint();
                RefreshUseDrugRedpoint();
            }
        }

        private void OnReikiRootPointRefresh()
        {
            if (isServerPrepare)
            {
                CheckRedpoint();
            }
        }

        private void PlayerDataRefreshEvent(PlayerDataType dataType)
        {
            if (dataType == PlayerDataType.FreePoint
                || dataType == PlayerDataType.LV)
            {
                CheckRedpoint();
            }
        }

        private void OnFuncStateChangeEvent(int id)
        {
            if (id == (int)FuncOpenEnum.BlastFurnace)
            {
                CheckRedpoint();
                RefreshUseDrugRedpoint();
            }
        }

        void ParseConfig()
        {
            {
                var configs = AlchemyCountConfig.GetValues();
                foreach (var config in configs)
                {
                    var intArray = LitJson.JsonMapper.ToObject<int[][]>(config.CntRateList);
                    var min = intArray[0][1];
                    var max = intArray[intArray.Length - 1][1];
                    if (!m_AlchemyCounts.ContainsKey(config.AlchemyQuality))
                    {
                        m_AlchemyCounts[config.AlchemyQuality] = new Dictionary<int, AlchemyCount>();
                    }
                    m_AlchemyCounts[config.AlchemyQuality].Add(config.LuckValue, new AlchemyCount()
                    {
                        min = min,
                        max = max,
                    });
                }
            }

            {
                var funcConfig = FuncConfigConfig.Get("alchemySuccess");
                alchemySuccRate = funcConfig.Numerical3;

                var json = LitJson.JsonMapper.ToObject(funcConfig.Numerical2);
                foreach (var key in json.Keys)
                {
                    var quality = int.Parse(key);
                    m_AlchemyQualityLucks.Add(quality, int.Parse(json[key].ToString()));
                }

                funcConfig = FuncConfigConfig.Get("AlchemyRedPoint");
                normalBatchAlchemyLevel = int.Parse(funcConfig.Numerical2);
                alchemyRedpointLevelLimits = ConfigParse.GetDic<int, int>(funcConfig.Numerical3);
                autoFunctionGuideLevel = int.Parse(funcConfig.Numerical4);
            }

            {
                var configs = AlchemyConfig.GetValues();
                foreach (var config in configs)
                {
                    m_AlchemyMaterials.Add(config.ID, new List<Item>());
                    var dict = ConfigParse.GetDic<int, int>(config.Material);
                    foreach (var key in dict.Keys)
                    {
                        m_AlchemyMaterials[config.ID].Add(new Item()
                        {
                            id = key,
                            count = dict[key],
                        });

                        if (!m_AssociationItems.Contains(key))
                        {
                            m_AssociationItems.Add(key);
                        }
                    }

                    if (!m_AssociationItems.Contains(config.LearnNeedItemID))
                    {
                        m_AssociationItems.Add(config.LearnNeedItemID);
                    }
                }

            }

            {
                var funcConfig = FuncConfigConfig.Get("AlchemyOverLimit");
                var itemId = int.Parse(funcConfig.Numerical1);
                maxBatchAlchemyCount = int.Parse(funcConfig.Numerical2);

                var configs = AttrFruitConfig.GetValues();
                foreach (var config in configs)
                {
                    if (config.FuncID == 2)
                    {
                        m_AlchemyDrugs.Add(config.ID);
                        var itemConfig = ItemConfig.Get(config.ID);
                        if (!m_AlchemyDrugQualitys.Contains(itemConfig.LV))
                        {
                            m_AlchemyDrugQualitys.Add(itemConfig.LV);
                        }
                        m_AlchemyDrugUseLimits.Add(config.ID, new AlchemyDrugUseLimit(config.ID, itemId));
                    }
                }

                m_AlchemyDrugQualitys.Sort();
            }

            var alchemys = AlchemyConfig.GetAlchemies((int)AlchemyType.Normal);
            foreach (var id in alchemys)
            {
                alchemyRedpoints.Add(id, new AlchemyRedpoint(alchemyDrugRedpoint1.id));
            }

            alchemys = AlchemyConfig.GetAlchemies((int)AlchemyType.Fairy);
            foreach (var id in alchemys)
            {
                alchemyRedpoints.Add(id, new AlchemyRedpoint(alchemyDrugRedpoint2.id));
            }
        }

        public bool TryGetAlchemyStartTime(int alchemyId, out AlchemyTime alchemyTime)
        {
            return m_AlchemyTimes.TryGetValue(alchemyId, out alchemyTime);
        }

        public bool TryGetAlchemyCount(int alchemyId, int luckValue, out AlchemyCount alchemyCount)
        {
            var config = AlchemyConfig.Get(alchemyId);
            alchemyCount = default(AlchemyCount);
            if (config == null)
            {
                return false;
            }
            if (config.AlchemType == (int)AlchemyType.Fairy)
            {
                alchemyCount = AlchemyCount.one;
                return true;
            }
            var dict = m_AlchemyCounts[config.AlchemyQuality];
            foreach (var _luckValue in dict.Keys)
            {
                if (luckValue >= _luckValue)
                {
                    alchemyCount = dict[_luckValue];
                }
            }
            return !alchemyCount.Equals(default(AlchemyCount));
        }

        public bool TryGetAlchemyMaterials(int alchemyId, out List<Item> items)
        {
            return m_AlchemyMaterials.TryGetValue(alchemyId, out items);
        }

        public bool TryGetAlchemyUseLimit(int id,out AlchemyDrugUseLimit drugUseLimit)
        {
            return m_AlchemyDrugUseLimits.TryGetValue(id, out drugUseLimit);
        }

        public bool TryLearn(int alchmeyId, out int error)
        {
            error = 0;
            var config = AlchemyConfig.Get(alchmeyId);
            if (stoveLevel < config.LearnNeedAlchemLV)
            {
                error = 2;
                return false;
            }
            if (reikiRootModel.GetReikiRootTotalPointWithFree() < config.LearnNeedLuck)
            {
                error = 3;
                return false;
            }
            var count = packModel.GetItemCountByID(PackType.Item, config.LearnNeedItemID);
            if (count <= 0)
            {
                error = 1;
                return false;
            }
            return true;
        }

        public bool TryGetAlchemyByStudyMaterial(int id, out int alchemyId)
        {
            alchemyId = 0;
            var configs = AlchemyConfig.GetValues();
            foreach (var config in configs)
            {
                if (config.LearnNeedItemID == id)
                {
                    alchemyId = config.ID;
                    return true;
                }
            }
            return false;
        }

        public int GetAlchemyRedpointId(int id)
        {
            return alchemyRedpoints.ContainsKey(id) ? alchemyRedpoints[id].redpoint.id : 0;
        }

        public float GetAlchemySuccRate(int alchemyId)
        {
            var config = AlchemyConfig.Get(alchemyId);
            if (config == null)
            {
                return 0f;
            }
            if (config.AlchemType == (int)AlchemyType.Fairy)
            {
                return 10000f;
            }
            var itemConfig = ItemConfig.Get(config.AlchemItemID);
            var luckValue = PlayerDatas.Instance.extersion.luckValue;
            return GetAlchemySuccRate(stoveLevel, itemConfig.LV, luckValue);
        }

        public float GetAlchemySuccRate(int stoveLevel, int itemLevel, int luck)
        {
            Equation.Instance.Clear();
            Equation.Instance.AddKeyValue("alchemyLV", stoveLevel);
            Equation.Instance.AddKeyValue("alchemyQuality", itemLevel);
            Equation.Instance.AddKeyValue("curLuckValue", luck);
            var qualityNeedLuck = m_AlchemyQualityLucks.ContainsKey(itemLevel) ? m_AlchemyQualityLucks[itemLevel] : 0;
            Equation.Instance.AddKeyValue("qualityNeedLuck", qualityNeedLuck);
            return Equation.Instance.Eval<float>(alchemySuccRate);
        }

        public int GetStoveState(int alchemyId)
        {
            AlchemyTime alchemyTime;
            if (TryGetAlchemyStartTime(alchemyId, out alchemyTime)
                && alchemyTime.startTick > 0)
            {
                var config = AlchemyConfig.Get(alchemyId);
                var startTime = TimeUtility.GetTime(alchemyTime.startTick);
                var seconds = config.NeedTime * alchemyTime.count
                    - (float)(TimeUtility.ServerNow - startTime).TotalSeconds;
                return seconds > 0 ? 1 : 2;
            }
            return 0;
        }

        public ICollection<int> GetDrugQualitys()
        {
            return m_AlchemyDrugQualitys;
        }

        public ICollection<int> GetAlchemyDrugs()
        {
            return m_AlchemyDrugs;
        }

        public int GetAlchemyDrugState(int id)//0-可服用丹药 1-达到上限 2-没有丹药 3-没有提升空间
        {
            AlchemyDrugUseLimit drugUseLimit;
            if (TryGetAlchemyUseLimit(id, out drugUseLimit))
            {
                if (!drugUseLimit.IsReachLimit())
                {
                    var count = packModel.GetItemCountByID(PackType.Item, id);
                    return count > 0 ? 0 : 2;
                }
                else
                {
                    return drugUseLimit.CanUpgradeLimit() ? 1 : 3;
                }
            }
            return int.MaxValue;
        }

        public int GetAlchemyDrugUseLimit(int id)
        {
            AlchemyDrugUseLimit drugUseLimit;
            if (TryGetAlchemyUseLimit(id, out drugUseLimit))
            {
                return drugUseLimit.GetUseLimit();
            }
            return 0;
        }

        public int GetCanAlchemyCount(int alchemyId)
        {
            Item item;
            var count = 0;
            if (IsAlchemyEnoughMaterial(alchemyId, out item))
            {
                List<Item> materials;
                if (TryGetAlchemyMaterials(alchemyId, out materials))
                {
                    for (int i = 0; i < materials.Count; i++)
                    {
                        var mat = materials[i];
                        var itemCount = packModel.GetItemCountByID(PackType.Item, mat.id);
                        var _count = itemCount / mat.count;
                        if (count == 0)
                        {
                            count = _count;
                        }
                        else
                        {
                            count = Mathf.Min(count, _count);
                        }
                    }
                }
            }
            return count;
        }

        public bool IsGraspRecipe(int alchemyId)
        {
            return m_AlchemyTimes.ContainsKey(alchemyId);
        }

        public bool IsAlchemyEnoughMaterial(int alchemyId, out Item item)
        {
            List<Item> materials;
            item = default(Item);
            if (TryGetAlchemyMaterials(alchemyId, out materials))
            {
                for (int i = 0; i < materials.Count; i++)
                {
                    var mat = materials[i];
                    var count = packModel.GetItemCountByID(PackType.Item, mat.id);
                    if (count < mat.count)
                    {
                        item = mat;
                        return false;
                    }
                }
            }
            return true;
        }

        public bool IsStoveAlcheming(AlchemyType alchemyType, out int _alchemyId)
        {
            _alchemyId = 0;
            var alchemys = AlchemyConfig.GetAlchemies((int)alchemyType);
            foreach (var alchemyId in alchemys)
            {
                var state = GetStoveState(alchemyId);
                if (state != 0)
                {
                    _alchemyId = alchemyId;
                    return true;
                }
            }
            return false;
        }

        public void ReceivePackage(HA3BF_tagMCPlayerStoveMsg package)
        {
            for (int i = 0; i < package.StoveCnt; i++)
            {
                var data = package.InfoList[i];
                m_AlchemyTimes[(int)data.AlchemyID] = new AlchemyTime()
                {
                    startTick = data.StartTime,
                    count = data.AlchemyTimes,
                };

                if (isServerPrepare)
                {
                    var config = AlchemyConfig.Get((int)data.AlchemyID);
                    if (config != null)
                    {
                        if ((AlchemyType)config.AlchemType == AlchemyType.Normal)
                        {
                            alchemyNormalNotifySymbol = false;
                        }
                        if ((AlchemyType)config.AlchemType == AlchemyType.Fairy)
                        {
                            alchemyFairyNotifySymbol = false;
                        }
                    }
                }
            }

            if (package.StoveCnt == 0)
            {
                alchemyNormalNotifySymbol = false;
                alchemyFairyNotifySymbol = false;
            }

            var lastLevel = stoveLevel;
            var stoveConfig = RefineStoveConfig.Get(stoveLevel);
            var lastProgress = 0f;
            if (stoveConfig != null)
            {
                lastProgress = Mathf.Clamp01((float)stoveExp / stoveConfig.Exp);
            }

            stoveLevel = package.StoveLV;
            stoveExp = (int)package.StoveExp;

            if (package.ItemID != 0)
            {
                if (isServerPrepare)
                {
                    if (!NewBieCenter.Instance.inGuiding && WindowCenter.Instance.IsOpen<AlchemyBaseWin>())
                    {
                        AlchemyResultWin.displayItem = new Item()
                        {
                            id = (int)package.ItemID,
                            count = package.ItemCnt,
                        };
                        AlchemyResultWin.lastLevel = lastLevel;
                        AlchemyResultWin.lastProgress = lastProgress;
                        WindowCenter.Instance.Open<AlchemyResultWin>();
                    }
                }
            }

            CheckRedpoint();

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

        public void ReceivePackage(HA339_tagMCAttrFruitEatCntList vNetData)
        {
            for (int i = 0; i < vNetData.count; i++)
            {
                var data = vNetData.EatCntList[i];
                AlchemyDrugUseLimit drugUseLimit;
                if (TryGetAlchemyUseLimit((int)data.ItemID, out drugUseLimit))
                {
                    drugUseLimit.SetTimes((int)data.EatCnt, (int)data.ItemAddCnt, (int)data.ItemBreakCnt);
                }
            }

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

            CheckRedpoint();
            RefreshUseDrugRedpoint();
        }

        private void PerSecond()
        {
            if (isServerPrepare)
            {
                if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.BlastFurnace))
                {
                    return;
                }

                var requireCheckRedpoint = false;

                int alchemyId = 0;
                if (IsStoveAlcheming(AlchemyType.Normal, out alchemyId)
                    && GetStoveState(alchemyId) == 2
                    && alchemyRedpoints.ContainsKey(alchemyId)
                    && alchemyRedpoints[alchemyId].endRedpoint.state != RedPointState.Simple)
                {
                    requireCheckRedpoint = true;
                }

                if (IsStoveAlcheming(AlchemyType.Fairy, out alchemyId)
                    && GetStoveState(alchemyId) == 2
                    && alchemyRedpoints.ContainsKey(alchemyId)
                    && alchemyRedpoints[alchemyId].endRedpoint.state != RedPointState.Simple)
                {
                    requireCheckRedpoint = true;
                }

                if (requireCheckRedpoint)
                {
                    CheckRedpoint();
                }
            }
        }

        static List<int> s_Endables = new List<int>();
        static List<int> s_Studyables = new List<int>();
        static List<int> s_Alchemyables = new List<int>();

        void CheckRedpoint()
        {
            s_Endables.Clear();
            s_Studyables.Clear();
            s_Alchemyables.Clear();

            if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.BlastFurnace))
            {
                RefreshRedpoint();
                return;
            }

            CheckRedpoint(AlchemyType.Normal);
            CheckRedpoint(AlchemyType.Fairy);

            RefreshRedpoint();
        }

        void CheckRedpoint(AlchemyType alchemyType)
        {
            int alchemyId = 0;
            if (IsStoveAlcheming(alchemyType, out alchemyId))
            {
                var state = GetStoveState(alchemyId);
                if (state == 2)
                {
                    s_Endables.Add(alchemyId);
                }
            }
            else
            {
                var hasStudyRed = false;

                var alchemys = AlchemyConfig.GetAlchemies((int)alchemyType);
                foreach (var id in alchemys)
                {
                    if (!IsGraspRecipe(id))
                    {
                        var config = AlchemyConfig.Get(id);
                        var count = packModel.GetItemCountByID(PackType.Item, config.LearnNeedItemID);
                        if (count <= 0 || stoveLevel < config.LearnNeedAlchemLV
                            || reikiRootModel.GetReikiRootTotalPointWithFree() < config.LearnNeedLuck)
                        {
                            continue;
                        }
                        s_Studyables.Add(id);
                        hasStudyRed = true;
                    }
                }

                if (hasStudyRed)
                {
                    return;
                }

                alchemys = AlchemyConfig.GetAlchemies((int)alchemyType);
                foreach (var id in alchemys)
                {
                    if (!IsGraspRecipe(id))
                    {
                        continue;
                    }

                    var config = AlchemyConfig.Get(id);
                    AlchemyDrugUseLimit drugUseLimit;
                    if (TryGetAlchemyUseLimit(config.AlchemItemID, out drugUseLimit))
                    {
                        if (drugUseLimit.IsReachLimit())
                        {
                            continue;
                        }

                        var itemCount = packModel.GetItemCountByID(PackType.Item, config.AlchemItemID);
                        if (drugUseLimit.GetUseLimit() - drugUseLimit.eatTimes - itemCount <= 0)
                        {
                            //背包中有足够的灵根丹
                            continue;
                        }
                        
                    }
                    else
                    {
                        var drugConfig = AttrFruitConfig.Get(config.AlchemItemID);
                        if (drugConfig != null)
                        {
                            if (packModel.GetItemTotalUsedTimes(config.AlchemItemID)
                               >= drugConfig.basicUseLimit)
                            {
                                continue;
                            }
                        }
                    }

                    Item item;
                    if (IsAlchemyEnoughMaterial(id, out item))
                    {
                        if (alchemyRedpointLevelLimits != null
                            && alchemyRedpointLevelLimits.ContainsKey(id))
                        {
                            if (PlayerDatas.Instance.baseData.LV >= alchemyRedpointLevelLimits[id])
                            {
                                continue;
                            }
                        }

                        s_Alchemyables.Add(id);
                    }
                }
            }
        }

        void RefreshRedpoint()
        {
            var alchemys = AlchemyConfig.GetAlchemies((int)AlchemyType.Normal);
            foreach (var id in alchemys)
            {
                var redpoint = alchemyRedpoints[id];
                redpoint.studyRedpoint.state = s_Studyables.Contains(id) ? RedPointState.Simple : RedPointState.None;
                redpoint.endRedpoint.state = s_Endables.Contains(id) ? RedPointState.Simple : RedPointState.None;
                redpoint.alchemyRedpoint.state = s_Alchemyables.Contains(id) ? RedPointState.Simple : RedPointState.None;
            }

            alchemys = AlchemyConfig.GetAlchemies((int)AlchemyType.Fairy);
            foreach (var id in alchemys)
            {
                var redpoint = alchemyRedpoints[id];
                redpoint.studyRedpoint.state = s_Studyables.Contains(id) ? RedPointState.Simple : RedPointState.None;
                redpoint.endRedpoint.state = s_Endables.Contains(id) ? RedPointState.Simple : RedPointState.None;
                redpoint.alchemyRedpoint.state = s_Alchemyables.Contains(id) ? RedPointState.Simple : RedPointState.None;
            }
        }

        void RefreshUseDrugRedpoint()
        {
            var normalUseable = false;
            var fairyUseable = false;
            if (FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.BlastFurnace))
            {
                foreach (var itemId in m_AlchemyDrugs)
                {
                    if (GetAlchemyDrugState(itemId) == 0)
                    {
                        var config = AttrFruitConfig.Get(itemId);
                        if (config.drugType == (int)AlchemyType.Normal)
                        {
                            normalUseable = true;
                        }
                        if (config.drugType == (int)AlchemyType.Fairy)
                        {
                            fairyUseable = true;
                        }

                        if (normalUseable && fairyUseable)
                        {
                            break;
                        }
                    }
                }
            }
            alchemyDrugRedpoint3.state = normalUseable ? RedPointState.Simple : RedPointState.None;
            alchemyDrugRedpoint4.state = fairyUseable ? RedPointState.Simple : RedPointState.None;
        }
    }

    public enum AlchemyType
    {
        Normal = 1,
        Fairy = 2,
    }

    public struct AlchemyCount
    {
        public int min;
        public int max;

        public static readonly AlchemyCount one = new AlchemyCount()
        {
            min = 1,
            max = 1,
        };
    }

    public class AlchemyDrugUseLimit
    {
        public readonly int id;

        Dictionary<int, int> realmLimits = new Dictionary<int, int>();
        Dictionary<int, OverLimitItem> overLimitItems = new Dictionary<int, OverLimitItem>();

        public int addTimes { get; private set; }

        public int eatTimes { get; private set; }

        public int overLimitTimes { get; private set; }

        public int overLimitMaxTimes { get; private set; }

        PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
        RealmModel realmModel { get { return ModelCenter.Instance.GetModel<RealmModel>(); } }

        public AlchemyDrugUseLimit(int id, int itemId)
        {
            this.id = id;
            var config = AttrFruitConfig.Get(id);
            foreach (var realmLimit in config.MaxUseCnt)
            {
                realmLimits.Add(realmLimit.x, realmLimit.y);
            }
            if (!string.IsNullOrEmpty(config.AddItemMaxCnt))
            {
                var array = LitJson.JsonMapper.ToObject<int[][]>(config.AddItemMaxCnt);
                if (array != null)
                {
                    for (int i = 0; i < array.Length; i++)
                    {
                        var infoArray = array[i];
                        overLimitItems.Add(infoArray[0], new OverLimitItem()
                        {
                            itemId = itemId,
                            count = infoArray[1],
                            times = infoArray[2],
                        });
                    }
                }

                overLimitMaxTimes = overLimitItems.Keys.Last();
            }
        }

        public void SetTimes(int eatTimes, int addTimes, int overLimitTimes)
        {
            this.eatTimes = eatTimes;
            this.addTimes = addTimes;
            this.overLimitTimes = overLimitTimes;
        }

        public int GetUseLimit()
        {
            var times = 0;
            var realmLevel = PlayerDatas.Instance.baseData.realmLevel;
            foreach (var level in realmLimits.Keys)
            {
                if (realmLevel >= level)
                {
                    times = realmLimits[level];
                }
            }
            times += addTimes;
            return times;
        }

        public int GetRealmLimit(int realmLevel)
        {
            var limit = 0;
            foreach (var level in realmLimits.Keys)
            {
                if (realmLevel >= level)
                {
                    limit = realmLimits[level];
                }
            }
            return limit;
        }

        public bool IsReachLimit()
        {
            var limit = GetUseLimit();
            return eatTimes >= limit;
        }

        public bool CanUpgradeLimit()
        {
            OverLimitItem item;
            if (CanUpgradeByItem(out item))
            {
                return true;
            }
            if (GetNextUpgradeRealm() > 0)
            {
                return true;
            }
            return false;
        }

        public bool CanUpgradeByItem(out OverLimitItem item)
        {
            item = default(OverLimitItem);
            if (overLimitTimes + 1 > overLimitMaxTimes)
            {
                return false;
            }
            if (overLimitItems.Count > 0)
            {
                foreach (var times in overLimitItems.Keys)
                {
                    if (overLimitTimes + 1 >= times)
                    {
                        item = overLimitItems[times];
                    }
                }
                return !item.Equals(default(OverLimitItem));
            }
            return false;
        }

        public int GetNextUpgradeRealm()
        {
            var realmLevel = PlayerDatas.Instance.baseData.realmLevel;
            foreach (var level in realmLimits.Keys)
            {
                if (realmLevel < level && level <= realmModel.realmMaxLevel)
                {
                    return level;
                }
            }
            return 0;
        }

        public struct OverLimitItem
        {
            public int itemId;
            public int count;
            public int times;
        }
    }

    public struct AlchemyTime
    {
        public uint startTick;
        public int count;
    }

    public class AlchemyRedpoint
    {
        public readonly Redpoint redpoint;
        public readonly Redpoint studyRedpoint;
        public readonly Redpoint endRedpoint;
        public readonly Redpoint alchemyRedpoint;

        public AlchemyRedpoint(int baseId)
        {
            redpoint = new Redpoint(baseId, AlchemyModel.redpointIndex++);
            studyRedpoint = new Redpoint(redpoint.id, AlchemyModel.redpointIndex++);
            endRedpoint = new Redpoint(redpoint.id, AlchemyModel.redpointIndex++);
            alchemyRedpoint = new Redpoint(redpoint.id, AlchemyModel.redpointIndex++);
        }
    }
}