using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using TableConfig;
using UnityEngine.EventSystems;
using System;
using Snxxz.UI;
using EnhancedUI.EnhancedScroller;
using System.Collections;

namespace Snxxz.UI
{
    public class MagicianWin : Window
    {
        [SerializeField] ScrollerController m_GodWeaponCtrl;
        [SerializeField] LongPressButton m_TemperBtn;
        [SerializeField] Text m_TemperBtnTxt;
        [SerializeField] GameObject m_ContainerLock;
        [SerializeField] GameObject m_ContainerUnLock;
        [SerializeField] Text previewText;
        [SerializeField] Text stuffText;
        [SerializeField] IntensifySmoothSlider m_SmoothSlider;
        [SerializeField] Text expNumText;
        [SerializeField] Text progressText;
        [SerializeField] Text attrTitText;
        [SerializeField] GameObject skillPanel;
        [SerializeField] List<GodWeaponSkill> m_Skills;
        [SerializeField] Image chooseImg;
        [SerializeField] List<ItemCell> temperItems = new List<ItemCell>();
        [SerializeField] RawImage m_GodWeaponModel;
        [SerializeField] List<GodWeaponProperty> m_Propertys;
        [SerializeField] Text m_UseItemName;
        [SerializeField] UIEffect m_GodWeaponEffect;
        [SerializeField, Header("滑动条时间")] float m_SliderDelay=0.1f;
        int m_PresentSelectItemCnt = 0;

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

        PlayerPackModel _playerPack;
        PlayerPackModel playerPack
        {
            get { return _playerPack ?? (_playerPack = ModelCenter.Instance.GetModel<PlayerPackModel>()); }
        }

        FunctionUnlockFlyObjectTarget flyObjectTarget;

        private void OnItemRefresh(PackType type, int index, int id)
        {
            if (model.selectType > 0)
            {
                UpdateUseItem(model.selectType);
                UpdateItems(model.selectItemIndex);
            }
        }
        void OnRefresh()
        {
            var _data = model.GetMagicianData(model.selectType);
            m_GodWeaponCtrl.m_Scorller.RefreshActiveCellViews();
            UpdateDynamicData(_data);
            UpdateStaticData(_data);
        }

        void RefreshGodWeapons()
        {
            if (m_GodWeaponCtrl.GetNumberOfCells(m_GodWeaponCtrl.m_Scorller) == 0)
            {
                m_GodWeaponCtrl.Refresh();
                for (int i = 0; i < model.magicianTypes.Count; i++)
                {
                    m_GodWeaponCtrl.AddCell(ScrollerDataType.Header, i, OnMagicianBtnClick);
                }
                m_GodWeaponCtrl.Restart();
            }
            else
            {
                m_GodWeaponCtrl.m_Scorller.RefreshActiveCellViews();
            }
        }

        void OnMagicianBtnClick(CellView _cell)
        {
            var type = model.magicianTypes[_cell.index];
            SwitchGodWeapon(type);
        }

        List<GodWeaponConfig> skills = new List<GodWeaponConfig>(4);
        void ShowGodWeaponModel(int type)
        {
            UI3DTreasureExhibition.Instance.BeginShowGodWeapon(type, m_GodWeaponModel);
        }

        void UpdateStaticData(MagicianData data)
        {
            if (data.level < 1)
            {
                previewText.text = Language.Get("L1048");
                stuffText.text = Language.Get("L1049");
                GodWeaponConfig cfg = GodWeaponConfig.GetGodWeaponCfgByTypeLv((int)data.type, data.level + 1);
                if (cfg == null)
                {
                    return;
                }
                attrTitText.text = Language.Get("L1050", cfg.Name);
                int[] Attrs = cfg.AttrType;
                int[] Nums = cfg.AttrNum;
                for (int i = 0; i < 2; i++)
                {
                    Text attrtext = m_ContainerLock.transform.Find(string.Format("LockAttrText{0}", i)).GetComponent<Text>();
                    Text numtext = m_ContainerLock.transform.Find(string.Format("LockNumText{0}", i)).GetComponent<Text>();
                    attrtext.gameObject.SetActive(false);
                    numtext.gameObject.SetActive(false);
                    if (i < Attrs.Length)
                    {
                        int id = Attrs[i];
                        if (id == 0)
                            continue;
                        PlayerPropertyConfig propertyCfg = Config.Instance.Get<PlayerPropertyConfig>(id);
                        attrtext.gameObject.SetActive(true);
                        attrtext.text = propertyCfg.Name;
                        numtext.gameObject.SetActive(true);
                        numtext.text = StringUtility.Contact("+", UIHelper.ReplacePercentage(Nums[i], propertyCfg.ISPercentage), propertyCfg.ISPercentage == 1 ? "%" : string.Empty);
                    }
                }
                m_TemperBtnTxt.text = Language.Get("L1130");
            }
            else
            {
                previewText.text = Language.Get("L1051");
                stuffText.text = Language.Get("L1052");
            }
        }

        void UpdateDynamicData(MagicianData _data, bool _switch = false)
        {
            if (_data.level < 1)
            {
                int progress = (int)((float)_data.exp / GodWeaponConfig.GetGodWeaponCfgByTypeLv((int)_data.type, _data.level).NeedExp * 100);
                progressText.text = StringUtility.Contact(progress, "%");
            }
            else
            {
                m_ContainerLock.gameObject.SetActive(false);
                m_ContainerUnLock.gameObject.SetActive(true);
                GodWeaponConfig cfg = GodWeaponConfig.GetGodWeaponCfgByTypeLv((int)_data.type, _data.level);
                GodWeaponConfig nextCfg = GodWeaponConfig.GetGodWeaponCfgByTypeLv((int)_data.type, _data.level + 1);
                m_SmoothSlider.slider.minValue = 0;
                m_SmoothSlider.slider.maxValue = 1;
                int[] _propertys;
                int[] _propertyValues;
                if (nextCfg == null)
                {
                    m_SmoothSlider.stage = cfg.Lv;
                    m_SmoothSlider.delay = 0;
                    m_SmoothSlider.ResetStage();
                    m_SmoothSlider.value = cfg.NeedExp == 0 ? 1 : cfg.NeedExp;
                    expNumText.text = Language.Get("L1053");
                    _propertys = cfg.AttrType;
                    _propertyValues = cfg.AttrNum;
                }
                else
                {
                    m_SmoothSlider.stage = cfg.Lv;
                    if (_switch)
                    {
                        m_SmoothSlider.delay = 0;
                        m_SmoothSlider.ResetStage();
                    }
                    else
                    {
                        m_SmoothSlider.delay = m_SliderDelay;
                    }
                    expNumText.text = StringUtility.Contact(_data.exp, "/", cfg.NeedExp);
                    m_SmoothSlider.value = (float)_data.exp/ cfg.NeedExp;
                    _propertys = nextCfg.AttrType;
                    _propertyValues = nextCfg.AttrNum;
                }
                for (int i = 0; i < m_Propertys.Count; i++)
                {
                    m_Propertys[i].SetActive(i < _propertys.Length);
                    if(i>=_propertys.Length)
                    {
                        continue;
                    }
                    PlayerPropertyConfig _propCfg = Config.Instance.Get<PlayerPropertyConfig>(_propertys[i]);
                    m_Propertys[i].propertyName.text = _propCfg.Name;
                    var _value = 0.0f;
                    m_Propertys[i].propertyValue.text = _value.ToString();
                    if (cfg != null && i < cfg.AttrNum.Length)
                    {
                        _value = UIHelper.ReplacePercentage(cfg.AttrNum[i], _propCfg.ISPercentage);
                        m_Propertys[i].propertyValue.text = StringUtility.Contact(_value, _propCfg.ISPercentage == 1 ? "%" : string.Empty);
                    }
                    m_Propertys[i].propertyUpValue.gameObject.SetActive(nextCfg != null);
                    if(nextCfg != null)
                    {
                        var _upValue = UIHelper.ReplacePercentage(_propertyValues[i], _propCfg.ISPercentage) - _value;
                        m_Propertys[i].propertyUpValue.gameObject.SetActive(_upValue != 0);
                        m_Propertys[i].propertyUpValue.text = StringUtility.Contact("+", (float)Math.Round(_upValue, 2), _propCfg.ISPercentage == 1 ? "%" : string.Empty);
                    }
                }
                m_TemperBtnTxt.text = Language.Get("L1131"); ;
            }

            List<GodWeaponConfig> list = GodWeaponConfig.GetGodWeaponCfgByType((int)_data.type);
            skills.Clear();
            if (list != null)
            {
                for (int i = 0; i < list.Count; i++)
                {
                    if (list[i].SkillID != 0)
                    {
                        skills.Add(list[i]);
                    }
                }
            }
            if (skills.Count < 1)
            {
                skillPanel.SetActive(false);
            }
            else
            {
                skillPanel.SetActive(true);
                for (int i = 0; i < m_Skills.Count; i++)
                {
                    var _godWeaponCfg = skills[i];
                    m_Skills[i].skillIcon.gameObject.SetActive(true);
                    var _skillCfg = Config.Instance.Get<SkillConfig>(skills[i].SkillID);
                    if (_skillCfg != null)
                    {
                        m_Skills[i].skillIcon.SetSprite(_skillCfg.IconName);
                        var _hasSkill = PlayerDatas.Instance.skill.GetSKillById(_skillCfg.SkillID) != null;
                        m_Skills[i].skillLock.gameObject.SetActive(!_hasSkill);
                        m_Skills[i].skillName.gameObject.SetActive(!_hasSkill);
                        m_Skills[i].skillIcon.material = _hasSkill ? MaterialUtility.GetUIDefaultGraphicMaterial() :
                            MaterialUtility.GetDefaultSpriteGrayMaterial();
                        if (!_hasSkill)
                        {
                            m_Skills[i].skillName.text = Language.Get("L1091", skills[i].Lv);
                        }
                    }
                    m_Skills[i].skillBtn.RemoveAllListeners();
                    m_Skills[i].skillBtn.onClick.AddListener(() =>
                    {
                        OnSkillClick(_godWeaponCfg);
                    });
                }
            }
        }

        private void OnSkillClick(GodWeaponConfig cfg)
        {
            string extra = string.Empty;
            if (PlayerDatas.Instance.skill.GetSKillById(cfg.SkillID) == null)
            {
                extra = StringUtility.Contact("<color=#fa0101>", Language.Get("L1113", cfg.Name, cfg.Lv), "</color>");
            }
            SkillDetails.ShowSkillDetails(cfg.SkillID, SkillDetails.SkillSourceType.MagicianSkill, 0, cfg.Name, extra);
        }

        void UpdateUseItem(int type)
        {
            int[] items = model.GetLvUpItemByType(type);
            if (items != null)
            {
                for (int i = 0; i < temperItems.Count; i++)
                {
                    if (i >= items.Length)
                    {
                        temperItems[i].gameObject.SetActive(false);
                        continue;
                    }
                    else
                    {
                        temperItems[i].gameObject.SetActive(true);
                        int _Cnt = playerPack.GetItemCountByID(PackType.rptItem, items[i]);
                        ItemCellModel cellModel = new ItemCellModel(items[i], false, (ulong)_Cnt);
                        temperItems[i].Init(cellModel);
                        temperItems[i].countText.color = _Cnt > 0 ? UIHelper.GetUIColor(TextColType.Green) : UIHelper.GetUIColor(TextColType.Red);
                        temperItems[i].countText.gameObject.SetActive(true);
                    }
                }
            }
        }

        void SwitchGodWeapon(int _type)
        {
            var _data = model.GetMagicianData(_type);
            UpdateDynamicData(_data, true);
            UpdateStaticData(_data);
            if (model.selectType == _type)
            {
                return;
            }
            var _cfg = GodWeaponConfig.GetGodWeaponCfgByTypeLv(_type, _data.level);
            ShowGodWeaponModel(_type);
            if (_cfg != null)
            {
                model.selectType = (int)_type;
                m_GodWeaponCtrl.m_Scorller.RefreshActiveCellViews();
                UpdateUseItem(_type);
                UpdateItems(GetItemIndex(_type));
                m_ContainerUnLock.gameObject.SetActive(false);
                m_ContainerLock.gameObject.SetActive(false);
                if (_data.level < 1)
                {
                    m_ContainerLock.gameObject.SetActive(true);
                }
                else
                {
                    m_ContainerUnLock.gameObject.SetActive(true);
                }
            }
        }

        void OnClickTemper()
        {
            var _index = Mathf.Min(model.selectItemIndex, temperItems.Count - 1);
            var _data = model.GetMagicianData(model.selectType);
            bool _switchItem = false;
            if (_index >= 0 && _data != null && _data.level >= 1 && !model.IsGodWeaponMaxLevel((int)_data.type))
            {
                int[] items = model.GetLvUpItemByType((int)_data.type);
                if (_index < items.Length)
                {
                    var itemCfg = Config.Instance.Get<ItemConfig>(items[_index]);
                    var _itemCnt = playerPack.GetItemCountByID(PackType.rptItem, itemCfg.ID);
                    if (_itemCnt > 0)
                    {
                        EffectMgr.Instance.PlayUIEffect(GetUIEffectId(_index), 2500, temperItems[_index].transform, false);
                    }
                    _switchItem = _itemCnt == 1;
                }
            }
            model.TemperMagician(model.selectType);
            if (_switchItem)
            {
                UpdateItems(GetItemIndex(model.selectType,model.selectItemIndex));
            }
        }

        int GetUIEffectId(int _index)
        {
            if (_index == 0)
            {
                return 1117;
            }
            else if (_index == 1)
            {
                return 1118;
            }
            return 1119;
        }

        private void OnPressTemper()
        {
            if (m_PresentSelectItemCnt <= 0)
            {
                UpdateItems(GetItemIndex(model.selectType));
                if (m_PresentSelectItemCnt <= 0)
                {
                    if (!WindowCenter.Instance.CheckOpen<GetItemPathWin>())
                    {
                        int[] items = model.GetLvUpItemByType(model.selectType);
                        ItemConfig itemCfg = Config.Instance.Get<ItemConfig>(items[model.selectItemIndex]);
                        ModelCenter.Instance.GetModel<GetItemPathModel>().SetChinItemModel(itemCfg.ID);
                        if (!model.IsGodWeaponTemperItem(3, itemCfg.ID) && !NewBieCenter.Instance.completeGuidesBuf.Contains(85))
                        {
                            NewBieCenter.Instance.StartNewBieGuide(85);
                        }
                    }
                    return;
                }
            }
            m_PresentSelectItemCnt--;
            OnClickTemper();
        }

        void OnClickItem(int _index)
        {
            if (model.selectItemIndex == _index)
            {
                int[] items = model.GetLvUpItemByType(model.selectType);
                ModelCenter.Instance.GetModel<GetItemPathModel>().SetChinItemModel(items[model.selectItemIndex]);
            }
            UpdateItems(_index);
        }

        private void UpdateItems(int _index)
        {
            chooseImg.transform.localPosition = temperItems[_index].transform.localPosition;
            model.selectItemIndex = _index;
            int[] items = model.GetLvUpItemByType(model.selectType);
            var _itemCfg = Config.Instance.Get<ItemConfig>(items[_index]);
            m_PresentSelectItemCnt = playerPack.GetItemCountByID(PackType.rptItem, _itemCfg.ID);
            m_UseItemName.text = _itemCfg.ItemName;
        }

        private int GetItemIndex(int _type, int _ingoreIndex = -1)
        {
            int[] items = model.GetLvUpItemByType(_type);
            var _index = 0;
            for (int i = 0; i < items.Length; i++)
            {
                if (i == _ingoreIndex)
                {
                    continue;
                }
                var _itemCnt = playerPack.GetItemCountByID(PackType.rptItem, items[i]);
                if (_itemCnt > 0)
                {
                    _index = i;
                }
            }
            return _index;
        }

        private void OnRefreshGodWeaponCell(ScrollerDataType type, CellView cell)
        {
            var _cell = cell as GodWeaponCell;
            _cell.Display(model.magicianTypes[cell.index]);
        }

        private void prepareFlySkillEvent(ActivateShow.ActivateFunc _type, int _skillId)
        {
            if (_type == ActivateShow.ActivateFunc.GodWeapon)
            {
                var _godWeaponType = 0; var _index = 0;
                if (TryGetSkill(_skillId, out _godWeaponType, out _index))
                {
                    if (model.selectType != _godWeaponType)
                    {
                        SwitchGodWeapon(_godWeaponType);
                    }
                    flyObjectTarget = m_Skills[_index].container.AddMissingComponent<FunctionUnlockFlyObjectTarget>();
                    flyObjectTarget.IdList = new int[] { _skillId };
                    flyObjectTarget.Z_UnLockType = FunctionUnlockType.Skill;
                    FunctionUnlockFlyObjectTargetCenter.Register(FunctionUnlockType.Skill, new int[] { _skillId }, flyObjectTarget);
                }
            }
        }

        private void ComplelteFlySkillEvent(ActivateShow.ActivateFunc _type)
        {
            if (_type == ActivateShow.ActivateFunc.GodWeapon && flyObjectTarget != null)
            {
                Destroy(flyObjectTarget);
            }
        }

        private bool TryGetSkill(int _skillId, out int _type, out int _index)
        {
            _type = 0;
            _index = 0;
            foreach (var _key in model.godWeaponSkillDict.Keys)
            {
                var _dict = model.godWeaponSkillDict[_key];
                _index = 0;
                foreach (var _lv in _dict.Keys)
                {
                    if (_dict[_lv] == _skillId)
                    {
                        _type = _key;
                        return true;
                    }
                    _index++;
                }
            }
            return false;
        }

        protected override void BindController()
        {

        }

        protected override void AddListeners()
        {
            m_GodWeaponCtrl.OnRefreshCell += OnRefreshGodWeaponCell;
            m_TemperBtn.onClick.AddListener(OnClickTemper);
            m_TemperBtn.onPress.AddListener(OnPressTemper);
            for (int i = 0; i < temperItems.Count; i++)
            {
                int index = i;
                temperItems[i].cellBtn.onClick.AddListener(() =>
                {
                    OnClickItem(index);
                });
            }
        }

        protected override void OnPreOpen()
        {
            model.selectType = -1;
            var _type = model.magicianTypes[0];
            if (model.magicianTypes.Contains(model.gotoType))
            {
                _type = model.gotoType;
                model.gotoType = 0;
            }
            else
            {
                for (int i = 0; i < model.magicianTypes.Count; i++)
                {
                    if (model.GetRedpointLightByType(model.magicianTypes[i]))
                    {
                        _type = model.magicianTypes[i];
                        break;
                    }
                }
            }
            RefreshGodWeapons();
            if (!HandleAchievement())
            {
                SwitchGodWeapon(_type);
                UpdateUseItem(model.selectType);
                ShowGodWeaponModel(model.selectType);
                UpdateItems(GetItemIndex(model.selectType));
            }
            playerPack.RefreshItemCountAct += OnItemRefresh;
            model.OnRefresh += OnRefresh;
            SysNotifyMgr.Instance.sysNotifyEvent += SysNotifyEvent;
            WindowCenter.Instance.windowBeforeCloseEvent += WindowBeforeCloseEvent;

            if (flyObjectTarget != null)
            {
                Destroy(flyObjectTarget);
            }

            ActivateShow.prepareFlySkillEvent += prepareFlySkillEvent;
            ActivateShow.complelteFlySkillEvent += ComplelteFlySkillEvent;
        }

        protected override void OnAfterOpen()
        {

        }

        protected override void OnPreClose()
        {
            UI3DTreasureExhibition.Instance.StopShow();
            model.selectType = 0;
            model.gotoType = 0;
            playerPack.RefreshItemCountAct -= OnItemRefresh;
            model.OnRefresh -= OnRefresh;
            SysNotifyMgr.Instance.sysNotifyEvent -= SysNotifyEvent;
            ActivateShow.prepareFlySkillEvent -= prepareFlySkillEvent;
            ActivateShow.complelteFlySkillEvent -= ComplelteFlySkillEvent;
            WindowCenter.Instance.windowBeforeCloseEvent -= WindowBeforeCloseEvent;
        }

        private void WindowBeforeCloseEvent(Window _win)
        {
            if (_win is RealmPropertyUpWin)
            {
                ShowGodWeaponModel(model.selectType);
            }
        }

        private void SysNotifyEvent(string _key, ArrayList _params)
        {
            if (_key == "GetGodWeapon" && _params != null && _params.Count >= 2)
            {
                int _type = 0;
                if(!int.TryParse(_params[1].ToString(),out _type))
                {
                    return;
                }
                if ((MagicianType)_type == MagicianType.AttackMag)
                {
                    m_GodWeaponEffect.effect = 3035;
                    m_GodWeaponEffect.Play();
                }
                else if((MagicianType)_type == MagicianType.CritMag)
                {
                    m_GodWeaponEffect.effect = 3036;
                    m_GodWeaponEffect.Play();
                }
            }
        }

        protected override void OnAfterClose()
        {

        }

        bool HandleAchievement()
        {
            if (AchievementGoto.achievementType == AchievementGoto.GodWeapon)
            {
                var _cfg = Config.Instance.Get<SuccessConfig>(AchievementGoto.guideAchievementId);
                if (_cfg != null)
                {
                    var _type = _cfg.Condition[0];
                    if (model.GetRedpointLightByType(_type))
                    {
                        SwitchGodWeapon(_type);
                        UpdateUseItem(model.selectType);
                        ShowGodWeaponModel(model.selectType);
                        UpdateItems(GetItemIndex(model.selectType));
                        var _effect = AchievementGuideEffectPool.Require(1);
                        _effect.transform.SetParentEx(m_TemperBtn.transform, Vector3.zero, Vector3.zero, Vector3.one);
                        return true;
                    }
                    else
                    {
                        SysNotifyMgr.Instance.ShowTip("Achievement_8");
                    }
                }
            }
            return false;
        }
        [Serializable]
        public class GodWeaponProperty
        {
            [SerializeField] Text m_PropertyName;
            public Text propertyName
            {
                get
                {
                    return m_PropertyName;
                }
            }
            [SerializeField] Text m_PropertyValue;
            public Text propertyValue
            {
                get
                {
                    return m_PropertyValue;
                }
            }
            [SerializeField] Text m_PropertyUpValue;
            public Text propertyUpValue
            {
                get
                {
                    return m_PropertyUpValue;
                }
            }

            public void SetActive(bool _active)
            {
                m_PropertyName.gameObject.SetActive(_active);
                m_PropertyUpValue.gameObject.SetActive(_active);
                m_PropertyValue.gameObject.SetActive(_active);
            }
        }
        [Serializable]
        public class GodWeaponSkill
        {
            [SerializeField] Text m_SkillName;
            public Text skillName
            {
                get
                {
                    return m_SkillName;
                }
            }
            [SerializeField] Image m_SkillIcon;
            public Image skillIcon
            {
                get
                {
                    return m_SkillIcon;
                }
            }
            [SerializeField] RectTransform m_SkillLock;
            public RectTransform skillLock
            {
                get
                {
                    return m_SkillLock;
                }
            }
            [SerializeField] Button m_SkillBtn;
            public Button skillBtn
            {
                get
                {
                    return m_SkillBtn;
                }
            }
            [SerializeField] RectTransform m_Container;
            public RectTransform container
            {
                get
                {
                    return m_Container;
                }
            }
        }
    }
}