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

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


namespace vnxbqy.UI
{

    public class MyTeamWin : Window, SecondWindowInterface
    {
        [Header("Middle"), SerializeField] Transform m_ContainerMates;
        [SerializeField] Transform m_ContainerEmpty;
        [SerializeField] Transform m_CaptainerSign;
        [SerializeField] MyTeammateBehaviour[] m_TeammateBehaviours;

        [Header("Bottom"), SerializeField] Transform m_ContainerTeamExperience;
        [SerializeField] Transform m_ContainerAutoInvitation;
        [SerializeField] TeammateNearByBehaviour[] m_TeamateSigns;
        [SerializeField] Text m_ExperienceAddition;
        [SerializeField] Button m_CreateTeam;
        [SerializeField] Button m_AutoFind;
        [SerializeField] Text m_MatchState;
        [SerializeField] TimerBehaviour m_MatchingCoolDown;
        [SerializeField] Button m_ChallengeDungeon;
        [SerializeField] RectTransform m_AutoPrepareContainer;
        [SerializeField] Button m_AutoPrepareSetting;
        [SerializeField] Button m_CancelAutoPrepare;
        [SerializeField] Toggle m_AutoAcceptInvitation;

        [Header("Left"), SerializeField] Text m_Mission;
        [SerializeField] RectTransform m_ContainerTeamLevel;
        [SerializeField] Image m_LevelMinSign;
        [SerializeField] Text m_LevelMin;
        [SerializeField] Image m_LevelMaxSign;
        [SerializeField] Text m_LevelMax;

        [SerializeField] Button m_ChangeMission;
        [SerializeField] GrayGroup m_ChangeMissionGray;
        [SerializeField] TextEx m_ChangeMissionText;
        [SerializeField] Button m_ApplicationList;
        [SerializeField] ImageEx m_ApplicationIcon;
        [SerializeField] TextEx m_ApplicationText;
        [SerializeField] ButtonEx m_WorldInviteInTeam;
        [SerializeField] Button m_WorldInviteNoTeam;
        [SerializeField] Button m_Invite;
        [SerializeField] RectTransform m_InviteSelectedSign;
        [SerializeField] TeamInviteEntrancePanel m_TeamInviteEntrancePanel;

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

        #region Built-in
        public Button close { get; set; }

        protected override void BindController()
        {
            if (this is SecondWindowInterface)
            {
                var frame = this.GetComponentInChildren<SecondFrameLoader>();
                frame.Create();
                close = frame.GetComponentInChildren<Button>();
            }
        }

        protected override void AddListeners()
        {
            close.AddListener(CloseClick);
            m_CreateTeam.AddListener(CreateTeam);
            m_ChallengeDungeon.AddListener(GroupChallengeDungeon);
            m_AutoFind.AddListener(AutoFind);
            m_ApplicationList.AddListener(ViewApplicationList);
            m_WorldInviteInTeam.AddListener(WorldInvite);
            m_Invite.AddListener(ShowInviteButtons);
            m_ChangeMission.AddListener(ChangeMission);
            m_AutoAcceptInvitation.AddListener(OnAutoAcceptInvitationValueChange);

            m_AutoPrepareSetting.AddListener(SetAutoPrepare); ;
            m_CancelAutoPrepare.AddListener(CancelAutoPrepare);
        }

        protected override void OnPreOpen()
        {
            m_AutoAcceptInvitation.isOn = model.autoAcceptInvitation;
            m_TeamInviteEntrancePanel.SetActive(false);
            m_InviteSelectedSign.SetActive(false);

            UpdateAutoPrepareButton();
            UpdateAutoMatchingButton();
            UpdateTeammateInfo();
            UpdateInteractElementState();
            UpdateExperienceAddition();
            UpdateMission();
            UpdateLevelLimit();

            model.myTeamRefreshEvent += UpdateTeammateInfo;
            model.myTeamRefreshEvent += UpdateMission;
            model.myTeamRefreshEvent += UpdateLevelLimit;
            model.myTeamRefreshEvent += UpdateInteractElementState;
            model.myTeamRefreshEvent += UpdateExperienceAddition;
            model.teammateChangeMapEvent += UpdateExperienceAddition;
            model.teammateChangeMapEvent += UpdateMission;
            model.missionLevelLimitChangeEvent += UpdateMission;
            model.missionLevelLimitChangeEvent += UpdateLevelLimit;
            model.missionLevelLimitChangeEvent += UpdateAutoPrepareButton;
            model.matchingStateChangeEvent += OnMatchStateChange;

            m_TeamInviteEntrancePanel.activeOrDeActiveEvent += OnInvitePanelActiveOrDeActive;
            model.myTeam.autoPrepare.autoPrepareChangeEvent += UpdateAutoPrepareButton;
        }

        protected override void OnAfterOpen()
        {

        }

        protected override void OnPreClose()
        {
            for (int i = 0; i < m_TeammateBehaviours.Length; i++)
            {
                var behaviour = m_TeammateBehaviours[i];
                behaviour.Dispose();
            }

            model.myTeamRefreshEvent -= UpdateTeammateInfo;
            model.myTeamRefreshEvent -= UpdateMission;
            model.myTeamRefreshEvent -= UpdateLevelLimit;
            model.myTeamRefreshEvent -= UpdateInteractElementState;
            model.myTeamRefreshEvent -= UpdateExperienceAddition;
            model.teammateChangeMapEvent -= UpdateExperienceAddition;
            model.teammateChangeMapEvent -= UpdateMission;
            model.missionLevelLimitChangeEvent -= UpdateMission;
            model.missionLevelLimitChangeEvent -= UpdateLevelLimit;
            model.missionLevelLimitChangeEvent -= UpdateAutoPrepareButton;
            model.matchingStateChangeEvent -= OnMatchStateChange;

            m_TeamInviteEntrancePanel.activeOrDeActiveEvent -= OnInvitePanelActiveOrDeActive;
            model.myTeam.autoPrepare.autoPrepareChangeEvent -= UpdateAutoPrepareButton;
        }

        protected override void OnAfterClose()
        {
        }

        public override void CloseClick()
        {
            WindowCenter.Instance.Close<TeamFrameWin>();
        }

        #endregion

        private void CreateTeam()
        {
            model.RequestCreateTeam(model.missionBuf.mapId, model.missionBuf.mapEx, model.levelMinBuf, model.levelMaxBuf);
        }

        private void GroupChallengeDungeon()
        {
            if (model.myTeam.iamCaptainer)
            {
                if (model.myTeam.iamCaptainer)
                {
                    HeroAIRecorder.Record();
                }
                GroupDungeonChallengeProcessor.Instance.GroupChallengeDungeon(model.myTeam.mission.mapId, model.myTeam.mission.mapEx, false);
            }
            else
            {
                SysNotifyMgr.Instance.ShowTip("DungeonGroupOnlyTeamLeader");
            }
        }

        private void AutoFind()
        {
            if (model.isMatching)
            {
                model.RequestCancelAutoMatchTeam();
            }
            else
            {
                var mission = model.myTeam.inTeam ? model.myTeam.mission : model.missionBuf;
                if (mission.mapId == TeamModel.NONE_MISSION)
                {
                    SysNotifyMgr.Instance.ShowTip("AutoMatchingNoTarget");
                }
                else if (model.myTeam.memberCount >= 4)
                {
                    SysNotifyMgr.Instance.ShowTip("AutoMatchingCannotJoinTeam");
                }
                else
                {
                    model.RequestAutoMatchTeam(true);
                }
            }
        }

        private void SetAutoPrepare()
        {
            WindowCenter.Instance.Open<TeamPrepareSettingWin>();
        }

        private void CancelAutoPrepare()
        {
            model.myTeam.autoPrepare.CancelAutoPrepare();
        }

        private void OnAutoAcceptInvitationValueChange(bool _value)
        {
            model.autoAcceptInvitation = _value;
        }

        private void ViewApplicationList()
        {
            if (model.myTeam.iamCaptainer || model.applications.Count > 0)
            {
                WindowCenter.Instance.Open<TeamApplicationWin>();
            }
        }

        private void WorldInvite()
        {
            if (model.myTeam.iamCaptainer)
            {
                model.RequestWorldInvite();
            }
        }

        private void ChangeMission()
        {
            if (!model.myTeam.inTeam || model.myTeam.iamCaptainer)
            {
                if (model.isMatching)
                {
                    SysNotifyMgr.Instance.ShowTip("AutoMatchingCannotChangeTarget");
                }
                else
                {
                    WindowCenter.Instance.Open<TeamTargetJoinLimitWin>();
                }
            }
        }

        private void ShowInviteButtons()
        {
            m_TeamInviteEntrancePanel.SetActive(true);
        }

        private void UpdateTeammateInfo()
        {
            m_CaptainerSign.SetActive(model.myTeam.inTeam);
            m_ContainerEmpty.SetActive(!model.myTeam.inTeam && !model.isMatching);
            UpdateAutoMatchingButton();

            var gray = model.myTeam.inTeam && !model.myTeam.iamCaptainer;
            m_ChangeMissionGray.gray = gray;
            m_ChangeMissionText.colorType = gray ? TextColType.White : TextColType.NavyBrown;

            for (int i = 0; i < m_TeammateBehaviours.Length; i++)
            {
                var behaviour = m_TeammateBehaviours[i];
                behaviour.Display();
            }
        }

        private void UpdateInteractElementState()
        {
            UpdateCreateTeamButton();
            UpdateDungeonChallengeButton();
            UpdateAutoPrepareButton();

            var able = model.myTeam.iamCaptainer;

            //非队长情况也可以 同意申请入队（目前用于boss伤害列表）
            m_ApplicationIcon.gray = !able && model.applications.Count == 0;
            m_ApplicationText.colorType = !m_ApplicationIcon.gray ? TextColType.NavyBrown : TextColType.White;

            m_WorldInviteInTeam.SetActive(able);
            m_WorldInviteNoTeam.SetActive(!able);
        }

        private void UpdateExperienceAddition()
        {
            m_ContainerAutoInvitation.SetActive(!model.myTeam.inTeam && !model.isMatching);
            m_ContainerTeamExperience.SetActive(model.myTeam.inTeam || model.isMatching);

            var nearByCount = model.myTeam.nearByCount;
            for (int i = 0; i < m_TeamateSigns.Length; i++)
            {
                var sign = m_TeamateSigns[i];
                Teammate mate;
                if (model.myTeam.TryGetMember(i, out mate))
                {
                    var isNearBy = mate.mapId == PlayerDatas.Instance.baseData.MapID;
                    sign.Display(isNearBy ? TeammateNearByBehaviour.LocationState.NearBy : TeammateNearByBehaviour.LocationState.FarAway);
                }
                else
                {
                    sign.Display(TeammateNearByBehaviour.LocationState.None);
                }
            }

            var experienceAddition = 10 * model.myTeam.nearByCount;
            m_ExperienceAddition.text = StringUtility.Contact(experienceAddition, "%");
            m_ExperienceAddition.color = UIHelper.GetUIColor(experienceAddition > 0 ? TextColType.Green : TextColType.NavyBrown, true);
        }

        private void UpdateExperienceAddition(int _playerId)
        {
            UpdateExperienceAddition();
        }

        private void UpdateMission(int _playerId)
        {
            UpdateMission();
        }

        private void UpdateMission()
        {
            TeamMission mission;
            if (model.myTeam.inTeam)
            {
                mission = model.myTeam.mission;
            }
            else
            {
                mission = model.missionBuf;
            }

            if (mission.mapId == TeamModel.NONE_MISSION)
            {
                m_Mission.text = Language.Get("No_Target");
            }
            else
            {
                var targetConfig = TeamTargetConfig.Get(mission.mapId);
                if (targetConfig != null)
                {
                    var dungeonId = dungeonModel.GetDungeonId(mission.mapId, mission.mapEx);
                    var config = DungeonConfig.Get(dungeonId);
                    m_Mission.text = config.FBName;
                }
                else
                {
                    var mapId = 0;
                    if (model.myTeam.inTeam)
                    {
                        Teammate teamLeader;
                        model.myTeam.TryGetMember(0, out teamLeader);
                        mapId = teamLeader != null ? teamLeader.mapId : PlayerDatas.Instance.baseData.MapID;
                    }
                    else
                    {
                        mapId = PlayerDatas.Instance.baseData.MapID;
                    }

                    var config = MapConfig.Get(mapId);
                    m_Mission.text = config != null ? config.Name : "";
                }
            }

            UpdateDungeonChallengeButton();
        }

        private void UpdateLevelLimit()
        {
            TeamMission mission;
            if (model.myTeam.inTeam)
            {
                mission = model.myTeam.mission;
            }
            else
            {
                mission = model.missionBuf;
            }

            var minLevel = model.myTeam.inTeam ? model.myTeam.levelMin : model.levelMinBuf;
            var maxLevel = model.myTeam.inTeam ? model.myTeam.levelMax : model.levelMaxBuf;

            m_LevelMinSign.SetActive(false);
            m_LevelMin.text = minLevel.ToString();
            m_LevelMaxSign.SetActive(false);
            m_LevelMax.text = maxLevel.ToString();

        }

        private void UpdateDungeonChallengeButton()
        {
            if (model.myTeam.inTeam)
            {
                var dungeonId = dungeonModel.GetDungeonId(model.myTeam.mission.mapId, model.myTeam.mission.mapEx);
                if (dungeonId == 0)
                {
                    m_ChallengeDungeon.SetActive(false);
                }
                else
                {
                    var dungeonConfig = DungeonConfig.Get(dungeonId);
                    var mapConfig = MapConfig.Get(dungeonConfig.MapID);
                    m_ChallengeDungeon.SetActive(mapConfig != null && (MapType)mapConfig.MapFBType == MapType.MultipleFB);
                }
            }
            else
            {
                m_ChallengeDungeon.SetActive(false);
            }
        }

        private void UpdateAutoMatchingButton()
        {
            m_AutoFind.SetActive(!model.myTeam.inTeam || model.myTeam.iamCaptainer);
            m_MatchState.text = model.isMatching ? Language.Get("StopMatching") : Language.Get("TeamListAutoMatching");
            if (model.isMatching)
            {
                m_MatchingCoolDown.Begin((int)(model.matchingEndTime - DateTime.Now).TotalSeconds);
            }
            else
            {
                m_MatchingCoolDown.Stop();
            }
        }

        private void UpdateCreateTeamButton()
        {
            m_CreateTeam.SetActive(!model.myTeam.inTeam);
        }

        private void UpdateAutoPrepareButton()
        {
            var multipleFB = false;
            var dungeonId = dungeonModel.GetDungeonId(model.myTeam.mission.mapId, model.myTeam.mission.mapEx);
            if (dungeonId != 0)
            {
                var dungeonConfig = DungeonConfig.Get(dungeonId);
                var mapConfig = MapConfig.Get(dungeonConfig.MapID);
                multipleFB = mapConfig != null && (MapType)mapConfig.MapFBType == MapType.MultipleFB;
            }
            else
            {
                multipleFB = false;
            }

            var showAutoPrepare = model.myTeam.inTeam && !model.myTeam.iamCaptainer && multipleFB;
            if (showAutoPrepare)
            {
                m_AutoPrepareSetting.SetActive(!model.myTeam.autoPrepare.auto);
                m_CancelAutoPrepare.SetActive(model.myTeam.autoPrepare.auto);
                m_AutoPrepareContainer.SetActive(true);
            }
            else
            {
                m_AutoPrepareContainer.SetActive(false);
            }
        }

        private void OnMatchStateChange()
        {
            UpdateTeammateInfo();
            UpdateExperienceAddition();
            if (model.isMatching)
            {
                SysNotifyMgr.Instance.ShowTip("BeginAutoMatching");
            }
        }

        private void OnInvitePanelActiveOrDeActive(bool _active)
        {
            m_InviteSelectedSign.SetActive(_active);
        }

    }

}