using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

using UnityEngine.EventSystems;
using System;
using vnxbqy.UI;
using EnhancedUI.EnhancedScroller;
using System.Collections;

namespace vnxbqy.UI
{

    public class MagicianWin : Window
    {
        [SerializeField] ScrollerController m_GodWeaponController;
        [SerializeField] LongPressButton m_Hammer;
        [SerializeField] Text m_HammerLabel;
        [SerializeField] Button m_AutoHammer;
        [SerializeField] Text m_AutoHammerLabel;
        [SerializeField] Button m_Preview;
        [SerializeField] Button m_Rule;

        [SerializeField] Text m_PropertyTitle;
        [SerializeField] Text m_CostItemTitle;

        [SerializeField] RectTransform m_ContainerUnlock;
        [SerializeField] RectTransform m_ContainerSlider;
        [SerializeField] IntensifySmoothSlider m_ExpSlider;
        [SerializeField] Text m_Exp;
        [SerializeField] PropertyBehaviour[] m_Propertys;
        [SerializeField] RectTransform m_ContainerLock;
        [SerializeField] RectTransform m_ContainerProgress;
        [SerializeField] Text m_Progress;
        [SerializeField] Text m_UnlockCondition;
        [SerializeField] PropertyBehaviour[] m_PreviewPropertys;
        [SerializeField] RectTransform m_ContainerCondition;
        [SerializeField] Text m_GodWeaponCondition;

        [SerializeField] RectTransform m_ContainerSkill;
        [SerializeField] GodWeaponSkillBehaviour[] m_Skills;
        [SerializeField] HorizontalLayoutGroup m_SkillLayout;
        [SerializeField] ContentSizeFitter m_SkillSizeFitter;
        [SerializeField] ScrollRect m_SkillScroller;

        [SerializeField] RectTransform m_EffectPoint;

        [SerializeField] ItemCell[] m_Items;
        [SerializeField] Image m_Select;
        [SerializeField] RawImage m_GodWeaponModel;
        [SerializeField] UIEffect m_GodWeaponEffect;

        [SerializeField] RectTransform m_HammerRedpoint;

        [SerializeField, Header("滑动条时间")] float m_SliderDelay = 0.1f;

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

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

        int selectItemCount = 0;
        bool moneyHammer = false;
        bool lockGodWeaponUpdate = false;
        bool lockItemUpdate = false;
        AutoHammerState m_LastAutoHammerState = AutoHammerState.None;
        AutoHammerState m_AutoHammerState = AutoHammerState.None;
        AutoHammerState autoHammerState
        {
            get { return m_AutoHammerState; }
            set
            {
                m_LastAutoHammerState = m_AutoHammerState;
                m_AutoHammerState = value;
                switch (m_AutoHammerState)
                {
                    case AutoHammerState.None:
                        OnExitAutoHammer();
                        break;
                    case AutoHammerState.Hammer:
                        OnHammer();
                        break;
                    case AutoHammerState.WaitAnimation:
                        break;
                    case AutoHammerState.WaitServer:
                        OnWaitServer();
                        break;
                }
                DisplayAutoHammerLabel();
            }
        }

        FunctionUnlockFlyObjectTarget flyObjectTarget;

        float waitServerTimer = 0f;
        const float WaitServerTime = 5.0f;

        static Dictionary<int, int> currentPropertyDict = new Dictionary<int, int>();
        static List<int> displayPropertys = new List<int>();
        static Dictionary<int, int> addPropertyDict = new Dictionary<int, int>();
        #region built-in
        protected override void BindController()
        {

        }

        protected override void AddListeners()
        {
            m_GodWeaponController.OnRefreshCell += OnRefreshCell;
            m_Hammer.onClick.AddListener(Hammer);
            m_Hammer.onPress.AddListener(PressHammer);
            m_Preview.onClick.AddListener(Preview);
            m_AutoHammer.onClick.AddListener(AutoHammer);
            m_Rule.onClick.AddListener(OnRule);
            for (int i = 0; i < m_Items.Length; i++)
            {
                var index = i;
                m_Items[i].button.onClick.AddListener(() =>
                {
                    OnSelectItem(index);
                });
            }
        }

        protected override void OnPreOpen()
        {
            autoHammerState = AutoHammerState.None;
            m_LastAutoHammerState = AutoHammerState.None;
            moneyHammer = false;
            lockGodWeaponUpdate = false;
            lockItemUpdate = false;

            if (!HandleAchievement())
            {
                model.selectType = GetDefaultSelect();
            }
            model.gotoType = 0;

            DisplayGodWeaponTypes();

            DisplayGodWeaponInfo(true);
            DisplaySkills();
            DisplayItems();
            model.selectItemIndex = GetItemIndex(model.selectType);
            DisplaySelectItem();
            DisplayGodWeaponModel();

            m_SkillScroller.horizontalNormalizedPosition = 0f;

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

            SysNotifyMgr.Instance.sysNotifyEvent += SysNotifyEvent;
            model.onSelectUpdate += OnSelectUpdate;
            model.godWeaponUpdate += GodWeaponUpdate;
            packModel.refreshItemCountEvent += RefreshItemCountAct;
            WindowCenter.Instance.windowBeforeOpenEvent += WindowBeforeOpenEvent;
            WindowCenter.Instance.windowBeforeCloseEvent += WindowBeforeCloseEvent;
            ActivateShow.prepareFlySkillEvent += PrepareFlySkillEvent;
            ActivateShow.complelteFlySkillEvent += ComplelteFlySkillEvent;
            AutoHammerWin.onConfirm += OnAutoHammerConfirm;
            DTC0102_tagCDBPlayer.beforePlayerDataInitializeEvent += BeforePlayerDataInitializeEvent;
        }

        protected override void OnAfterOpen()
        {

        }

        protected override void OnAfterClose()
        {

        }

        protected override void OnPreClose()
        {
            autoHammerState = AutoHammerState.None;
            SysNotifyMgr.Instance.sysNotifyEvent -= SysNotifyEvent;
            model.onSelectUpdate -= OnSelectUpdate;
            model.godWeaponUpdate -= GodWeaponUpdate;
            packModel.refreshItemCountEvent -= RefreshItemCountAct;
            WindowCenter.Instance.windowBeforeOpenEvent -= WindowBeforeOpenEvent;
            WindowCenter.Instance.windowBeforeCloseEvent -= WindowBeforeCloseEvent;
            ActivateShow.prepareFlySkillEvent -= PrepareFlySkillEvent;
            ActivateShow.complelteFlySkillEvent -= ComplelteFlySkillEvent;
            AutoHammerWin.onConfirm -= OnAutoHammerConfirm;
            DTC0102_tagCDBPlayer.beforePlayerDataInitializeEvent -= BeforePlayerDataInitializeEvent;
            UI3DTreasureExhibition.Instance.Stop();
        }

        protected override void LateUpdate()
        {
            base.LateUpdate();
            switch (autoHammerState)
            {
                case AutoHammerState.Hammer:
                    break;
                case AutoHammerState.WaitServer:
                    waitServerTimer += Time.deltaTime;
                    if (waitServerTimer >= WaitServerTime)
                    {
                        autoHammerState = AutoHammerState.Hammer;
                    }
                    break;
            }
        }

        #endregion

        private void BeforePlayerDataInitializeEvent()
        {
            if (autoHammerState != AutoHammerState.None)
            {
                autoHammerState = AutoHammerState.None;
            }
        }

        private void SysNotifyEvent(string key, ArrayList infoList)
        {
            if (key == "GetGodWeapon" && infoList != null && infoList.Count >= 2)
            {
                int type = 0;
                if (!int.TryParse(infoList[1].ToString(), out type))
                {
                    return;
                }
                if (type == 2)
                {
                    m_GodWeaponEffect.effect = 3035;
                    m_GodWeaponEffect.Play();
                }
                else if (type == 3)
                {
                    m_GodWeaponEffect.effect = 3036;
                    m_GodWeaponEffect.Play();
                }
            }
        }

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

        private void PrepareFlySkillEvent(ActivateShow.ActivateFunc type, int skillId)
        {
            var index = 0;
            if (type == ActivateShow.ActivateFunc.GodWeapon)
            {
                var godWeaponType = 0;
                if (TryGetGodWeaponType(skillId, out godWeaponType, out index))
                {
                    model.selectType = godWeaponType;
                    flyObjectTarget = m_EffectPoint.AddMissingComponent<FunctionUnlockFlyObjectTarget>();
                    flyObjectTarget.IdList = new int[] { skillId };
                    flyObjectTarget.Z_UnLockType = FunctionUnlockType.Skill;
                    FunctionUnlockFlyObjectTargetCenter.Register(FunctionUnlockType.Skill, new int[] { skillId }, flyObjectTarget);
                }
            }

            var rt = m_SkillLayout.transform as RectTransform;
            var rt1 = m_SkillScroller.transform as RectTransform;
            var delta = m_Skills[index].transform.localPosition.x;
            var offset = rt.rect.width - rt1.rect.width;
            delta -= offset;
            m_SkillScroller.horizontalNormalizedPosition = Mathf.Clamp01(delta / offset);

            var worldpos = m_Skills[index].transform.TransformPoint(Vector3.zero);
            var localpos = transform.InverseTransformPoint(worldpos);
            m_EffectPoint.transform.localPosition = localpos;
        }

        private void WindowBeforeCloseEvent(Window window)
        {
            if (window is RealmPropertyUpWin)
            {
                DisplayGodWeaponModel();
                if (autoHammerState == AutoHammerState.WaitAnimation)
                {
                    autoHammerState = AutoHammerState.Hammer;
                }
            }
        }

        private void WindowBeforeOpenEvent(Window window)
        {
            if (window is RealmPropertyUpWin)
            {
                if (autoHammerState != AutoHammerState.None)
                {
                    autoHammerState = AutoHammerState.WaitAnimation;
                }
            }
        }

        private void RefreshItemCountAct(PackType packType, int index, int itemId)
        {
            if (packType == PackType.Item)
            {
                DisplayItems();
                bool noneOfAnyItemCount = true;
                var items = model.GetLevelUpItemByType(model.selectType);
                for (int i = 0; i < items.Length; i++)
                {
                    if (packModel.GetItemCountByID(PackType.Item, items[i]) > 0)
                    {
                        noneOfAnyItemCount = false;
                    }
                }
                var count = packModel.GetItemCountByID(PackType.Item, items[model.selectItemIndex]);
                if (count == 0 && !noneOfAnyItemCount)
                {
                    OnSelectItem(GetItemIndex(model.selectType, model.selectItemIndex));
                }
                if (model.IsGodWeaponHammerItem(model.selectType, itemId))
                {
                    lockItemUpdate = false;
                    if (!moneyHammer && autoHammerState == AutoHammerState.WaitServer
                        && !lockItemUpdate && !lockGodWeaponUpdate)
                    {
                        autoHammerState = AutoHammerState.Hammer;
                    }
                }
            }
        }

        private void OnSelectUpdate()
        {
            if (autoHammerState != AutoHammerState.None)
            {
                autoHammerState = AutoHammerState.None;
            }
            DisplayGodWeaponInfo(true);
            DisplaySkills();
            DisplayItems();
            model.selectItemIndex = GetItemIndex(model.selectType);
            DisplaySelectItem();
            DisplayGodWeaponModel();
            m_GodWeaponController.m_Scorller.RefreshActiveCellViews();

            m_SkillScroller.horizontalNormalizedPosition = 0f;
        }

        private void GodWeaponUpdate()
        {
            m_GodWeaponController.m_Scorller.RefreshActiveCellViews();
            DisplayGodWeaponInfo(false);
            lockGodWeaponUpdate = false;
            if (autoHammerState != AutoHammerState.None)
            {
                if (moneyHammer)
                {
                    if (autoHammerState == AutoHammerState.WaitServer)
                    {
                        autoHammerState = AutoHammerState.Hammer;
                    }
                }
                else
                {
                    if (!lockItemUpdate && autoHammerState == AutoHammerState.WaitServer)
                    {
                        autoHammerState = AutoHammerState.Hammer;
                    }
                }
            }
        }

        private void DisplayGodWeaponInfo(bool immediatly)
        {
            bool active = model.IsGodWeaponUnlock(model.selectType);
            var maxLevel = model.IsGodWeaponMaxLevel(model.selectType);
            m_ContainerLock.SetActive(!active);
            m_ContainerUnlock.SetActive(active);
            m_ContainerSlider.SetActive(active);
            m_Hammer.SetActive((active || model.SatisfyUnlockCondition(model.selectType)) && !maxLevel);
            m_AutoHammer.SetActive(active && !maxLevel);
            m_HammerRedpoint.SetActive(model.GetRedpointLightByType(model.selectType));

            m_Preview.SetActive(false);

            if (!active)
            {
                m_CostItemTitle.text = Language.Get("L1049");
                m_PropertyTitle.text = Language.Get("L1048");
                m_HammerLabel.text = Language.Get("L1130");
                DisplayPreviewProperty();
                DisplayProgress();
                DisplayCondition();
            }
            else
            {
                m_ContainerProgress.SetActive(false);
                m_ContainerCondition.SetActive(false);
                m_CostItemTitle.text = Language.Get("L1052");
                m_PropertyTitle.text = Language.Get("L1051");
                m_HammerLabel.text = Language.Get("L1131");
                DisplayProperty();
                DisplayExp(immediatly);
            }
        }

        private void DisplaySkills()
        {
            List<int> displaySkillLevels = new List<int>();
            Dictionary<int, int> dict;
            var index = 0;
            if (model.TryGetGodWeaponSkills(model.selectType, out dict))
            {
                displaySkillLevels.AddRange(dict.Keys);
            }
            displaySkillLevels.Sort();
            foreach (var level in displaySkillLevels)
            {
                if (index < m_Skills.Length)
                {
                    m_Skills[index].SetActive(true);
                    var godWeaponConfig = GodWeaponConfig.GetConfig(model.selectType, level);
                    if (dict != null && dict.ContainsKey(level))
                    {
                        m_Skills[index].Display(godWeaponConfig);
                    }
                    index++;
                }
            }
            for (int i = index; i < m_Skills.Length; i++)
            {
                m_Skills[i].SetActive(false);
            }
            m_ContainerSkill.SetActive(displaySkillLevels.Count > 0);
            m_SkillSizeFitter.horizontalFit = displaySkillLevels.Count > 4 ?
                ContentSizeFitter.FitMode.PreferredSize : ContentSizeFitter.FitMode.Unconstrained;
            m_SkillLayout.childAlignment = displaySkillLevels.Count > 4 ?
                TextAnchor.MiddleLeft : TextAnchor.MiddleCenter;
            m_SkillScroller.horizontal = displaySkillLevels.Count > 4;
            if (displaySkillLevels.Count <= 4)
            {
                var rt = m_SkillLayout.transform as RectTransform;
                rt.sizeDelta = rt.sizeDelta.SetX(m_ContainerSkill.rect.width);
            }
        }

        private void DisplayItems()
        {
            var items = model.GetLevelUpItemByType(model.selectType);
            for (int i = 0; i < m_Items.Length; i++)
            {
                if (items != null && i < items.Length)
                {
                    m_Items[i].SetActive(true);
                    var count = packModel.GetItemCountByID(PackType.Item, items[i]);
                    ItemCellModel cellModel = new ItemCellModel(items[i], false, (ulong)count);
                    m_Items[i].Init(cellModel);
                    m_Items[i].countText.text = count.ToString();
                    m_Items[i].countText.color = count > 0 ? UIHelper.GetUIColor(TextColType.Green) : UIHelper.GetUIColor(TextColType.Red);
                    m_Items[i].countText.SetActive(true);
                }
                else
                {
                    m_Items[i].SetActive(false);
                }
            }
        }

        private void OnSelectItem(int index, bool tip = true)
        {
            if (model.selectItemIndex == index && tip)
            {
                var items = model.GetLevelUpItemByType(model.selectType);
                ItemTipUtility.Show(items[model.selectItemIndex]);
            }
            else
            {
                model.selectItemIndex = index;
                DisplaySelectItem();
            }
        }

        private void DisplaySelectItem()
        {
            if (model.selectItemIndex >= 0 && model.selectItemIndex < m_Items.Length)
            {
                m_Select.transform.localPosition = m_Items[model.selectItemIndex].transform.localPosition;
                int[] items = model.GetLevelUpItemByType(model.selectType);
                selectItemCount = packModel.GetItemCountByID(PackType.Item, items[model.selectItemIndex]);
            }
            else
            {
                selectItemCount = 0;
            }
        }

        private void CheckSelectItemCounts()
        {
            int[] items = model.GetLevelUpItemByType(model.selectType);
            if (items != null && model.selectItemIndex >= 0 && model.selectItemIndex < items.Length)
            {
                selectItemCount = packModel.GetItemCountByID(PackType.Item, items[model.selectItemIndex]);
            }
        }

        private int GetItemIndex(int type, int except = -1)
        {
            var items = model.GetLevelUpItemByType(type);
            var index = 0;
            for (int i = 0; i < items.Length; i++)
            {
                if (i == except)
                {
                    continue;
                }
                var count = packModel.GetItemCountByID(PackType.Item, items[i]);
                if (count > 0)
                {
                    index = i;
                }
            }
            return index;
        }

        private void DisplayProgress()
        {
            bool requireProgress = !model.IsGodWeaponUnlock(model.selectType)
                && !model.ContainsCondition(model.selectType);
            m_ContainerProgress.SetActive(requireProgress);
            if (requireProgress)
            {
                var godWeaponInfo = model.GetGodWeaponInfo(model.selectType);
                var config = GodWeaponConfig.GetConfig(godWeaponInfo.type, godWeaponInfo.level);
                int progress = 100;
                if (config != null)
                {
                    progress = (int)((float)godWeaponInfo.exp / config.NeedExp * 100);
                }
                m_Progress.text = StringUtility.Contact(progress, "%");
            }
        }

        private void DisplayCondition()
        {
            bool requireCondition = !model.IsGodWeaponUnlock(model.selectType)
                && model.ContainsCondition(model.selectType);
            m_ContainerCondition.SetActive(requireCondition);
            if (requireCondition)
            {
                var playerLevelLimit = 0;
                model.TryGetPlayerLevelCondition(model.selectType, out playerLevelLimit);
                List<GodWeaponCondition> list;
                model.TryGetConditions(model.selectType, out list);

                var limitGodWeaponType = 0;
                var limitGodWeaponLevel = 0;
                if (list != null)
                {
                    var index = 0;
                    for (int i = 0; i < list.Count; i++)
                    {
                        var godWeaponInfo = model.GetGodWeaponInfo(list[i].type);
                        if (godWeaponInfo != null && godWeaponInfo.level >= list[i].level)
                        {
                            if (i + 1 < list.Count)
                            {
                                index = i + 1;
                            }
                        }
                        else
                        {
                            break;
                        }
                    }
                    if (index < list.Count)
                    {
                        limitGodWeaponType = list[index].type;
                        limitGodWeaponLevel = list[index].level;
                    }
                }
                if (playerLevelLimit > 0 && list != null)
                {
                    var config = GodWeaponConfig.GetConfig(limitGodWeaponType, 1);
                    m_GodWeaponCondition.text = Language.Get("GodWeaponCondition1", playerLevelLimit,
                        config.Name, limitGodWeaponLevel);
                }
                else if (playerLevelLimit > 0 && list == null)
                {
                    m_GodWeaponCondition.text = Language.Get("GodWeaponCondition2", playerLevelLimit);
                }
                else if (playerLevelLimit == 0 && list != null)
                {
                    var config = GodWeaponConfig.GetConfig(limitGodWeaponType, 1);
                    m_GodWeaponCondition.text = StringUtility.Contact(config.Name,
                        Language.Get("GodWeaponCondition", limitGodWeaponLevel));
                }
            }
        }

        private void DisplayExp(bool immediatly)
        {
            var godWeaponInfo = model.GetGodWeaponInfo(model.selectType);
            if (godWeaponInfo != null && godWeaponInfo.level >= 1)
            {
                bool isMaxLevel = model.IsGodWeaponMaxLevel(model.selectType);
                m_ExpSlider.slider.minValue = 0;
                m_ExpSlider.slider.maxValue = 1;
                var config = GodWeaponConfig.GetConfig(model.selectType, godWeaponInfo.level);
                m_ExpSlider.stage = config.Lv;
                if (isMaxLevel)
                {
                    m_ExpSlider.delay = 0;
                    m_ExpSlider.ResetStage();
                    m_ExpSlider.value = 1;
                    m_Exp.text = Language.Get("L1053");
                }
                else
                {
                    var value = (float)godWeaponInfo.exp / config.NeedExp;
                    if (immediatly)
                    {
                        m_ExpSlider.delay = 0;
                        m_ExpSlider.ResetStage();
                    }
                    else
                    {
                        m_ExpSlider.delay = m_SliderDelay;
                    }
                    m_Exp.text = StringUtility.Contact(godWeaponInfo.exp, "/", config.NeedExp);
                    m_ExpSlider.value = value;
                }
            }
        }

        private void DisplayPreviewProperty()
        {
            var godWeaponInfo = model.GetGodWeaponInfo(model.selectType);
            if (godWeaponInfo != null)
            {
                var config = GodWeaponConfig.GetConfig(godWeaponInfo.type, godWeaponInfo.level + 1);
                m_UnlockCondition.text = Language.Get("L1050", config.Name);
                for (int i = 0; i < m_PreviewPropertys.Length; i++)
                {
                    if (i < config.AttrType.Length)
                    {
                        m_PreviewPropertys[i].SetActive(true);
                        m_PreviewPropertys[i].DisplayUpper(config.AttrType[i], config.AttrNum[i]);
                    }
                    else
                    {
                        m_PreviewPropertys[i].SetActive(false);
                    }
                }
            }
        }

        private void DisplayProperty()
        {
            bool isMaxLevel = model.IsGodWeaponMaxLevel(model.selectType);
            var godWeaponInfo = model.GetGodWeaponInfo(model.selectType);
            currentPropertyDict.Clear();
            addPropertyDict.Clear();
            displayPropertys.Clear();
            var config = GodWeaponConfig.GetConfig(model.selectType, godWeaponInfo.level);
            for (int i = 0; i < config.AttrType.Length; i++)
            {
                currentPropertyDict.Add(config.AttrType[i], config.AttrNum[i]);
                if (!displayPropertys.Contains(config.AttrType[i]))
                {
                    displayPropertys.Add(config.AttrType[i]);
                }
            }
            if (!isMaxLevel)
            {
                config = GodWeaponConfig.GetConfig(model.selectType, godWeaponInfo.level + 1);
                for (int i = 0; i < config.AttrType.Length; i++)
                {
                    addPropertyDict.Add(config.AttrType[i], config.AttrNum[i]);
                    if (!displayPropertys.Contains(config.AttrType[i]))
                    {
                        displayPropertys.Add(config.AttrType[i]);
                    }
                }
            }
            for (int i = 0; i < m_Propertys.Length; i++)
            {
                if (i < displayPropertys.Count)
                {
                    var key = displayPropertys[i];
                    m_Propertys[i].SetActive(true);
                    var currentValue = 0;
                    if (currentPropertyDict.ContainsKey(key))
                    {
                        currentValue = currentPropertyDict[key];
                    }
                    var addValue = 0;
                    if (addPropertyDict.ContainsKey(key))
                    {
                        if (currentPropertyDict.ContainsKey(key))
                        {
                            addValue = addPropertyDict[key] - currentPropertyDict[key];
                        }
                        else
                        {
                            addValue = addPropertyDict[key];
                        }
                    }
                    m_Propertys[i].DisplayGodWeaponAdd(displayPropertys[i], currentValue, addValue);
                }
                else
                {
                    m_Propertys[i].SetActive(false);
                }
            }
        }

        private int GetDefaultSelect()
        {
            var _type = model.godWeaponTypes[0];
            if (model.godWeaponTypes.Contains(model.gotoType))
            {
                _type = model.gotoType;
                model.gotoType = 0;
            }
            else
            {
                for (int i = 0; i < model.godWeaponTypes.Count; i++)
                {
                    if (model.GetRedpointLightByType(model.godWeaponTypes[i]))
                    {
                        _type = model.godWeaponTypes[i];
                        break;
                    }
                }
            }
            return _type;
        }

        private void OnRefreshCell(ScrollerDataType type, CellView cell)
        {
            var godWeaponCell = cell as GodWeaponCell;
            godWeaponCell.Display(cell.index);
        }

        private void DisplayGodWeaponTypes()
        {
            if (m_GodWeaponController.GetNumberOfCells(m_GodWeaponController.m_Scorller) == 0)
            {
                var list = model.godWeaponSorts;
                m_GodWeaponController.Refresh();
                for (int i = 0; i < list.Count; i++)
                {
                    if (model.godWeaponTypes.Contains(list[i]))
                    {
                        m_GodWeaponController.AddCell(ScrollerDataType.Header, list[i], OnGodWeaponSelect);
                    }
                }
                m_GodWeaponController.Restart();
            }
            else
            {
                m_GodWeaponController.m_Scorller.RefreshActiveCellViews();
            }
        }

        private void OnGodWeaponSelect(CellView cell)
        {
            model.selectType = cell.index;
        }

        private void DisplayGodWeaponModel()
        {
            m_GodWeaponModel.SetActive(true);
            UI3DTreasureExhibition.Instance.ShowGodWeapon(model.selectType, m_GodWeaponModel);
        }

        private bool TryGetGodWeaponType(int skillId, out int type, out int index)
        {
            type = 0;
            index = 0;
            foreach (var key in model.godWeaponSkillDict.Keys)
            {
                var dict = model.godWeaponSkillDict[key];
                var list = model.TryGetDisplaySkillLevels(key);
                foreach (var level in dict.Keys)
                {
                    if (dict[level] == skillId)
                    {
                        type = key;
                        index = list.IndexOf(level);
                        return true;
                    }
                }
            }
            return false;
        }

        private int HammerEffectId(int index)
        {
            return index == 0 ? 1117 : index == 1 ? 1118 : 1119;
        }

        private void PressHammer()
        {
            if (autoHammerState != AutoHammerState.None)
            {
                autoHammerState = AutoHammerState.None;
            }

            if (!model.IsGodWeaponUnlock(model.selectType) && model.ContainsCondition(model.selectType))
            {
                return;
            }

            if (selectItemCount <= 0)
            {
                CheckSelectItemCounts();
                if (selectItemCount <= 0)
                {
                    OnSelectItem(GetItemIndex(model.selectType), false);
                }
                if (selectItemCount <= 0)
                {
                    var items = model.GetLevelUpItemByType(model.selectType);
                    ItemTipUtility.Show(items[model.selectItemIndex]);
                    return;
                }
            }
            selectItemCount--;
            Hammer();
        }
        
        private void Hammer()
        {
            if (autoHammerState != AutoHammerState.None)
            {
                autoHammerState = AutoHammerState.None;
            }

            if (!model.IsGodWeaponUnlock(model.selectType))
            {
                if (model.ContainsCondition(model.selectType))
                {
                    if (model.SatisfyUnlockCondition(model.selectType))
                    {
                        CA556_tagCMGodWeaponActivate pak = new CA556_tagCMGodWeaponActivate();
                        pak.WeaponType = (uint)model.selectType;
                        GameNetSystem.Instance.SendInfo(pak);
                    }

                    return;
                }
            }
            var godWeaponInfo = model.GetGodWeaponInfo(model.selectType);
            bool requireSwitchItem = false;
            if (godWeaponInfo != null)
            {
                var items = model.GetLevelUpItemByType(godWeaponInfo.type);
                if (model.selectItemIndex < items.Length)
                {
                    var count = packModel.GetItemCountByID(PackType.Item, items[model.selectItemIndex]);
                    if (count > 0 && godWeaponInfo.level >= 1)
                    {
                        EffectMgr.Instance.PlayUIEffect(HammerEffectId(model.selectItemIndex), 2500, m_Items[model.selectItemIndex].transform, false);
                    }
                    LimitedTimeLuxuryGiftModel.Instance.IsItemIdShow(10, items[model.selectItemIndex], 1, 1, 0);
                    requireSwitchItem = count == 1;
                }
            }
            model.HammerGodWeapon(model.selectType);
            EffectMgr.Instance.PlayUIEffect(HammerEffectId(model.selectItemIndex), 2500, m_Items[model.selectItemIndex].transform, false);
            if (requireSwitchItem)
            {
                OnSelectItem(GetItemIndex(model.selectType, model.selectItemIndex), false);
            }
        }

        private void OnAutoHammerConfirm(bool isOk)
        {
            if (isOk && autoHammerState == AutoHammerState.None)
            {
                moneyHammer = true;
                autoHammerState = AutoHammerState.Hammer;
            }
        }

        private void AutoHammer()
        {
            if (autoHammerState != AutoHammerState.None)
            {
                autoHammerState = AutoHammerState.None;
            }
            else
            {
                var index = 0;
                if (model.IsGodWeaponMaxLevel(model.selectType))
                {
                    return;
                }
                if (ExistAnyHammerItem(model.selectType, out index))
                {
                    moneyHammer = false;
                    autoHammerState = AutoHammerState.Hammer;
                }
                else
                {
                    //AutoHammerCost autoHammerCost;
                    //if (model.TryGetAutoHammerCost(model.selectType, out autoHammerCost))
                    //{
                    //    AutoHammerWin.selectGodWeaponType = model.selectType;
                    //    WindowCenter.Instance.Open<AutoHammerWin>();
                    //}
                    //else
                    {
                        var items = model.GetLevelUpItemByType(model.selectType);
                        ItemTipUtility.Show(items[0]);
                    }
                }
            }
        }

        
        private void OnHammer()
        {
            if (model.IsGodWeaponMaxLevel(model.selectType))
            {
                autoHammerState = AutoHammerState.None;
                return;
            }
            var items = model.GetLevelUpItemByType(model.selectType);
            LimitedTimeLuxuryGiftModel.Instance.IsItemIdShow(10, items[model.selectItemIndex], 1, 1, 0);
            var index = 0;
            if (!moneyHammer)
            {
                if (!ExistAnyHammerItem(model.selectType, out index))
                {
                    autoHammerState = AutoHammerState.None;
                    return;
                }
                var count = model.GetAutoHammerCount(model.selectType, index);
                if (index != model.selectItemIndex)
                {
                    OnSelectItem(index);
                }
                EffectMgr.Instance.PlayUIEffect(HammerEffectId(index), 2500, m_Items[index].transform, false);

                CA555_tagCMGodWeaponPlus pak = new CA555_tagCMGodWeaponPlus();
                pak.ItemID = (uint)items[index];
                pak.WeaponType = (uint)model.selectType;
                pak.IsAutoBuy = 1;
                pak.ItemCount = (byte)Mathf.Min(byte.MaxValue, count);
                GameNetSystem.Instance.SendInfo(pak);
                model.PlayHammerAudio();
            }
            else
            {
                var godWeaponInfo = model.GetGodWeaponInfo(model.selectType);
                if (godWeaponInfo != null && godWeaponInfo.level >= model.autoHammerLevel)
                {
                    autoHammerState = AutoHammerState.None;
                    return;
                }
                var requireExp = 0;
                for (int i = godWeaponInfo.level; i < model.autoHammerLevel; i++)
                {
                    var config = GodWeaponConfig.GetConfig(model.selectType, i);
                    if (config != null)
                    {
                        requireExp += config.NeedExp;
                    }
                }
                requireExp -= (int)godWeaponInfo.exp;
                requireExp = Mathf.Max(0, requireExp);
                var count = model.GetAutoHammerCount(model.selectType);
                AutoHammerCost autoHammerCost;
                if (!model.TryGetAutoHammerCost(model.selectType, out autoHammerCost))
                {
                    autoHammerState = AutoHammerState.None;
                    return;
                }
                if (count * autoHammerCost.exp > requireExp)
                {
                    count = Mathf.CeilToInt((float)requireExp / autoHammerCost.exp);
                }
                count = Mathf.Max(1, count);
                count = Mathf.Min(byte.MaxValue, count);
                var cost = count * autoHammerCost.cost;
                if (PlayerDatas.Instance.baseData.diamond < cost)
                {
                    autoHammerState = AutoHammerState.None;
                    return;
                }
                CA555_tagCMGodWeaponPlus pak = new CA555_tagCMGodWeaponPlus();
                pak.ItemID = (uint)items[0];
                pak.WeaponType = (uint)model.selectType;
                pak.IsAutoBuy = 1;
                pak.ItemCount = (byte)count;
                GameNetSystem.Instance.SendInfo(pak);
                model.PlayHammerAudio();
            }
            lockGodWeaponUpdate = true;
            lockItemUpdate = true;
            autoHammerState = AutoHammerState.WaitServer;
        }

        private void DisplayAutoHammerLabel()
        {
            switch (autoHammerState)
            {
                case AutoHammerState.None:
                    m_AutoHammerLabel.text = Language.Get("AutoHammerBtnTxt");
                    break;
                case AutoHammerState.Hammer:
                case AutoHammerState.WaitAnimation:
                case AutoHammerState.WaitServer:
                    m_AutoHammerLabel.text = Language.Get("CancelAutoHammerBtnTxt");
                    break;
            }
        }

        private void OnExitAutoHammer()
        {
            if (m_LastAutoHammerState != AutoHammerState.None)
            {
                DisplayExp(true);
                if (moneyHammer)
                {
                    ScrollTip.Close();
                }
            }
        }

        private void OnWaitServer()
        {
            waitServerTimer = 0f;
        }

        private void Preview()
        {
        }

        bool ExistAnyHammerItem(int type, out int index)
        {
            var items = model.GetLevelUpItemByType(type);
            index = 0;
            for (int i = items.Length - 1; i >= 0; i--)
            {
                var count = packModel.GetItemCountByID(PackType.Item, items[i]);
                if (count > 0)
                {
                    index = i;
                    return true;
                }
            }
            return false;
        }

        private void OnRule()
        {
            var ruleId = 0;
            switch (model.selectType)
            {
                case 1:
                    ruleId = 33;
                    break;
                case 2:
                    ruleId = 34;
                    break;
                case 3:
                    ruleId = 35;
                    break;
                case 4:
                    ruleId = 36;
                    break;
            }
            if (ruleId != 0)
            {
                ModelCenter.Instance.GetModel<HowToPlayModel>().ruleId = ruleId;
                WindowCenter.Instance.Open<HowToPlayWin>();
            }
        }

        bool HandleAchievement()
        {
            if (AchievementGoto.achievementType == AchievementGoto.GodWeapon)
            {
                var config = SuccessConfig.Get(AchievementGoto.guideAchievementId);
                if (config != null)
                {
                    var type = config.Condition[0];
                    if (model.GetRedpointLightByType(type))
                    {
                        model.selectType = type;
                        var effect = AchievementGuideEffectPool.Require(1);
                        effect.transform.SetParentEx(m_Hammer.transform, Vector3.zero, Vector3.zero, Vector3.one);
                        return true;
                    }
                    else
                    {
                        SysNotifyMgr.Instance.ShowTip("Achievement_8");
                    }
                }
            }
            return false;
        }



        enum AutoHammerState
        {
            None,
            Hammer,
            WaitAnimation,
            WaitServer,
        }
    }
}