using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace Snxxz.UI
{
    public class AlchemyModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk
    {
        Dictionary<int, uint> m_AlchemyTimes = new Dictionary<int, uint>();
        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);
        Dictionary<int, Dictionary<int, Redpoint>> alchemyQualityRedpoints = new Dictionary<int, Dictionary<int, Redpoint>>();
        Dictionary<int, AlchemyRedpoint> alchemyRedpoints = new Dictionary<int, AlchemyRedpoint>();

        public static int redpointIndex = 110010000;

        int m_SelectQuality = 0;
        public int selectQuality
        {
            get { return m_SelectQuality; }
            set
            {
                if (m_SelectQuality != value)
                {
                    m_SelectQuality = value;
                    if (selectQualityRefresh != null)
                    {
                        selectQualityRefresh();
                    }
                }
            }
        }

        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 isServerPrepare { get; private set; }

        Clock m_AlchemingClock = null;

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

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

        public override void Init()
        {
            FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;
            PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshEvent;
            packModel.refreshItemCountEvent += RefreshItemCountEvent;

            ParseConfig();
        }

        public void OnBeforePlayerDataInitialize()
        {
            m_AlchemyTimes.Clear();
            stoveLevel = 0;
            stoveExp = 0;
            foreach (var item in m_AlchemyDrugUseLimits.Values)
            {
                item.SetTimes(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;
        }

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

            if (m_AlchemyDrugs.Contains(itemId))
            {
                RefreshUseDrugRedpoint();
            }
        }

        private void PlayerDataRefreshEvent(PlayerDataType dataType)
        {
            if (dataType == PlayerDataType.LuckValue)
            {
                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()));
                }
            }

            {
                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 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));
                    }
                }

                m_AlchemyDrugQualitys.Sort();
            }

            var qualitys = AlchemyConfig.GetAlchemyQualities((int)AlchemyType.Normal);
            alchemyQualityRedpoints.Add((int)AlchemyType.Normal, new Dictionary<int, Redpoint>());
            foreach (var quality in qualitys)
            {
                var qualityRedpoint = new Redpoint(alchemyDrugRedpoint1.id, redpointIndex++); ;
                alchemyQualityRedpoints[(int)AlchemyType.Normal].Add(quality, qualityRedpoint);
                var alchemys = AlchemyConfig.GetAlchemies((int)AlchemyType.Normal, quality);
                foreach (var id in alchemys)
                {
                    alchemyRedpoints.Add(id, new AlchemyRedpoint(qualityRedpoint.id));
                }
            }

            qualitys = AlchemyConfig.GetAlchemyQualities((int)AlchemyType.Fairy);
            alchemyQualityRedpoints.Add((int)AlchemyType.Fairy, new Dictionary<int, Redpoint>());
            foreach (var quality in qualitys)
            {
                var qualityRedpoint = new Redpoint(alchemyDrugRedpoint2.id, redpointIndex++); ;
                alchemyQualityRedpoints[(int)AlchemyType.Fairy].Add(quality, qualityRedpoint);
                var alchemys = AlchemyConfig.GetAlchemies((int)AlchemyType.Fairy, quality);
                foreach (var id in alchemys)
                {
                    alchemyRedpoints.Add(id, new AlchemyRedpoint(qualityRedpoint.id));
                }
            }
        }

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

        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 int GetAlchemyRedpointId(int id)
        {
            return alchemyRedpoints.ContainsKey(id) ? alchemyRedpoints[id].redpoint.id : 0;
        }

        public int GetQualityRedpointId(int alchemyType, int quality)
        {
            if (alchemyQualityRedpoints.ContainsKey(alchemyType))
            {
                if (alchemyQualityRedpoints[alchemyType].ContainsKey(quality))
                {
                    return alchemyQualityRedpoints[alchemyType][quality].id;
                }
            }
            return 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)
        {
            uint tick = 0;
            if (TryGetAlchemyStartTime(alchemyId, out tick)
                && tick > 0)
            {
                var config = AlchemyConfig.Get(alchemyId);
                var startTime = TimeUtility.GetTime(tick);
                var seconds = (int)(config.NeedTime - (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 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 Int2 alchemyPosition)
        {
            alchemyPosition = default(Int2);
            var qualities = AlchemyConfig.GetAlchemyQualities((int)alchemyType);
            foreach (var quality in qualities)
            {
                var alchemys = AlchemyConfig.GetAlchemies((int)alchemyType, quality);
                foreach (var alchemyId in alchemys)
                {
                    var state = GetStoveState(alchemyId);
                    if (state != 0)
                    {
                        alchemyPosition.x = quality;
                        alchemyPosition.y = alchemyId;
                        return true;
                    }
                }
            }
            return false;
        }

        public void ReceivePackage(HA3BF_tagMCPlayerStoveMsg package)
        {
            var seconds = 0;

            for (int i = 0; i < package.StoveCnt; i++)
            {
                var data = package.InfoList[i];
                m_AlchemyTimes[(int)data.AlchemyID] = data.StartTime;

                if (data.StartTime > 0)
                {
                    var config = AlchemyConfig.Get((int)data.AlchemyID);
                    var time = TimeUtility.GetTime(data.StartTime);
                    var _seconds = (int)(TimeUtility.ServerNow - time).TotalSeconds;
                    if (_seconds < config.NeedTime && config.NeedTime - _seconds > seconds)
                    {
                        seconds = config.NeedTime - _seconds;
                    }
                }
            }

            if (m_AlchemingClock != null)
            {
                Clock.Stop(m_AlchemingClock);
                m_AlchemingClock = null;
            }
            if (seconds > 0)
            {
                m_AlchemingClock = Clock.AlarmAfter(seconds, CheckRedpoint);
            }

            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,
                        };
                        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(data.EatCnt, (int)data.AddItemCnt);
                }
            }

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

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

        static Dictionary<AlchemyType, List<int>> s_SortQualitys = new Dictionary<AlchemyType, List<int>>();

        public List<int> GetSortQualitys(AlchemyType alchemyType)
        {
            if (!s_SortQualitys.ContainsKey(alchemyType))
            {
                s_SortQualitys.Add(alchemyType, new List<int>(AlchemyConfig.GetAlchemyQualities((int)alchemyType)));
                s_SortQualitys[alchemyType].Sort(QualityCompare);
            }
            return s_SortQualitys[alchemyType];
        }

        private int QualityCompare(int x, int y)
        {
            return -x.CompareTo(y);
        }

        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)
        {
            Int2 position;
            if (IsStoveAlcheming(alchemyType, out position))
            {
                var state = GetStoveState(position.y);
                if (state == 2)
                {
                    s_Endables.Add(position.y);
                }
            }
            else
            {
                var qualitys = AlchemyConfig.GetAlchemyQualities((int)alchemyType);
                foreach (var quality in qualitys)
                {
                    var alchemys = AlchemyConfig.GetAlchemies((int)alchemyType, quality);
                    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
                                || PlayerDatas.Instance.extersion.luckValue < config.LearnNeedLuck)
                            {
                                continue;
                            }
                            s_Studyables.Add(id);
                        }
                    }
                }

                qualitys = GetSortQualitys(alchemyType);
                foreach (var quality in qualitys)
                {
                    var alchemyable = false;
                    var alchemys = AlchemyConfig.GetAlchemies((int)alchemyType, quality);
                    foreach (var id in alchemys)
                    {
                        if (!IsGraspRecipe(id))
                        {
                            continue;
                        }
                        Item item;
                        if (IsAlchemyEnoughMaterial(id, out item))
                        {
                            s_Alchemyables.Add(id);
                            alchemyable = true;
                        }
                    }

                    if (alchemyable)
                    {
                        break;
                    }
                }
            }
        }

        void RefreshRedpoint()
        {
            var qualitys = AlchemyConfig.GetAlchemyQualities((int)AlchemyType.Normal);
            foreach (var quality in qualitys)
            {
                var alchemys = AlchemyConfig.GetAlchemies((int)AlchemyType.Normal, quality);
                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;
                }
            }

            qualitys = AlchemyConfig.GetAlchemyQualities((int)AlchemyType.Fairy);
            foreach (var quality in qualitys)
            {
                var alchemys = AlchemyConfig.GetAlchemies((int)AlchemyType.Fairy, quality);
                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 useable = false;
            if (FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.BlastFurnace))
            {
                foreach (var itemId in m_AlchemyDrugs)
                {
                    if (GetAlchemyDrugState(itemId) == 0)
                    {
                        useable = true;
                        break;
                    }
                }
            }
            alchemyDrugREdpoint3.state = useable ? 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;
        public readonly Item addItem;
        public readonly int addLimitPerTimes;
        Dictionary<int, int> realmLimits = new Dictionary<int, int>();

        public int addTimes { get; private set; }

        public int eatTimes { get; private set; }

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

        public AlchemyDrugUseLimit(int id)
        {
            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);
                addItem = new Item()
                {
                    id = array[0],
                    count = array[1],
                };
                addLimitPerTimes = array[2];
            }
        }

        public void SetTimes(int eatTimes, int addTimes)
        {
            this.eatTimes = eatTimes;
            this.addTimes = addTimes / (addItem.count <= 0 ? 1 : addItem.count);
        }

        public int GetUseLimit()
        {
            var times = 0;
            var realmLevel = PlayerDatas.Instance.baseData.realmLevel;
            foreach (var level in realmLimits.Keys)
            {
                if (realmLevel >= level)
                {
                    times = realmLimits[level];
                }
            }
            if (addItem.id != 0)
            {
                times += addTimes * addLimitPerTimes;
            }
            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()
        {
            if (addItem.id != 0)
            {
                return true;
            }
            if (GetNextUpgradeRealm() > 0)
            {
                return true;
            }
            return false;
        }

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

    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++);
        }
    }
}