//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Monday, October 16, 2017
//--------------------------------------------------------

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

namespace Snxxz.UI
{

    public class TeamTargetJoinLimitWin : Window
    {
        [SerializeField] Image m_MinLevelSign;
        [SerializeField] Text m_MinLevel;
        [SerializeField] RepeatedButton m_ReduceMinLevel;
        [SerializeField] RepeatedButton m_AddMinLevel;
        [SerializeField] Button m_AmendMinLevel;
        [SerializeField] Image m_MaxLevelSign;
        [SerializeField] Text m_MaxLevel;
        [SerializeField] RepeatedButton m_ReduceMaxLevel;
        [SerializeField] RepeatedButton m_AddMaxLevel;
        [SerializeField] Button m_AmendMaxLevel;
        [SerializeField] Transform m_ContainerNumKeyBoard;
        [SerializeField] NumKeyBoard m_NumKeyBoard;
        [SerializeField] TeamMissionGroup m_MissionList;
        [SerializeField] Button m_Confirm;
        [SerializeField] Text m_ActivityTime;
        [SerializeField] Button m_Close;

        TeamModel model { get { return ModelCenter.Instance.GetModel<TeamModel>(); } }
        DungeonModel dungeonModel { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } }

        TeamMission missionBuf;
        int minLevelBuf = 0;
        int maxLevelBuf = 0;
        AmendLevelType amendType = AmendLevelType.Min;

        int minLevelLimit = 1;
        int maxLevelLimit = 500;

        #region Built-in
        protected override void BindController()
        {
        }

        protected override void AddListeners()
        {
            m_Close.AddListener(CloseClick);
            m_ReduceMinLevel.AddListener(ReduceMinLevel);
            m_AddMinLevel.AddListener(AddMinLevel);
            m_ReduceMaxLevel.AddListener(ReduceMaxLevel);
            m_AddMaxLevel.AddListener(AddMaxLevel);
            m_AmendMinLevel.AddListener(AmendMinLevel);
            m_AmendMaxLevel.AddListener(AmendMaxLevel);
            m_Confirm.AddListener(ConfirmTargetAndLimit);
            m_NumKeyBoard.onConfirm.AddListener(OnNumKeyBoardSubmit);
        }

        protected override void OnPreOpen()
        {
            missionBuf = model.missionBuf;
            RefreshTeammission(missionBuf.mapId, missionBuf.mapEx);
            m_ContainerNumKeyBoard.gameObject.SetActive(false);
            m_MissionList.Init();
            m_MissionList.OnMissionSelected(RefreshTeammission);
        }

        protected override void OnAfterOpen()
        {
        }

        protected override void OnPreClose()
        {
            m_MissionList.OnMissionSelected(null);
        }

        protected override void OnAfterClose()
        {
        }
        #endregion

        private void RefreshTeammission(int _mapId, int _mapEx)
        {
            missionBuf = new TeamMission(_mapId, _mapEx);

            var mapId = _mapId == TeamModel.NONE_MISSION ? 0 : _mapId == TeamModel.CURRENTMAP_MISSION ? PlayerDatas.Instance.baseData.MapID : _mapId;
            var mapEx = _mapEx <= 0 ? 0 : _mapEx;
            var dungeonId = dungeonModel.DungeonMap(mapId, mapEx);

            if (mapId == 0)
            {
                minLevelBuf = 1;
                maxLevelBuf = GeneralConfig.Instance.playerMaxLevel;
                minLevelLimit = 1;
                maxLevelLimit = GeneralConfig.Instance.playerMaxLevel;
            }
            else if (dungeonId != 0)
            {
                var dungeonConfig = Config.Instance.Get<DungeonConfig>(dungeonId);
                if (model.targetPreferences.ContainsKey(dungeonId))
                {
                    var target = model.targetPreferences[dungeonId];
                    minLevelBuf = target.minLevel;
                    maxLevelBuf = target.maxLevel;
                }
                else
                {
                    minLevelBuf = dungeonConfig.LVLimitMin;
                    maxLevelBuf = dungeonConfig.LVLimitMax;
                }

                minLevelLimit = dungeonConfig.LVLimitMin;
                maxLevelLimit = dungeonConfig.LVLimitMax;
            }
            else
            {
                var key = mapId * 100 + mapEx;
                if (model.targetPreferences.ContainsKey(key))
                {
                    var target = model.targetPreferences[key];
                    minLevelBuf = target.minLevel;
                    maxLevelBuf = target.maxLevel;
                }
                else
                {
                    minLevelBuf = 1;
                    maxLevelBuf = GeneralConfig.Instance.playerMaxLevel;
                }

                minLevelLimit = 1;
                maxLevelLimit = GeneralConfig.Instance.playerMaxLevel;
            }

            UpdateMinLevelContent();
            UpdateMaxLevelContent();
            UpdateActivityTime();
        }

        private void ReduceMinLevel()
        {
            minLevelBuf = Mathf.Clamp(minLevelBuf - 1, minLevelLimit, maxLevelBuf);
            UpdateMinLevelContent();
        }

        private void AddMinLevel()
        {
            minLevelBuf = Mathf.Clamp(minLevelBuf + 1, minLevelLimit, maxLevelBuf);
            UpdateMinLevelContent();
        }

        private void AmendMinLevel()
        {
            amendType = AmendLevelType.Min;
            m_ContainerNumKeyBoard.gameObject.SetActive(true);
            m_NumKeyBoard.Value = minLevelBuf.ToString();
            m_NumKeyBoard.min = (uint)minLevelLimit;
            m_NumKeyBoard.max = (uint)maxLevelBuf;
        }

        private void ReduceMaxLevel()
        {
            maxLevelBuf = Mathf.Clamp(maxLevelBuf - 1, minLevelBuf, maxLevelLimit);
            UpdateMaxLevelContent();
        }

        private void AddMaxLevel()
        {
            maxLevelBuf = Mathf.Clamp(maxLevelBuf + 1, minLevelBuf, maxLevelLimit);
            UpdateMaxLevelContent();
        }

        private void AmendMaxLevel()
        {
            amendType = AmendLevelType.Max;
            m_ContainerNumKeyBoard.gameObject.SetActive(true);
            m_NumKeyBoard.Value = maxLevelBuf.ToString();
            m_NumKeyBoard.min = (uint)minLevelBuf;
            m_NumKeyBoard.max = (uint)maxLevelLimit;
        }

        private void ConfirmTargetAndLimit()
        {
            var mapId = missionBuf.mapId == TeamModel.NONE_MISSION ? 0 :
                missionBuf.mapId == TeamModel.CURRENTMAP_MISSION ? PlayerDatas.Instance.baseData.MapID : missionBuf.mapId;
            var mapEx = missionBuf.mapEx <= 0 ? 0 : missionBuf.mapEx;

            if (mapId == 31110)
            {
                var config = Config.Instance.Get<RealmConfig>(PlayerDatas.Instance.baseData.realmLevel);
                if (config.IsBigRealm != 1 || !ModelCenter.Instance.GetModel<RealmModel>().IsDungeonState)
                {
                    SysNotifyMgr.Instance.ShowTip("NOGreatBourn");
                    return;
                }
            }

            var key = dungeonModel.DungeonMap(mapId, mapEx);

            if (key == 0)
            {
                key = missionBuf.mapId * 100 + missionBuf.mapEx;
            }

            model.targetPreferences[key] = new TeamTargetPreference(minLevelBuf, maxLevelBuf);

            if (model.myTeam.inTeam)
            {
                model.RequestAmendTeamInfo(missionBuf, minLevelBuf, maxLevelBuf);
            }
            else
            {
                model.levelMinBuf = minLevelBuf;
                model.levelMaxBuf = maxLevelBuf;
                model.missionBuf = missionBuf;
            }

            CloseClick();
        }

        private void UpdateMinLevelContent()
        {
            m_MinLevelSign.gameObject.SetActive(minLevelBuf != 0);
            m_MinLevel.gameObject.SetActive(minLevelBuf != 0);
            if (minLevelBuf != 0)
            {
                var isMinPickLevel = minLevelBuf >= GeneralConfig.Instance.greatMasterStartLV;
                m_MinLevelSign.gameObject.SetActive(isMinPickLevel);
                m_MinLevel.text = (isMinPickLevel ? (minLevelBuf - GeneralConfig.Instance.greatMasterStartLV) : minLevelBuf).ToString();
            }
        }

        private void UpdateMaxLevelContent()
        {
            m_MaxLevelSign.gameObject.SetActive(maxLevelBuf != 0);
            m_MaxLevel.gameObject.SetActive(maxLevelBuf != 0);

            if (maxLevelBuf != 0)
            {
                var isMaxPickLevel = maxLevelBuf >= GeneralConfig.Instance.greatMasterStartLV;
                m_MaxLevelSign.gameObject.SetActive(isMaxPickLevel);
                m_MaxLevel.text = (isMaxPickLevel ? (maxLevelBuf - GeneralConfig.Instance.greatMasterStartLV) : maxLevelBuf).ToString();
            }
        }

        private void OnNumKeyBoardSubmit(bool _value)
        {
            if (_value)
            {
                switch (amendType)
                {
                    case AmendLevelType.Min:
                        minLevelBuf = Mathf.Clamp(int.Parse(m_NumKeyBoard.Value), 1, maxLevelBuf);
                        UpdateMinLevelContent();
                        break;
                    case AmendLevelType.Max:
                        maxLevelBuf = Mathf.Clamp(int.Parse(m_NumKeyBoard.Value), minLevelBuf, GeneralConfig.Instance.playerMaxLevel);
                        UpdateMaxLevelContent();
                        break;
                }

                m_ContainerNumKeyBoard.gameObject.SetActive(false);
            }
        }

        private void UpdateActivityTime()
        {
            DailyQuestOpenTime openTime;
            if (dungeonModel.TryGetOpenTime(missionBuf.mapId, out openTime))
            {
                if (openTime.always)
                {
                    m_ActivityTime.text = Language.Get("DailyQuest_NoTimeLimit");
                }
                else
                {
                    var week = DateTime.Now.DayOfWeek;
                    if (openTime.openTimes.ContainsKey((int)week))
                    {
                        var durations = openTime.openTimes[(int)week];
                        var stringArray = new string[durations.Count];
                        for (int i = 0; i < durations.Count; i++)
                        {
                            stringArray[i] = durations[i].ToString();
                        }
                        m_ActivityTime.text = string.Join(",", stringArray);
                    }
                }
            }
            else
            {
                m_ActivityTime.text = Language.Get("DailyQuest_NoTimeLimit");
            }
        }

        enum AmendLevelType
        {
            Min,
            Max,
        }

    }

}