using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace Snxxz.UI
{
    public class ReikiRootModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk
    {
        Dictionary<int, int> m_ReikiRootPoints = new Dictionary<int, int>();
        Dictionary<int, int> m_ReikiRootFreePoints = new Dictionary<int, int>();
        Dictionary<int, List<int>> m_RecommendReikiRoots = new Dictionary<int, List<int>>();
        Dictionary<int, Dictionary<int, float>> m_RecommendProportion = new Dictionary<int, Dictionary<int, float>>();
        Dictionary<int, int> m_MainReikiRoots = new Dictionary<int, int>();
        Dictionary<int, int> m_ReikiQualityMapColors;
        Dictionary<int, int> m_CacheReikiRootPoints = new Dictionary<int, int>();
        Dictionary<int, Dictionary<int, int[]>> m_PromotePropertyValues = new Dictionary<int, Dictionary<int, int[]>>();

        public List<int> reikiRoots = new List<int>();

        public int freePoint
        {
            get
            {
                return (int)PlayerDatas.Instance.baseData.FreePoint;
            }
        }

        int m_CacheFreePoint = 0;
        public int cacheFreePoint
        {
            get { return m_CacheFreePoint; }
            set
            {
                if (m_CacheFreePoint != value)
                {
                    m_CacheFreePoint = value;
                    if (onCacheFreePointRefresh != null)
                    {
                        onCacheFreePointRefresh();
                    }
                }
            }
        }

        public int mainReikiRoot
        {
            get
            {
                var job = PlayerDatas.Instance.baseData.Job;
                return m_MainReikiRoots[job];
            }
        }

        public int maxQuality { get; private set; }

        public readonly Redpoint redpoint = new Redpoint(101, 10103);

        public event Action onCacheFreePointRefresh;
        public event Action onReikiRootPointRefresh;

        public override void Init()
        {
            ParseConfig();

            PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshEvent;
        }

        public void OnBeforePlayerDataInitialize()
        {
            m_ReikiRootPoints.Clear();
            m_ReikiRootFreePoints.Clear();
        }

        public void OnPlayerLoginOk()
        {
            RefreshReikiRootPoint();
        }

        public override void UnInit()
        {
            PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshEvent;
        }

        void ParseConfig()
        {
            var funcConfig = FuncConfigConfig.Get("RecommendPoint");
            var json = LitJson.JsonMapper.ToObject(funcConfig.Numerical1);
            foreach (var jobKey in json.Keys)
            {
                var job = int.Parse(jobKey);
                var _mainReikiRoot = 0;
                var _proportion = 0f;
                m_RecommendProportion.Add(job, new Dictionary<int, float>());
                foreach (var idKey in json[jobKey].Keys)
                {
                    var id = int.Parse(idKey);
                    var proportion = int.Parse(json[jobKey][idKey].ToString()) / 100f;
                    if (proportion > _proportion)
                    {
                        _mainReikiRoot = id;
                        _proportion = proportion;
                    }
                    m_RecommendProportion[job].Add(id, proportion);
                }
                m_MainReikiRoots.Add(job, _mainReikiRoot);
                m_RecommendReikiRoots.Add(job, new List<int>(m_RecommendProportion[job].Keys));
            }

            var config = ReikiRootConfig.GetValues()[0];
            maxQuality = config.qualityArea.Length;

            funcConfig = FuncConfigConfig.Get("RecommendPoint");
            m_ReikiQualityMapColors = ConfigParse.GetDic<int, int>(funcConfig.Numerical2);

            reikiRoots.Add((int)PropertyType.Mater);
            reikiRoots.Add((int)PropertyType.Wood);
            reikiRoots.Add((int)PropertyType.Water);
            reikiRoots.Add((int)PropertyType.Fire);
            reikiRoots.Add((int)PropertyType.Earth);

            var configs = ReikiRootConfig.GetValues();
            foreach (var _config in configs)
            {
                m_PromotePropertyValues.Add(_config.id, new Dictionary<int, int[]>());
                var _json = LitJson.JsonMapper.ToObject(_config.promoteValue);
                foreach (var _jobKey in _json.Keys)
                {
                    var job = int.Parse(_jobKey);
                    m_PromotePropertyValues[_config.id].Add(job,
                        LitJson.JsonMapper.ToObject<int[]>(_json[_jobKey].ToJson()));
                }
            }
        }

        public int GetReikiRootQuality(int id, int point)
        {
            var config = ReikiRootConfig.Get(id);
            if (config == null)
            {
                return 0;
            }
            var quality = 0;
            for (int i = 0; i < config.qualityArea.Length; i++)
            {
                if (point >= config.qualityArea[i])
                {
                    quality = i + 1;
                }
                else
                {
                    break;
                }
            }
            return quality;
        }

        public int GetReikiRootQuality(int id)
        {
            return GetReikiRootQuality(id, GetReikiRootPoint(id));
        }

        public int GetReikiRootPoint(int id)
        {
            return m_ReikiRootPoints.ContainsKey(id) ? m_ReikiRootPoints[id] : 0;
        }

        public int GetReikiRootFreePoint(int id)
        {
            return m_ReikiRootFreePoints.ContainsKey(id) ? m_ReikiRootFreePoints[id] : 0;
        }

        int GetReikiRootCachePoint(int id)
        {
            return m_CacheReikiRootPoints.ContainsKey(id) ? m_CacheReikiRootPoints[id] : 0;
        }

        public List<ReikiRootRecommend> GetReikiRootRecommendPoint(int point)
        {
            if (point == 0)
            {
                return null;
            }

            //m_CacheReikiRootPoints.Clear();
            //foreach (var id in m_ReikiRootPoints.Keys)
            //{
            //    m_CacheReikiRootPoints[id] = m_ReikiRootPoints[id];
            //}

            var recommends = new List<ReikiRootRecommend>();
            var job = PlayerDatas.Instance.baseData.Job;

            if (m_RecommendProportion.ContainsKey(job))
            {
                var proportions = m_RecommendProportion[job];
                var index = 0;
                var surplusPoint = point;
                foreach (var id in proportions.Keys)
                {
                    var recommendPoint = Mathf.Min(surplusPoint, (int)(point * proportions[id]));
                    if (index == proportions.Keys.Count - 1)
                    {
                        recommendPoint = surplusPoint;
                    }
                    recommends.Add(new ReikiRootRecommend()
                    {
                        id = id,
                        value = recommendPoint,
                    });
                    surplusPoint -= recommendPoint;
                    index++;
                }
            }

            //var remainPoint = point;
            //var currentMaxQuality = 1;

            //foreach (var id in reikiRoots)
            //{
            //    var quality = GetReikiRootQuality(id);
            //    if (quality >= currentMaxQuality)
            //    {
            //        currentMaxQuality = quality;
            //    }
            //}
            //
            //if (m_RecommendReikiRoots.ContainsKey(job))
            //{
            //    var reikiRoots = m_RecommendReikiRoots[job];
            //    while (remainPoint > 0)
            //    {
            //        reikiRoots.Sort(QualityCompare);
            //        var id = reikiRoots[0];
            //        var quality = GetReikiRootQuality(id, m_CacheReikiRootPoints[id]);
            //        var addpoint = 0;
            //        if (quality >= maxQuality)
            //        {
            //            var proportions = m_RecommendProportion[job];
            //            foreach (var key in proportions.Keys)
            //            {
            //                addpoint = Mathf.RoundToInt(remainPoint * proportions[key]);
            //                recommends.Add(new ReikiRootRecommend()
            //                {
            //                    id = key,
            //                    value = addpoint,
            //                });
            //                if (!m_CacheReikiRootPoints.ContainsKey(key))
            //                {
            //                    m_CacheReikiRootPoints.Add(key, 0);
            //                }
            //                m_CacheReikiRootPoints[key] += addpoint;
            //            }
            //            remainPoint = 0;
            //        }
            //        else
            //        {
            //            addpoint = Mathf.Min(remainPoint, GetCacheQualityRequrePoint(id,
            //                quality < currentMaxQuality ? currentMaxQuality : quality + 1));
            //            remainPoint -= addpoint;
            //            recommends.Add(new ReikiRootRecommend()
            //            {
            //                id = id,
            //                value = addpoint,
            //            });
            //            if (!m_CacheReikiRootPoints.ContainsKey(id))
            //            {
            //                m_CacheReikiRootPoints.Add(id, 0);
            //            }
            //            m_CacheReikiRootPoints[id] += addpoint;
            //        }
            //    }
            //}
            return recommends;
        }

        int GetCacheQualityRequrePoint(int id,int quality)
        {
            var requirePoint = 0;
            var currebtQuality = GetReikiRootQuality(id, GetReikiRootCachePoint(id));
            if (currebtQuality < quality)
            {
                var point = GetReikiRootCachePoint(id);
                requirePoint = GetQualityPoint(id, quality) - point;
            }
            return requirePoint;
        }

        public int GetQualityPoint(int id, int quality)
        {
            var config = ReikiRootConfig.Get(id);
            for (int i = 0; i < config.qualityArea.Length; i++)
            {
                if (quality == i + 1)
                {
                    return config.qualityArea[i];
                }
            }
            return 0;
        }

        public void GetReikiRootProperty(int id, int point, ref Dictionary<int, int> propertyDict)
        {
            var config = ReikiRootConfig.Get(id);

            if (!propertyDict.ContainsKey(config.propertyPerPoint.x))
            {
                propertyDict.Add(config.propertyPerPoint.x, 0);
            }
            propertyDict[config.propertyPerPoint.x] += config.propertyPerPoint.y * point;

            var job = PlayerDatas.Instance.baseData.Job;
            var promotePropertyId = config.GetPromotePropertyId(job);

            if (!propertyDict.ContainsKey(promotePropertyId))
            {
                propertyDict.Add(promotePropertyId, 0);
            }
            var quality = GetReikiRootQuality(id, point);
            propertyDict[promotePropertyId] += GetQualityProperty(id, quality);
        }

        public int GetQualityProperty(int id, int quality)
        {
            var config = ReikiRootConfig.Get(id);
            var job = PlayerDatas.Instance.baseData.Job;
            var promoteValues = m_PromotePropertyValues[id][job];
            var value = 0;
            for (int i = 0; i < promoteValues.Length; i++)
            {
                if (quality > i)
                {
                    value = promoteValues[i];
                }
                else
                {
                    break;
                }
            }
            return value;
        }

        public static string GetQualityLabel(int quality)
        {
            return Language.Get(StringUtility.Contact("ReikiRootQuality_", quality));
        }

        public int GetQualityColor(int quality)
        {
            return m_ReikiQualityMapColors.ContainsKey(quality) ? m_ReikiQualityMapColors[quality] : 1;
        }

        public void ReceivePackage(HB107_tagMCRolePointInfo package)
        {
            for (int i = 0; i < package.PointAttrIDCount; i++)
            {
                var id = package.PointAttrIDList[i];
                var point = package.PointValueList[i];
                m_ReikiRootFreePoints[id] = point;
            }
        }

        public void SendAddPoint(byte[] points, ushort[] pointValues)
        {
            var pak = new CB206_tagCMAddPoint();
            pak.PointAttrIDList = points;
            pak.PointValueList = pointValues;
            pak.PointAttrIDCount = (byte)points.Length;
            GameNetSystem.Instance.SendInfo(pak);
        }

        int QualityCompare(int lhs, int rhs)
        {
            var lhsQuality = GetReikiRootQuality(lhs, GetReikiRootCachePoint(lhs));
            var rhsQuality = GetReikiRootQuality(rhs, GetReikiRootCachePoint(rhs));
            if (lhs != rhs)
            {
                if (mainReikiRoot == lhs || mainReikiRoot == rhs)
                {
                    if (lhsQuality == rhsQuality)
                    {
                        return mainReikiRoot == lhs ? -1 : 1;
                    }
                }
            }
            return lhsQuality.CompareTo(rhsQuality);
        }

        private void PlayerDataRefreshEvent(PlayerDataType dataType)
        {
            switch (dataType)
            {
                case PlayerDataType.CDBPlayerRefresh_Mater:
                case PlayerDataType.CDBPlayerRefresh_Wood:
                case PlayerDataType.CDBPlayerRefresh_Water:
                case PlayerDataType.CDBPlayerRefresh_Fire:
                case PlayerDataType.CDBPlayerRefresh_Earth:
                    RefreshReikiRootPoint();
                    break;
                case PlayerDataType.FreePoint:
                    RefreshRedpoint();
                    break;
            }
        }

        void RefreshReikiRootPoint()
        {
            foreach (var id in reikiRoots)
            {
                m_ReikiRootPoints[id] = (int)UIHelper.GetPropertyValue((PropertyType)id);
            }
            if (onReikiRootPointRefresh != null)
            {
                onReikiRootPointRefresh();
            }
        }

        void RefreshRedpoint()
        {
            var existFreePoint = false;
            if (FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.ReikiRoot))
            {
                existFreePoint = freePoint > 0;
            }
            redpoint.state = existFreePoint ? RedPointState.Simple : RedPointState.None;
        }
    }

    public struct ReikiRootRecommend
    {
        public int id;
        public int value;
    }

    public static class ReikiRootConfigUtil
    {
        public static int GetPromotePropertyId(this ReikiRootConfig config, int job)
        {
            if (config != null)
            {
                foreach (var item in config.promoteProperty)
                {
                    if (item.x == job)
                    {
                        return item.y;
                    }
                }
            }
            return 0;
        }
    }
}