// ***********************************************************************
// Assembly         : Unity
// Author           : Kimch
// Created          : 2019-06-05
// Description      :
// Last Modified By : 
// Last Modified On : 
// ***********************************************************************
// <copyright file= "PlayerProxy" company="Kunpo"></copyright>
// <summary></summary>
// ***********************************************************************
using System.Collections;
using System.Collections.Generic;
using CodeStage.AntiCheat.ObscuredTypes;
using F;
using UnityEngine;

namespace G
{
    /// <summary>
    /// 
    /// </summary>
    public partial class PlayerProxy : GameProxy
    {
        #region Proxy

        private static PlayerProxy _Instance;
        public static PlayerProxy Instance
        {
            get { return _Instance; }
        }

        private void Awake()
        {
            _Instance = this;
        }

        public override int priority => 900;

        public override void ReadArchive()
        {
            this.InitCombatAttributes();
            this.InitEquipmentSlots();
            this.InitEquipmentSlotSuits();

            LoadCha();
            LoadEquipmentSlots();
            LoadEquipmentSuits();
            this.UpdateAttributes(false);

            SyncMission();
        }

        private void SyncMission()
        {
            //MissionProxy.Instance.OnEvent2(MissionProxy.角色达到X, this.grade);
            int totalGrade = 0;
            for (int i = 0; i < _equipmentSlots.Length; i++)
            {
                totalGrade += _equipmentSlots[i].grade;
            }
            MissionProxy.Instance.OnEvent2(MissionProxy.累计强化次数, totalGrade);
        }

        #endregion

        #region Method

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public ItemCha GetCurrentCha()
        {
            return ItemProxy.Instance.GetStaticItem<ItemCha>(1);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public string GetCurrentChaModel()
        {
            var skin = ChaSkinProxy.Instance.GetCurrentSkin(0).item;
            if (skin.asset3d == "cha_01_skin_1" && KPlatform.Instance.IsAbConfig("expt_cha", "1"))
                return "cha_01_skin_t";
            return skin.asset3d;
        }

        public string GetWeaponModel(int weaponKind)
        {
            var chaSkinInfo = ChaSkinProxy.Instance.GetCurrentSkin(weaponKind);
            if (chaSkinInfo != null && !chaSkinInfo.isDefault)
            {
                return chaSkinInfo.item.weapon3d[weaponKind - 1];
            }
            else
            {
                return null;
            }
        }

        public ItemChaSkin GetCurrentChaSkin()
        {
            var weapon = GetCurWeapon();
            if (weapon != null)
            {
                return ChaSkinProxy.Instance.GetCurrentSkin(weapon.weaponKind).item;
            }
            return ItemProxy.Instance.GetStaticItem<ItemChaSkin>(2000);
        }

        //public ItemChaSkin GetChaSkinByWeapon(int weaponKind)
        //{
        //    int skinId = ArchiveProxy.Instance.GetInt("cha_skin_" + weaponKind, 2000);
        //    return ItemProxy.Instance.GetStaticItem<ItemChaSkin>(skinId);
        //}

        //public void SetChaSkinByWeapon(int weaponKind, int skin)
        //{
        //    ArchiveProxy.Instance.SetInt("cha_skin_" + weaponKind, skin);
        //}

        private void LoadCha()
        {
            var isNew = ArchiveProxy.Instance.GetInt(GlobalDefine.KEY_NEW, 0);
            if (isNew == 0)
            {
                GlobalVar.IsNewPlayer = true;
                //设置初始装备
                var item = GetCurrentCha();
                if (item != null)
                {
                    MoneyProxy.Instance.AddCoin(item.money);
                    MoneyProxy.Instance.AddChip(item.gem);
                    //this.energyMax = item.energy;
                    if (item.weapon > 0)
                    {
                        SetDefaultEquipment(item.weapon);
                    }
                }
                ArchiveProxy.Instance.SetInt(GlobalDefine.KEY_NEW, 1);

                var saveVer = ArchiveProxy.Instance.GetString("app_ver");
                if (string.IsNullOrEmpty(saveVer))
                {
                    ArchiveProxy.Instance.SetString("app_ver", Application.version);
                }
            }
            this.gradeMax = ItemProxy.Instance.GetStaticItems<ItemChaLevel>().Count;
            UpdateGrowthCombatValue(false);
        }

        #endregion

        #region 角色属性

        /// <summary>
        /// 角色Id
        /// </summary>
        public int id
        {
            get;
            private set;
        }

        /// <summary>
        /// 配置表Id
        /// </summary>
        public int itemId
        {
            get { return 1; }
        }

        /// <summary>
        /// 等级
        /// </summary>
        public int grade
        {
            get { return Mathf.Min(ArchiveProxy.Instance.GetInt(Item.Id.kGrade, 1), gradeMax); }
            set
            {
                value = Mathf.Clamp(value, 1, gradeMax);
                var tmpGrade = ArchiveProxy.Instance.GetInt(Item.Id.kGrade, 1);
                if (value > tmpGrade)
                {
                    ArchiveProxy.Instance.SetInt(Item.Id.kGrade, value);
                    //UpdateGrowthCombatValue(true);
                    MissionProxy.Instance.OnEvent2(MissionProxy.角色达到X, value);
                    PostNotification(GlobalDefine.EVENT_GRADE_CHANGED);
                }
            }
        }

        /// <summary>
        /// 等级上限
        /// </summary>
        public int gradeMax
        {
            get;
            private set;
        }

        /// <summary>
        /// 经验
        /// </summary>
        public int exp
        {
            get { return ArchiveProxy.Instance.GetInt(Item.Id.kExp); }
            set
            {
                int tmpGrade = this.grade;
                int oldGrade = tmpGrade;

                int tmpExp = value;
            Label:
                var chaLevelItem = ItemProxy.Instance.GetStaticItem<ItemChaLevel>(tmpGrade);
                if (chaLevelItem != null && tmpGrade < gradeMax)
                {
                    if (tmpExp >= chaLevelItem.exp)
                    {
                        tmpExp -= chaLevelItem.exp;
                        tmpGrade += 1;
                        if (tmpExp > chaLevelItem.exp)
                            goto Label;
                    }
                }

                ArchiveProxy.Instance.SetInt(Item.Id.kExp, tmpExp);
                if (oldGrade < tmpGrade)
                {
                    this.grade = tmpGrade;

                    KStatistics.Instance.ReportEventLevelUp(1, oldGrade, tmpGrade, "battle", 0);
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="value"></param>
        public void AddExp(int value)
        {
            if (value > 0)
            {
                this.exp += value;
            }
        }

        /// <summary>
        /// 当前等级所需经验
        /// </summary>
        public int expMax
        {
            get
            {
                var gi = this.GetGradeInfo(this.grade);
                return gi != null ? gi.exp : 1;
            }
        }

        /// <summary>
        /// 经验比例
        /// </summary>
        public float expRatio
        {
            get { return UnityEngine.Mathf.Clamp01(exp / (float)expMax); }
        }

        /// <summary>
        /// 
        /// </summary>
        public int combatValue
        {
            get { return _combatValues[0]; }
        }

        /// <summary>
        /// 昵称
        /// </summary>
        public string nickName
        {
            get { return ArchiveProxy.Instance.GetString("name", "少侠李太白"); }
            set
            {
                if (!string.IsNullOrEmpty(value))
                    ArchiveProxy.Instance.SetString("name", value);
            }
        }

        /// <summary>
        /// 自我介绍
        /// </summary>
        public string selfIntro
        {
            get;
            set;
        }

        /// <summary>
        /// 头像
        /// </summary>
        public string headURL
        {
            get { return ArchiveProxy.Instance.GetString("avatar", ""); }
            set
            {
                if (!string.IsNullOrEmpty(value))
                {
                    ArchiveProxy.Instance.SetString("avatar", value);
                }
                else
                {
                    ArchiveProxy.Instance.SetString("avatar", "");
                }
            }
        }

        public string socialAvatarUrl
        {
            get;
            set;
        }

        public string socialNickName
        {
            get;
            set;
        }

        #endregion

        #region Energy

        private int _energyTime => energy;

        private const int ENERGY_RECOVER_SECOND = 900;
        private const int ENERGY_LIMIT = 600;
        private const int ENERGY_INIT_AMOUNT = 20;

        /// <summary>
        /// 
        /// </summary>
        public int energy
        {
            get
            {
                var result = ArchiveProxy.Instance.GetInt(Item.Id.kEnergy);
                int maxEnergy = this.energyMax;
                if (result >= maxEnergy && result <= ENERGY_LIMIT)
                {
                    return result;
                }
                else
                {
                    float secondEnergy = (result - Launch.Timestamp) / (float)ENERGY_RECOVER_SECOND;
                    //int second = Mathf.Max(0, result - Launch.Timestamp);// (float)ENERGY_RECOVER_SECOND);
                    return Mathf.Clamp((int)(maxEnergy - secondEnergy), 0, maxEnergy);
                }
            }
            set
            {
                int maxEnergy = this.energyMax;
                if (value >= maxEnergy)
                {
                    ArchiveProxy.Instance.SetInt(Item.Id.kEnergy, Mathf.Min(ENERGY_LIMIT, value));
                }
                else if (value >= 0)
                {
                    var tmpEnergy = ArchiveProxy.Instance.GetInt(Item.Id.kEnergy);
                    int second = 0;
                    if (tmpEnergy > ENERGY_LIMIT)
                    {
                        second = Mathf.Max(0, tmpEnergy - Launch.Timestamp);
                        second %= ENERGY_RECOVER_SECOND;
                        if (second != 0)
                            second = ENERGY_RECOVER_SECOND - second;
                    }
                    tmpEnergy = Launch.Timestamp + Mathf.Max(0, (maxEnergy - value) * ENERGY_RECOVER_SECOND - second);
                    ArchiveProxy.Instance.SetInt(Item.Id.kEnergy, tmpEnergy);
                }

                //if (_energy >= energyMax)
                //{
                //	int diff = _energy - value;
                //	_energy = value;
                //	if (_energy < energyMax)
                //		_energyTime = Launch.Timestamp + (ENERGY_RECOVER_SECOND * diff);
                //	else
                //		_energyTime = 0;
                //}
                //else
                //{
                //	int diff = _energy - value;
                //	_energy = value;
                //	if (_energy < energyMax)
                //		_energyTime += (ENERGY_RECOVER_SECOND * diff);
                //	else
                //		_energyTime = 0;
                //}
                //ArchiveProxy.Instance.SetInt((int)Item.ItemId.kEnergy, _energy);
                //ArchiveProxy.Instance.SetInt("energy_time", _energyTime);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public float energyOverflow
        {
            get
            {
                var result = ArchiveProxy.Instance.GetInt(Item.Id.kEnergy);
                int maxEnergy = this.energyMax;
                if (result >= maxEnergy && result <= ENERGY_LIMIT)
                {
                    return 0f;
                }
                else
                {
                    return (Launch.Timestamp - result) / (float)ENERGY_RECOVER_SECOND;
                }
            }
        }

        ObscuredInt _energyMax;
        /// <summary>
        /// 
        /// </summary>
        public int energyMax
        {
            get { return Mathf.Max(ENERGY_INIT_AMOUNT, _energyMax); }
            set
            {
                if (value > 0)
                    _energyMax = Mathf.Max(ENERGY_INIT_AMOUNT, value);
                else
                    _energyMax = ENERGY_INIT_AMOUNT;
                //ArchiveProxy.Instance.SetInt(GlobalDefine.KEY_ENERGY_MAX, value);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public int energyTime
        {
            get
            {
                var result = ArchiveProxy.Instance.GetInt(Item.Id.kEnergy);
                if (result >= energyMax && result <= ENERGY_LIMIT)
                {
                    return 0;
                }
                return result;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public string energyRecoverTime
        {
            get
            {
                int second = (energyTime - Launch.Timestamp);
                if (second > 0)
                {
                    int temp = second % ENERGY_RECOVER_SECOND;
                    return $"{temp / 60}:{(temp % 60).ToString("00")}";
                }
                return "";
            }
        }

        //
        private static ObscuredByte _LevelEnergyCost = 5;
        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public bool UseEnergyForLevel()
        {
            int energyCost = _LevelEnergyCost;
            if (energy >= energyCost)
            {
                energy -= energyCost;
                return true;
            }
            return false;
        }

        /// <summary>
        /// 检查
        /// </summary>
        /// <returns></returns>
        public bool CheckEnergyForLevel()
        {
            int energyCost = _LevelEnergyCost;
            return energy >= energyCost;
        }

        #endregion

        #region Motility

        private const int MOTILITY_RECOVER_SECOND = 3600;
        private const int MOTILITY_LIMIT = 100;
        private const int MOTILITY_INIT_AMOUNT = 3;

        /// <summary>
        /// 
        /// </summary>
        public int motility
        {
            get
            {
                var result = ArchiveProxy.Instance.GetInt(Item.Id.kMotility);
                if (result >= motilityMax && result <= MOTILITY_LIMIT)
                {
                    return result;
                }
                else
                {
                    int second = Mathf.Max(0, result - Launch.Timestamp);
                    return Mathf.Max(0, (int)(motilityMax - second / (float)MOTILITY_RECOVER_SECOND));
                }
            }
            set
            {
                if (value >= motilityMax)
                {
                    ArchiveProxy.Instance.SetInt(Item.Id.kMotility, Mathf.Min(MOTILITY_LIMIT, value));
                }
                else if (value >= 0)
                {
                    var tmpMotility = ArchiveProxy.Instance.GetInt(Item.Id.kMotility);
                    int second = 0;
                    if (tmpMotility > MOTILITY_LIMIT)
                    {
                        second = Mathf.Max(0, tmpMotility - Launch.Timestamp);
                        second %= MOTILITY_RECOVER_SECOND;
                        if (second != 0)
                            second = MOTILITY_RECOVER_SECOND - second;
                    }
                    tmpMotility = Launch.Timestamp + Mathf.Max(0, (motilityMax - value) * MOTILITY_RECOVER_SECOND - second);
                    ArchiveProxy.Instance.SetInt(Item.Id.kMotility, tmpMotility);
                }
            }
        }

        ObscuredInt _motilityMax;
        /// <summary>
        /// (0)重置
        /// </summary>
        public int motilityMax
        {
            get { return Mathf.Max(MOTILITY_INIT_AMOUNT, _motilityMax); }
            set
            {
                if (value > 0)
                    _motilityMax = Mathf.Max(MOTILITY_INIT_AMOUNT, value);
                else
                    _motilityMax = MOTILITY_INIT_AMOUNT;
                //ArchiveProxy.Instance.SetInt(GlobalDefine.KEY_MOTILITY_MAX, value);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public int motilityTime
        {
            get
            {
                var result = ArchiveProxy.Instance.GetInt(Item.Id.kMotility);
                if (result >= motilityMax && result <= MOTILITY_LIMIT)
                {
                    return 0;
                }
                return result;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public string motilityRecoverTime
        {
            get
            {
                int second = (motilityTime - Launch.Timestamp);
                if (second > 0)
                {
                    int temp = second % MOTILITY_RECOVER_SECOND;
                    return $"{temp / 60}:{(temp % 60).ToString("00")}";
                }
                return "";
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="check"></param>
        /// <returns></returns>
        public bool UseMotilityForTravel(bool check = false)
        {
            if (motility >= 1)
            {
                if (!check)
                    motility -= 1;
                return true;
            }
            return false;
        }

        #endregion

        #region 角色信息表  

        /// <summary>
        /// 头像信息表
        /// </summary>
        public class HeadInfo
        {
            public enum Type
            {
                PlayerHead = 1,
            }
            public int id
            {
                get;
                private set;
            }

            public int type
            {
                get;
                private set;
            }

            public string icon
            {
                get;
                private set;
            }

            public bool unlocked
            {
                get;
                private set;
            }

            public void Load(IDictionary<string, object> table)
            {
                this.id = table.GetInt("Id");
                this.type = table.GetInt("Type");
                this.icon = table.GetString("Icon");
            }
        }

        public class NameInfo
        {
            public int id;
            public int type;

            public void Load(IDictionary<string, object> table)
            {
                id = table.GetInt("Id");
                type = table.GetInt("Type");
            }
        }

        public class HeadFrameInfo
        {
            public int id;
            public int nameId;
            public string iconName;
            public string iconAtlas;
            public bool islock = false;
            public void Load(IDictionary<string, object> table)
            {
                //id = table.GetInt("Id");
                //nameId = table.GetInt("NameId");
                //iconName = table.GetString("Icon");
                //iconAtlas = table.GetString("IconAtlas");
            }
        }

        private static Dictionary<int, HeadInfo> _HeadInfos;

        public ItemChaLevel GetGradeInfo(int grade)
        {
            return ItemProxy.Instance.GetStaticItem<ItemChaLevel>(grade);
        }

        public List<HeadInfo> GetAllHeads()
        {
            return new List<HeadInfo>(_HeadInfos.Values);
        }

        public HeadInfo GetHeadInfo(int id)
        {
            HeadInfo ret = null;
            if (_HeadInfos != null)
            {
                _HeadInfos.TryGetValue(id, out ret);
            }
            return ret;
        }
        /// <summary>
        /// 1为男性2为女性
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        public static string GetRandomName(int type)
        {
            var firstString = string.Empty;
            var familyString = string.Empty;
            return firstString + familyString;
        }

        #endregion
    }
}