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

namespace Snxxz.UI
{
    public class FairyTreasureCollectPanelPattern5 : FairyTreasureCollect
    {
        [SerializeField] RectTransform m_ContainerAchievement;
        [SerializeField] ScrollRect m_AchievementScroller;
        [SerializeField] FurnacesAchievement[] m_FurnacesAchievements;
        [SerializeField] Button m_AchievementGetBtn;
        [SerializeField] RectTransform m_ContainerHoles;
        [SerializeField] Image[] m_FurnacesIcons;
        [SerializeField] RectTransform m_ContainerFunc;
        [SerializeField] Image m_FuncIcon;
        [SerializeField] Text m_FuncTitle;
        [SerializeField] RectTransform m_ContainerFurnace;
        [SerializeField] Text m_FurnaceLv;
        [SerializeField] Slider m_StoveSlider;
        [SerializeField] Text m_Progress;
        [SerializeField] RectTransform m_CurrentProperty;
        [SerializeField] Text[] m_CurrentPropertyNames;
        [SerializeField] Text[] m_CurrentPropertyValues;
        [SerializeField] RectTransform m_NextProperty;
        [SerializeField] Text[] m_NextPropertyNames;
        [SerializeField] Text[] m_NextPropertyValues;
        [SerializeField] RectTransform m_MaxLevelContainer;

        [SerializeField] PositionTween m_AchievementTween;
        [SerializeField] PositionTween m_FurnaceTween;
        [SerializeField] PositionTween m_FuncTween;

        [SerializeField] Button m_GotoStove;

        BlastFurnaceModel blastFurnaceModel { get { return ModelCenter.Instance.GetModel<BlastFurnaceModel>(); } }

        AchievementModel achievementModel
        {
            get
            {
                return ModelCenter.Instance.GetModel<AchievementModel>();
            }
        }

        PlayerTaskDatas task { get { return ModelCenter.Instance.GetModel<PlayerTaskDatas>(); } }

        Achievement currentAchievement;

        int completedAchivement = 0;

        protected override void Awake()
        {
            m_AchievementGetBtn.onClick.AddListener(OnAchievementGet);
            m_GotoStove.onClick.AddListener(GotoStove);
        }

        public override void Display(int _treasureId, bool _tween = false)
        {
            m_GotoGet.onClick.RemoveAllListeners();
            m_GotoGet.onClick.AddListener(GotoGet);

            model.TryGetTreasure(_treasureId, out treasure);

            m_ContainerFight.gameObject.SetActive(false);

            m_GotoBtnText.text = Language.Get("GotoComplete");

            var config = ConfigManager.Instance.GetTemplate<TreasureConfig>(_treasureId);

            m_TreasureStory.text = config.Story;
            Display();
            DisplayProgress();
            DisplayFurnacesHole();
            DisplayFurnace();
            DisplayFunc();
            achievementModel.achievementCompletedEvent += AchievementCompletedEvent;

            completedAchivement = 0;

            if (_tween)
            {
                if (m_AchievementTween.gameObject.activeInHierarchy)
                {
                    m_AchievementTween.Play();
                }
                if (m_FurnaceTween.gameObject.activeInHierarchy)
                {
                    m_FurnaceTween.Play();
                }
                m_FuncTween.Play();
                m_StoryTween.Play();
            }
            else
            {
                m_AchievementTween.SetEndState();
                m_FurnaceTween.SetEndState();
                m_FuncTween.SetEndState();
                m_StoryTween.SetEndState();
            }
        }

        protected override void GotoGet()
        {
            achievementModel.GotoCompleteAchievement(currentAchievement.id);
        }

        public override void Dispose()
        {
            m_GotoGet.onClick.RemoveAllListeners();
            achievementModel.achievementCompletedEvent -= AchievementCompletedEvent;
            for (int i = 0; i < m_FurnacesAchievements.Length; i++)
            {
                m_FurnacesAchievements[i].Dispose();
            }
        }

        private void AchievementCompletedEvent(int _id)
        {
            if (model.GetFurnacesAchievements().Contains(_id))
            {
                Display();
                DisplayFurnacesHole();
            }
        }

        private void DisplayProgress()
        {
            m_ContainerAchievement.gameObject.SetActive(treasure.state == TreasureState.Collected && treasure.stage <= 0);
            var _processingIndex = -1;
            if (treasure.state == TreasureState.Collected && treasure.stage <= 0)
            {
                var _list = model.GetFurnacesAchievements();
                for (int i = 0; i < m_FurnacesAchievements.Length; i++)
                {
                    var _beforeId = i == 0 ? 0 : _list[i - 1];
                    Achievement _beforeAchievement;
                    bool _beforeComplete = true;
                    if (achievementModel.TryGetAchievement(_beforeId, out _beforeAchievement))
                    {
                        _beforeComplete = _beforeAchievement.completed;
                    }
                    Achievement achievement;
                    achievementModel.TryGetAchievement(_list[i], out achievement);
                    var config = ConfigManager.Instance.GetTemplate<SuccessConfig>(_list[i]);
                    var _processing = !achievement.completed &&  _beforeComplete;
                    if ((_processing || Achievement.IsReach(achievement.id, achievement.progress)) && _processingIndex == -1)
                    {
                        _processingIndex = i;
                    }
                    m_FurnacesAchievements[i].Display(_list[i]);
                }
            }
            if (_processingIndex != -1)
            {
                var _position = (m_FurnacesAchievements.Length - _processingIndex) * 145.5f;
                var _height = (m_AchievementScroller.transform as RectTransform).rect.height;
                _position -= _height;
                m_AchievementScroller.verticalNormalizedPosition = Mathf.Clamp01(_position / (m_AchievementScroller.content.rect.height - _height));
            }
        }

        private void DisplayFurnacesHole()
        {
            m_ContainerHoles.gameObject.SetActive(treasure.state == TreasureState.Collected);
            if (treasure.state == TreasureState.Collected)
            {
                var _list = model.GetFurnacesAchievements();
                for (int i = 0; i < m_FurnacesIcons.Length; i++)
                {
                    Achievement achievement;
                    achievementModel.TryGetAchievement(_list[i], out achievement);
                    if (achievement != null && achievement.id == completedAchivement)
                    {
                        completedAchivement = 0;
                        if (achievement.completed)
                        {
                            var _effect = EffectMgr.Instance.PlayUIEffect(5161, 2700, m_FurnacesIcons[i].transform.parent, false);
                            if (_effect != null)
                            {
                                var _index = i;
                                if (_index == m_FurnacesIcons.Length - 1)
                                {
                                    model.treasureStepUpShow = true;
                                }
                                _effect.OnComplete = () =>
                                {
                                    _effect.OnComplete = null;
                                    m_FurnacesIcons[_index].gameObject.SetActive(true);
                                    if (_index == m_FurnacesIcons.Length - 1)
                                    {
                                        TreasureActiveEffect();
                                    }
                                };
                            }
                            continue;
                        }
                    }
                    m_FurnacesIcons[i].gameObject.SetActive(achievement != null && achievement.completed);
                }
            }
            else
            {
                for (int i = 0; i < m_FurnacesIcons.Length; i++)
                {
                    m_FurnacesIcons[i].gameObject.SetActive(true);
                }
            }
        }

        private void TreasureActiveEffect()
        {
            var _effect = EffectMgr.Instance.PlayUIEffect(5160, 2700, this.transform, false);
            if (_effect != null)
            {
                _effect.OnComplete = () =>
                {
                    _effect.OnComplete = null;
                    StartCoroutine(Co_Fly());
                };
            }
            else
            {
                model.treasureStepUpShow = false;
            }
        }

        IEnumerator Co_Fly()
        {
            yield return WaitingForSecondConst.WaitMS300;
            model.treasureStepUpShow = false;
            BeginFly();
        }

        private void BeginFly()
        {
            CameraUtility.ScreenShotCut((Texture2D _tex) =>
            {
                TreasureStageUpTriggerWin.screenShotCut = _tex;
                WindowCenter.Instance.CloseImmediately<TreasureLevelUpWin>();
                WindowCenter.Instance.Open<TreasureStageUpTriggerWin>(true);
                WindowCenter.Instance.Open<MainInterfaceWin>();
                if (WindowCenter.Instance.CheckOpen<DialogueDuidanceWin>())
                {
                    WindowCenter.Instance.CloseImmediately<DialogueDuidanceWin>();
                }
                if (WindowCenter.Instance.CheckOpen<TaskBoxBGMWin>())
                {
                    WindowCenter.Instance.CloseImmediately<TaskBoxBGMWin>();
                }
            });
        }
        
        private void Display()
        {
            GetCurrentAchievement();
            if (treasure.state != TreasureState.Collected)
            {
                int unlocktreasureId = 0;
                var list = model.GetTreasureCategory(TreasureCategory.Human);
                for (int i = 0; i < list.Count; i++)
                {
                    Treasure _treasure;
                    if(model.TryGetTreasure(list[i], out _treasure))
                    {
                        var index = _treasure.treasureStages.FindIndex((x) =>
                        {
                            return x.unlockType == TreasureStageUnlock.Treasure && x.treasure == treasure.id;
                        });
                        if (index != -1)
                        {
                            unlocktreasureId = list[i];
                            break;
                        }
                    }
                }

                var unlockTreasureConfig = ConfigManager.Instance.GetTemplate<TreasureConfig>(unlocktreasureId);

                m_AchievementGetBtn.gameObject.SetActive(false);
                m_GotoGet.gameObject.SetActive(false);
                m_ContainerLocked.gameObject.SetActive(true);
                m_LockedDescription.text = Language.Get("BlastFurnaceGet", unlockTreasureConfig == null ? string.Empty : unlockTreasureConfig.Name);
                m_ContainerAchievement.gameObject.SetActive(false);
            }
            else if (currentAchievement == null || treasure.stage >= 1)
            {
                m_AchievementGetBtn.gameObject.SetActive(false);
                m_GotoGet.gameObject.SetActive(false);
                m_ContainerLocked.gameObject.SetActive(false);
            }
            else
            {
                m_ContainerLocked.gameObject.SetActive(false);
                var _isReach = Achievement.IsReach(currentAchievement.id, currentAchievement.progress);
                m_AchievementGetBtn.gameObject.SetActive(_isReach);
                var _list = model.GetFurnacesAchievements();
                m_GotoGet.gameObject.SetActive(!_isReach);
            }

            m_GotoStove.gameObject.SetActive(treasure.stage >= 1);
        }

        private void OnAchievementGet()
        {
            if (Achievement.IsReach(currentAchievement.id, currentAchievement.progress))
            {
                completedAchivement = currentAchievement.id;
                achievementModel.GetAchievementReward(currentAchievement.id);
            }
        }

        private void DisplayFunc()
        {
            m_FuncTitle.text = treasure.state == TreasureState.Collected && treasure.stage >= 1 ? Language.Get("FairyTreasureOpenFunc") : Language.Get("FairyTreasureUnOpenFunc");
            var funcStage = treasure.treasureStages.Find((x) =>
            {
                return x.unlockType == TreasureStageUnlock.Func;
            });
            var config = ConfigManager.Instance.GetTemplate<FuncOpenLVConfig>(funcStage.func);
            if (config != null)
            {
                m_FuncIcon.SetSprite(config.Icon);
            }
        }

        private void DisplayFurnace()
        {
            m_ContainerFurnace.gameObject.SetActive(treasure.state == TreasureState.Collected && treasure.stage >= 1);
            if (treasure.state == TreasureState.Collected && treasure.stage >= 1)
            {
                var stoveLevel = blastFurnaceModel.StoveLV;
                m_FurnaceLv.text = Language.Get("BlastFurnace101", stoveLevel);
                var configNow = ConfigManager.Instance.GetTemplate<RefineStoveConfig>(stoveLevel);
                var min = Mathf.Min(m_CurrentPropertyNames.Length, m_CurrentPropertyValues.Length);
                for (int i = 0; i < min; i++)
                {
                    if (i < configNow.AttrID.Length)
                    {
                        m_CurrentPropertyNames[i].gameObject.SetActive(true);
                        m_CurrentPropertyValues[i].gameObject.SetActive(true);

                        var propertyId = configNow.AttrID[i];
                        var propertyConfig = ConfigManager.Instance.GetTemplate<PlayerPropertyConfig>(propertyId);
                        m_CurrentPropertyNames[i].text = propertyConfig.Name;
                        m_CurrentPropertyValues[i].text = StringUtility.Contact("+", configNow.AttrValue[i]);
                    }
                    else
                    {
                        m_CurrentPropertyNames[i].gameObject.SetActive(false);
                        m_CurrentPropertyValues[i].gameObject.SetActive(false);
                    }
                }

                var configNext = ConfigManager.Instance.GetTemplate<RefineStoveConfig>(stoveLevel + 1);
                var isMax = configNext==null;
                m_NextProperty.gameObject.SetActive(!isMax);
                m_MaxLevelContainer.gameObject.SetActive(isMax);

                if (!isMax)
                {
                    var min1 = Mathf.Min(m_NextPropertyNames.Length, m_NextPropertyValues.Length);
                    for (int i = 0; i < min1; i++)
                    {
                        if (i < configNext.AttrID.Length)
                        {
                            m_NextPropertyNames[i].gameObject.SetActive(true);
                            m_NextPropertyValues[i].gameObject.SetActive(true);

                            var propertyId = configNext.AttrID[i];
                            var propertyConfig = ConfigManager.Instance.GetTemplate<PlayerPropertyConfig>(propertyId);
                            m_NextPropertyNames[i].text = propertyConfig.Name;
                            m_NextPropertyValues[i].text = StringUtility.Contact("+", configNext.AttrValue[i]);
                        }
                        else
                        {
                            m_NextPropertyNames[i].gameObject.SetActive(false);
                            m_NextPropertyValues[i].gameObject.SetActive(false);
                        }
                    }
                }

                m_StoveSlider.minValue = 0;
                if (blastFurnaceModel.GetBlastFurnaceUpgradExp() <= 0)
                {
                    m_StoveSlider.maxValue = 1;
                    m_StoveSlider.value = 1;
                }
                else
                {
                    m_StoveSlider.maxValue = blastFurnaceModel.GetBlastFurnaceUpgradExp();
                    m_StoveSlider.value = blastFurnaceModel.StoveExp;
                }

                if (!blastFurnaceModel.IsReachMaxStoveLv())
                {
                    m_Progress.text = blastFurnaceModel.StoveExp + "/" + blastFurnaceModel.GetBlastFurnaceUpgradExp();
                }
                else
                {
                    m_Progress.text = Language.Get("L1055");
                }
            }
        }

        private void GotoStove()
        {
            WindowCenter.Instance.CloseImmediately<TreasureLevelUpWin>();
            WindowCenter.Instance.Close<MainInterfaceWin>();
            WindowCenter.Instance.Open<BlastFurnaceWin>();
        }


        private void GetCurrentAchievement()
        {
            currentAchievement = null;
            var _list = model.GetFurnacesAchievements();
            for (int i = 0; i < _list.Count; i++)
            {
                Achievement _achievement;
                achievementModel.TryGetAchievement(_list[i], out _achievement);
                if (_achievement == null)
                {
                    continue;
                }
                if (_achievement.completed)
                {
                    continue;
                }
                else
                {
                    currentAchievement = _achievement;
                    break;
                }
            }
        }
    }
}