using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;
using TableConfig;
using System;
using System.Text;
using System.Text.RegularExpressions;

namespace Snxxz.UI
{
    public class RolePanel : Window
    {
        [SerializeField] FunctionButtonGroup buttonGroup;
        [SerializeField] FunctionButton functionButtonRole;
        [SerializeField] FunctionButton functionButtonClothes;
        [SerializeField] FunctionButton functionButtonMounts;
        [SerializeField] FunctionButton functionButtonMagician;
        [SerializeField] FunctionButton functionButtonGulu;
        [SerializeField] FunctionButton functionButtonHorucx;

        [SerializeField] RectTransform m_RoleInfoRt;
        [SerializeField] Text m_PropertyAtk;
        [SerializeField] Text m_PropertyHp;
        [SerializeField] Text m_PropertyHit;
        [SerializeField] Text m_PropertyDef;
        [SerializeField] Text m_PropertyDodge;
        [SerializeField] Text m_PropertyAtkSpeed;
        [SerializeField] Text m_PropertyMoveSpeed;
        [SerializeField] Text m_PropertyRealHurt;
        [SerializeField] Text m_PropertyRealDef;
        [SerializeField] Text m_PropertyExtraHurt;
        [SerializeField] Text m_PropertyReduceHurt;
        [SerializeField] Text m_PropertyCritOdd;
        [SerializeField] Text m_PropertyCritHurt;
        [SerializeField] Text m_PropertyCritHurtOdd;
        [SerializeField] Text m_PropertyCritHitHurt;
        [SerializeField] Text m_PlayerExp;
        [SerializeField] Text m_PlayerLv;
        [SerializeField] Text m_PlayerName;
        [SerializeField] Text m_PlayerFightPower;
        [SerializeField] RawImage m_PlayerShowModel;
        [SerializeField] RectTransform m_ContainerExp;
        [SerializeField] Slider m_ExpSlider;
        [SerializeField] Text m_WorldExp;
        [SerializeField] Button m_PlayerPropertyBtn;
        [SerializeField] Button m_TitleBtn;
        [SerializeField] Button m_RenameBtn;
        [SerializeField] Image m_RoleTitleIcon;
        [SerializeField] Image m_RoleRealmIcon;
        [SerializeField] Button m_LeftBtn;
        [SerializeField] Button m_RightBtn;
        [SerializeField] Button m_CloseBtn;
        [SerializeField] Button m_Btn_Elixir;

        RoleModel m_Model;
        RoleModel model
        {
            get
            {
                return m_Model ?? (m_Model = ModelCenter.Instance.GetModel<RoleModel>());
            }
        }

        TitleModel m_TitleModel;
        TitleModel titleModel
        {
            get
            {
                return m_TitleModel ?? (m_TitleModel = ModelCenter.Instance.GetModel<TitleModel>());
            }
        }
        private void OnRefreshTitle()
        {
            TitleData titleData = titleModel.GetTitleEquip();
            if (titleData != null && titleModel.IsTitleGain(titleData.id))
            {
                m_RoleTitleIcon.gameObject.SetActive(true);
                DienstgradConfig cfg = Config.Instance.Get<DienstgradConfig>(titleData.id);
                if (cfg != null)
                {
                    m_RoleTitleIcon.SetSprite(cfg.Image);
                }
            }
            else
            {
                m_RoleTitleIcon.gameObject.SetActive(false);
            }
        }
        private void OnRefreshRealm()
        {
            int realmlv = PlayerDatas.Instance.baseData.realmLevel;
            RealmConfig presentCfg = Config.Instance.Get<RealmConfig>(realmlv);
            if (presentCfg != null && presentCfg.Lv > 0)
            {
                m_RoleRealmIcon.SetSprite(presentCfg.Img);
                m_RoleRealmIcon.gameObject.SetActive(true);
            }
            else
            {
                m_RoleRealmIcon.gameObject.SetActive(false);
            }
        }
        private void OnRenameClick()
        {
            MessageWin.Inst.ShowFixedTip(Language.Get("Z1025"));
        }

        private void OnElixirClick()
        {
            //WindowCenter.Instance.Open<RoleElixirTipWin>();
        }
        private void OnDesignationClick()
        {
            if (FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Title))
            {
                WindowCenter.Instance.Open<RoleTitle>();
            }
            else
            {
                FuncOpen.Instance.ProcessorFuncErrorTip((int)FuncOpenEnum.Title);
            }
        }
        private void OnAttrExplainClick()
        {
            WindowCenter.Instance.Open<RoleAttrWin>();
        }
        //private void OnPromoteClick()
        //{
        //    if (FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.AddPoint))
        //    {
        //        WindowCenter.Instance.Open<RolePoint>();
        //    }
        //    else
        //    {
        //        FuncOpen.Instance.ProcessorFuncErrorTip((int)FuncOpenEnum.AddPoint);
        //    }
        //}
        private void OnRefreshPlayerInfo(PlayerDataRefresh refreshType)
        {
            switch (refreshType)
            {
                case PlayerDataRefresh.FightPower:
                    m_PlayerFightPower.text = PlayerDatas.Instance.baseData.FightPoint.ToString();
                    break;
                case PlayerDataRefresh.MAXATK:
                case PlayerDataRefresh.MINATK:
                case PlayerDataRefresh.MaxHP:
                case PlayerDataRefresh.HIT:
                case PlayerDataRefresh.DEF:
                case PlayerDataRefresh.Miss:
                    {
                        OnUpdateBasicAttr();
                    }
                    break;
                //case PlayerDataRefresh.BattleValEx1:
                //case PlayerDataRefresh.Speed:
                //case PlayerDataRefresh.ExAttr3:
                //case PlayerDataRefresh.ExAttr4:
                //case PlayerDataRefresh.BattleValEx3:
                //case PlayerDataRefresh.DamageReduceRate:
                //case PlayerDataRefresh.SuperHitRate:
                //case PlayerDataRefresh.SuperHit:
                //case PlayerDataRefresh.LuckyHitRate:
                //case PlayerDataRefresh.LuckyHitVal:
                //    {
                //    }
                //    break;
                case PlayerDataRefresh.OfficialRank:
                    {
                        OnRefreshRealm();
                    }
                    break;
                case PlayerDataRefresh.LV:
                case PlayerDataRefresh.TotalExp:
                case PlayerDataRefresh.ExpPoint:
                    {
                        OnUpdateLvExp();
                        OnRefreshWorldLv();
                    }
                    break;
            }
        }

        private void RefreshPlayerInfoEvent()
        {
            OnUpdateSpecialAttr();
        }

        void InitRole()
        {
            OnUpdateBasicAttr();
            OnUpdateSpecialAttr();
            OnUpdateLvExp();
            m_PlayerFightPower.text = PlayerDatas.Instance.baseData.FightPoint.ToString();
            UI3DModelExhibition.Instance.BeginShowPlayer(m_PlayerShowModel, PlayerDatas.Instance.baseData.Job);
            OnRefreshRealm();
            OnRefreshWorldLv();
        }

        void OnUpdateLvExp()
        {
            int lv = PlayerDatas.Instance.baseData.LV;
            if (Config.Instance.Get<PlayerLVConfig>(lv + 1) == null)
            {
                m_ExpSlider.maxValue = 1;
                m_ExpSlider.minValue = 0;
                m_ExpSlider.value = 1;
                m_PlayerExp.text = Language.Get("L1055");
            }
            else
            {
                m_ExpSlider.minValue = 0;
                m_ExpSlider.maxValue = PlayerLVConfig.GetExpByPlayerLv(lv);
                m_ExpSlider.value = (ulong)PlayerDatas.Instance.baseData.TotalExp + (ulong)PlayerDatas.Instance.baseData.ExpPoint * 100000000;
                m_PlayerExp.text = string.Format("{0}/{1}", UIHelper.ReplaceLargeNum((ulong)PlayerDatas.Instance.baseData.TotalExp + (ulong)PlayerDatas.Instance.baseData.ExpPoint * 100000000), UIHelper.ReplaceLargeNum((ulong)PlayerLVConfig.GetExpByPlayerLv(lv)));
            }
            m_PlayerLv.text = Language.Get("Z1024", lv);
            m_PlayerName.text = PlayerDatas.Instance.baseData.PlayerName;
            OnRefreshTitle();
        }

        void OnUpdateBasicAttr()
        {
            m_PropertyAtk.text = StringUtility.Contact(ReplaceLargeNum((ulong)PlayerDatas.Instance.extersion.MINATK), "-", ReplaceLargeNum((ulong)PlayerDatas.Instance.extersion.MAXATK));
            m_PropertyHp.text = GetAttrStr(AttrEnum.HP);
            m_PropertyHit.text = GetAttrStr(AttrEnum.HIT);
            m_PropertyDef.text = GetAttrStr(AttrEnum.DEF);
            m_PropertyDodge.text = GetAttrStr(AttrEnum.MISS);
        }

        void OnUpdateSpecialAttr()
        {
            m_PropertyAtkSpeed.text = GetAttrStr(AttrEnum.ATKSPEED);
            m_PropertyMoveSpeed.text = GetAttrStr(AttrEnum.MoveSpeed);
            m_PropertyRealHurt.text = GetAttrStr(AttrEnum.RealHurt);
            m_PropertyRealDef.text = GetAttrStr(AttrEnum.RealResis);
            m_PropertyExtraHurt.text = GetAttrStr(AttrEnum.AddHurt);
            m_PropertyReduceHurt.text = GetAttrStr(AttrEnum.ReduceHurt);
            m_PropertyCritOdd.text = GetAttrStr(AttrEnum.CritChance);
            m_PropertyCritHurt.text = GetAttrStr(AttrEnum.CritHurt);
            m_PropertyCritHurtOdd.text = GetAttrStr(AttrEnum.HeartHit);
            m_PropertyCritHitHurt.text = GetAttrStr(AttrEnum.HeartHurt);
        }

        private string GetAttrStr(AttrEnum type)
        {
            PlayerPropertyConfig cfg = Config.Instance.Get<PlayerPropertyConfig>((int)type);
            float value = UIHelper.GetPropertyMapPlayerData(type);
            return StringUtility.Contact(UIHelper.ReplaceLargeNum(UIHelper.ReplacePercentage(value, cfg.ISPercentage)), cfg.ISPercentage == 1 ? "%" : string.Empty);
        }

        void OnDisableRole()
        {
            UI3DModelExhibition.Instance.StopShowPlayer();
        }

        protected override void BindController()
        {
        }

        protected override void AddListeners()
        {
            functionButtonRole.onClick.AddListener(OnFuncRole);
            functionButtonClothes.onClick.AddListener(OnFuncClothes);
            functionButtonMounts.onClick.AddListener(OnFuncMounts);
            functionButtonMagician.onClick.AddListener(OnFuncMagician);
            functionButtonGulu.onClick.AddListener(OnFuncGulu);
            functionButtonHorucx.onClick.AddListener(OnFuncHorucx);
            //m_PromoteBtn.onClick.AddListener(OnPromoteClick);
            m_PlayerPropertyBtn.onClick.AddListener(OnAttrExplainClick);
            m_TitleBtn.onClick.AddListener(OnDesignationClick);
            m_RenameBtn.onClick.AddListener(OnRenameClick);
            m_Btn_Elixir.onClick.AddListener(OnElixirClick);
            m_LeftBtn.onClick.AddListener(buttonGroup.TriggerLast);
            m_RightBtn.onClick.AddListener(buttonGroup.TriggerNext);
            m_CloseBtn.onClick.AddListener(CloseClick);
        }

        private void OnFuncHorucx()
        {
            functionOrder = 5;
        }

        private void OnFuncGulu()
        {
            functionOrder = 4;
        }

        private void OnFuncMagician()
        {
            CloseChild();
            if (windowState == WindowState.Opened)
            {
                WindowCenter.Instance.OpenWithoutAnimation<MagicianWin>();
            }
            else
            {
                WindowCenter.Instance.Open<MagicianWin>();
            }
            functionOrder = 3;
        }

        private void OnFuncMounts()
        {
            CloseChild();
            if (windowState == WindowState.Opened)
            {
                WindowCenter.Instance.OpenWithoutAnimation<MountWin>();
            }
            else
            {
                WindowCenter.Instance.Open<MountWin>();
            }
            functionOrder = 2;
        }

        private void OnFuncClothes()
        {
            functionOrder = 1;
        }

        private void OnFuncRole()
        {
            CloseChild();
            m_RoleInfoRt.gameObject.SetActive(true);
            InitRole();
            functionOrder = 0;
        }

        protected override void OnPreOpen()
        {
            PlayerDatas.Instance.InitPlayerInfoEvent += OnUpdateLvExp;
            PlayerDatas.Instance.PlayerDataRefreshInfoEvent += OnRefreshPlayerInfo;
            titleModel.OnRefreshGainTitle += OnRefreshTitle;
            PlayerDatas.Instance.OnRoleAttrRefresh += OnRefreshWorldLv;
            PlayerDatas.Instance.RefreshPlayerInfoEvent += RefreshPlayerInfoEvent;
        }

        protected override void OnActived()
        {
            base.OnActived();
            buttonGroup.TriggerByOrder(functionOrder);
        }

        protected override void OnAfterOpen()
        {

        }
        protected override void OnPreClose()
        {
        }
        protected override void OnAfterClose()
        {
            PlayerDatas.Instance.InitPlayerInfoEvent -= OnUpdateLvExp;
            PlayerDatas.Instance.PlayerDataRefreshInfoEvent -= OnRefreshPlayerInfo;
            titleModel.OnRefreshGainTitle -= OnRefreshTitle;
            PlayerDatas.Instance.OnRoleAttrRefresh -= OnRefreshWorldLv;
            if (!WindowJumpMgr.Instance.IsJumpState)
            {
                WindowCenter.Instance.Open<MainInterfaceWin>();
            }
            PlayerDatas.Instance.RefreshPlayerInfoEvent -= RefreshPlayerInfoEvent;
            CloseChild();
        }

        private void OnRefreshWorldLv()
        {
            int limit = Config.Instance.Get<FuncOpenLVConfig>((int)FuncOpenEnum.WorldLv).LimitLV;
            if (PlayerDatas.Instance.baseData.LV >= limit)
            {
                m_WorldExp.gameObject.SetActive(true);
                m_WorldExp.text = Language.Get("WordExpText", PlayerDatas.Instance.worldLv, Mathf.FloorToInt(UIHelper.ReplacePercentage((int)PlayerDatas.Instance.worldExpRate, 2)) + "%");
            }
            else
            {
                m_WorldExp.gameObject.SetActive(false);
            }
        }

        private void CloseChild()
        {
            if (m_RoleInfoRt.gameObject.activeSelf)
            {
                OnDisableRole();
                m_RoleInfoRt.gameObject.SetActive(false);
            }
            if (WindowCenter.Instance.CheckOpen<MagicianWin>())
            {
                WindowCenter.Instance.CloseImmediately<MagicianWin>();
            }
            if (WindowCenter.Instance.CheckOpen<MountWin>())
            {
                WindowCenter.Instance.CloseImmediately<MountWin>();
            }
        }

        public StringBuilder m_StringBuilder = new StringBuilder();

        public string ReplaceLargeNum(float num)
        {
            m_StringBuilder.Length = 0;
            float hm = (float)Math.Round(num / 100000000, 2);
            if (hm >= 1)
            {
                int _value = (int)hm;
                var _length = 3 - _value.ToString().Length;
                _length = Mathf.Max(0, _length);
                if (_length > 0)
                {
                    hm = (float)Math.Round(num / 100000000, _length);
                }
                decimal _checkValue = ((decimal)hm * 1000 - _value * 1000) / 1000;
                var _decimal = Mathf.Max(0, _checkValue.ToString().Length - 2);
                m_StringBuilder.Append(hm.ToString(StringUtility.Contact("f", _decimal > _length ? _length : _decimal)));
                m_StringBuilder.Append(Language.Get("L1070"));
                return m_StringBuilder.ToString();
            }
            float tt = (float)Math.Round(num / 10000, 2);
            if (tt >= 1)
            {
                int _value = (int)tt;
                var _length = 3 - _value.ToString().Length;
                if (_length > 0)
                {
                    tt = (float)Math.Round(num / 10000, _length);
                }
                _length = Mathf.Max(0, _length);
                decimal _checkValue = ((decimal)tt * 1000 - _value * 1000) / 1000;
                var _decimal = Mathf.Max(0, _checkValue.ToString().Length - 2);
                m_StringBuilder.Append(tt.ToString(StringUtility.Contact("f", _decimal > _length ? _length : _decimal)));
                m_StringBuilder.Append(Language.Get("L1071"));
                return m_StringBuilder.ToString();
            }
            if (m_StringBuilder.Length == 0)
            {
                num = (float)Math.Round(num, 2);
                int _value = (int)num;
                var _length = 3 - _value.ToString().Length;
                if (_length > 0)
                {
                    num = (float)Math.Round(num, _length);
                }
                _length = Mathf.Max(0, _length);
                decimal _checkValue = ((decimal)num * 1000 - _value * 1000) / 1000;
                var _decimal = Mathf.Max(0, _checkValue.ToString().Length - 2);
                m_StringBuilder.Append(num.ToString(StringUtility.Contact("f", _decimal > _length ? _length : _decimal)));
            }
            return m_StringBuilder.ToString();
        }
    }
}