//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Saturday, October 14, 2017
//--------------------------------------------------------

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

namespace Snxxz.UI {

    public class RealmPracticeWin : Window
    {
        private ScrollerController _practiceTypeCtrl;
        private ScrollerController _taskTypeCtrl;
        private Text _curPracticePointText;
        private Text _nextRealmPointText;
        private RealmConfig _tagRealmModel;
        RealmPracticeModel practiceModel { get { return ModelCenter.Instance.GetModel<RealmPracticeModel>(); } }
        Dictionary<int, Dictionary<int, List<RealmPracticeConfig>>> realmPraDict;
        private int selectFirstType = 0;
        private int selectSecondType = 0;
        private bool isOpen = true;
        #region Built-in
        protected override void BindController()
        {
            _practiceTypeCtrl = transform.Find("PracticeTypeCtrl").GetComponent<ScrollerController>();
            _taskTypeCtrl = transform.Find("TaskTypeCtrl").GetComponent<ScrollerController>();
            _curPracticePointText = transform.Find("NowNumImg/PointValue").GetComponent<Text>();
            _nextRealmPointText = transform.Find("NowNumImg/PointValue/TipsText").GetComponent<Text>();
            _taskTypeCtrl.lockType = EnhanceLockType.KeepVertical;
          
        }

        protected override void AddListeners()
        {
          
        }

        protected override void OnPreOpen()
        {
            isOpen = true;
            _practiceTypeCtrl.OnRefreshCell += RefreshPracticeTypeCell;
            _taskTypeCtrl.OnRefreshCell += RefreshTaskTypeCell;
            practiceModel.AchieveModel.achievementAwardableEvent += RefreshIsReach;
            practiceModel.AchieveModel.achievementCompletedEvent += RefreshComplete;
            PlayerDatas.Instance.PlayerDataRefreshInfoEvent += RefreshRealmPoint;
            realmPraDict = practiceModel.GetAllOpenRealmPra();
            if(realmPraDict.Count > 0)
            {
                selectFirstType = realmPraDict.Keys.ToList()[0];
            }
            if (AchievementGoto.guideAchievementId != 0)
            {
                SuccessConfig config = Config.Instance.Get<SuccessConfig>(AchievementGoto.guideAchievementId);
                if (config.Type == 114)
                {
                    bool isAchieveReach = false;
                    foreach(var first in practiceModel.realmFirstTypeDict.Keys)
                    {
                        if(practiceModel.realmFirstTypeDict[first].state == RedPointState.Simple)
                        {
                            isAchieveReach = true;
                            selectFirstType = first;
                        }

                        foreach(var second in practiceModel.realmSecondTypeDict[first].Keys)
                        {
                            if(practiceModel.realmSecondTypeDict[first][second].state == RedPointState.Simple)
                            {
                                selectSecondType = second;
                                break;
                            }
                        }

                        if(isAchieveReach)
                        {
                            break;
                        }
                    }

                    if(!isAchieveReach)
                    {
                        MessageWin.Inst.ShowFixedTip(Language.Get("RealmWin_Practice_1"));
                    }
                    AchievementGoto.guideAchievementId = 0;
                }
            }

            InitUI();
        }

        protected override void OnAfterOpen()
        {
            _taskTypeCtrl.vertical = true;
            _practiceTypeCtrl.mScrollRect.verticalNormalizedPosition = 1;
            _taskTypeCtrl.mScrollRect.verticalNormalizedPosition = 1;
        }

        protected override void OnPreClose()
        {
        }

        protected override void OnAfterClose()
        {
            _practiceTypeCtrl.OnRefreshCell -= RefreshPracticeTypeCell;
            PlayerDatas.Instance.PlayerDataRefreshInfoEvent -= RefreshRealmPoint;
            _taskTypeCtrl.OnRefreshCell -= RefreshTaskTypeCell;
            practiceModel.AchieveModel.achievementCompletedEvent -= RefreshComplete;
            practiceModel.AchieveModel.achievementAwardableEvent -= RefreshIsReach;
        }
        #endregion

        public void InitUI()
        {
            OnClickFirstTypeCell(selectFirstType);
            RefreshUI();
            isOpen = false;
        }


        private void RefreshComplete(int id)
        {
            SuccessConfig successConfig = Config.Instance.Get<SuccessConfig>(id);
            RealmPracticeConfig practiceConfig = Config.Instance.Get<RealmPracticeConfig>(successConfig.RealmPracticeID);
          
            if (practiceConfig != null && PracticeModellist != null)
            {
               if(PracticeModellist.Contains(practiceConfig))
                {
                    PracticeModellist = practiceModel.GetRealmPracticelist(selectFirstType,selectSecondType);
                    _practiceTypeCtrl.m_Scorller.RefreshActiveCellViews();
                    _taskTypeCtrl.m_Scorller.RefreshActiveCellViews();
                }
            }
        }

        private void RefreshIsReach(int id)
        {
            SuccessConfig successConfig = Config.Instance.Get<SuccessConfig>(id);
            RealmPracticeConfig practiceConfig = Config.Instance.Get<RealmPracticeConfig>(successConfig.RealmPracticeID);
          
            if (practiceConfig != null && PracticeModellist != null)
            {
                if (PracticeModellist.Contains(practiceConfig))
                {
                    PracticeModellist = practiceModel.GetRealmPracticelist(selectFirstType, selectSecondType);
                    _practiceTypeCtrl.m_Scorller.RefreshActiveCellViews();
                    _taskTypeCtrl.m_Scorller.RefreshActiveCellViews();
                }
            }
        }

        private void RefreshRealmPoint(PlayerDataRefresh type)
        {
            if (type != PlayerDataRefresh.RealmPoint) return;

            RefreshUI();
        }

        public void RefreshUI()
        {
            _curPracticePointText.text = UIHelper.ReplaceLargeNum(PlayerDatas.Instance.extersion.realmPoint);
            _tagRealmModel = Config.Instance.Get<RealmConfig>(PlayerDatas.Instance.baseData.realmLevel);
            if (_tagRealmModel != null)
            {
                _nextRealmPointText.text = Language.Get("RealmPractice101").Replace("{0}",UIHelper.ReplaceLargeNum(_tagRealmModel.NeedPoint));
            }
        }

        private void CreatePracticeTypeCell()
        {
            _practiceTypeCtrl.Refresh();
            foreach (var first in realmPraDict.Keys)
            {
                _practiceTypeCtrl.AddCell(ScrollerDataType.Header, first);
                if (selectFirstType == first && !isDoubleClick)
                {
                    foreach (var second in realmPraDict[first].Keys)
                    {
                        if (second != 0)
                        {
                            _practiceTypeCtrl.AddCell(ScrollerDataType.Normal, second);
                        }
                    }
                }
            }
            _practiceTypeCtrl.Restart();
            DebugEx.Log("Cell数量" + _practiceTypeCtrl.GetNumberOfCells(_practiceTypeCtrl.m_Scorller));
            if (_practiceTypeCtrl.GetNumberOfCells(_practiceTypeCtrl.m_Scorller) < _practiceTypeCtrl.maxCellCnt)
            {
                _practiceTypeCtrl.mScrollRect.vertical = false;
            }
            else
            {
                _practiceTypeCtrl.mScrollRect.vertical = true;
            }
        }

        private void RefreshPracticeTypeCell(ScrollerDataType type, CellView cell)
        {
            switch (type)
            {
                case ScrollerDataType.Header:
                    PracticeTypeCell firstType = cell.GetComponent<PracticeTypeCell>();
                    firstType.Init(cell.index,selectFirstType,isDoubleClick);
                    firstType.cellBtn.RemoveAllListeners();
                    firstType.cellBtn.AddListener(() => { OnClickFirstTypeCell(cell.index); });
                    break;
                case ScrollerDataType.Normal:
                    SecondPraTypeCell secondType = cell.GetComponent<SecondPraTypeCell>();
                    secondType.Init(selectFirstType,cell.index,selectSecondType);
                    secondType.cellBtn.RemoveAllListeners();
                    secondType.cellBtn.AddListener(() => { OnClickSecondTypeCell(cell.index); });
                    break;
            }  
        }

        private bool isDoubleClick = false;
        private void OnClickFirstTypeCell(int firstType)
        {
            if (!isOpen)
            {
                if (selectFirstType == firstType)
                {
                    if(!isDoubleClick)
                    {
                        isDoubleClick = true;
                    }
                    else
                    {
                        isDoubleClick = false;
                    }
                    CreatePracticeTypeCell();
                    if (!realmPraDict[firstType].ContainsKey(selectSecondType))
                    {
                        selectSecondType = realmPraDict[firstType].Keys.ToList()[0];
                    }
                    CreateTaskTypeCell();
                    return;
                }
              
            }
            isDoubleClick = false;
            selectFirstType = firstType;
            selectSecondType = realmPraDict[firstType].Keys.ToList()[0];
            CreatePracticeTypeCell();
            CreateTaskTypeCell();
        }

        private void OnClickSecondTypeCell(int secondType)
        {
            selectSecondType = secondType;
            _practiceTypeCtrl.m_Scorller.RefreshActiveCellViews();
            CreateTaskTypeCell();
        }

        private List<RealmPracticeConfig> PracticeModellist;
        private void CreateTaskTypeCell()
        {
            _taskTypeCtrl.Refresh();
            PracticeModellist = practiceModel.GetRealmPracticelist(selectFirstType,selectSecondType);
            for (int i = 0; i < PracticeModellist.Count; i++)
            {
                _taskTypeCtrl.AddCell(ScrollerDataType.Header, i);

            }
            _taskTypeCtrl.Restart();
            if (PracticeModellist.Count < _taskTypeCtrl.maxCellCnt)
                _taskTypeCtrl.mScrollRect.vertical = false;

        }

        private void RefreshTaskTypeCell(ScrollerDataType type, CellView cell)
        {
            TaskTypeCell taskTypeCell = cell.GetComponent<TaskTypeCell>();
            taskTypeCell.InitModel(PracticeModellist[cell.index]);
        }

        private void OnClickReceiveReward(int id)
        {
           
            practiceModel.AchieveModel.GetAchievementReward(id);
        }
    }

}