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

public class MergeServerActivityWin : ILWindow
{
    ScrollerController m_ActivityCtrl;
    Button m_BtnClose;

    List<int> m_MergeServerActivities = new List<int>();

    List<int> openActivitys = new List<int>();
    List<int> priorityActivitys = new List<int>();
    List<int> alreadyOpenActivitys = new List<int>();


    protected override void BindController()
    {
        m_BtnClose = proxy.GetWidgtEx<Button>("Btn_Close");
        m_ActivityCtrl = proxy.GetWidgtEx<ScrollerController>("ScrollerControl");

        var configs = ILMergeServerActivityConfig.GetValues();
        for (int i = 0; i < configs.Count; i++)
        {
            m_MergeServerActivities.Add(configs[i].id);
        }
        m_MergeServerActivities.Sort((x, y) =>
        {
            var config_x = ILMergeServerActivityConfig.Get(x);
            var config_y = ILMergeServerActivityConfig.Get(y);
            return config_x.order.CompareTo(config_y.order);
        });
    }

    protected override void AddListeners()
    {
            
        m_BtnClose.onClick.AddListener(TryClose);
    }

    protected override void OnPreOpen()
    {
        m_ActivityCtrl.OnRefreshCell += OnMergeServerActivityRefresh;
        TimeUtility.OnServerOpenDayRefresh += OnStepServerDayEvent;
        OpenServerActivityCenter.Instance.openServerActivityStateChange += OpenServerActivityStateChange;
        MergeServerActivityModel.Instance.SelectEvent += OnSelectType;

        CheckAlreadyOpen();
        
    }

    protected override void OnAfterOpen()
    {
        UpdateFunctionBtns();
    }

    protected override void OnActived()
    {
        if (alreadyOpenActivitys.Count == 0)
        {
            WindowCenter.Instance.CloseIL<MergeServerActivityWin>();
            return;
        }
        if (!WindowJumpMgr.Instance.IsJumpState)
        { 
            //跳转和红点优先打开的处理
            proxy.functionOrder = GetDefaultSelect();
        }
        MergeServerActivityModel.Instance.selectType = proxy.functionOrder;
        UpdateFunctionBtns();
            
        OnOpenActivity(proxy.functionOrder);

        var index = alreadyOpenActivitys.IndexOf(proxy.functionOrder);
        m_ActivityCtrl.JumpIndex(index);
    }


    protected override void OnPreClose()
    {
        m_ActivityCtrl.OnRefreshCell -= OnMergeServerActivityRefresh;
        TimeUtility.OnServerOpenDayRefresh -= OnStepServerDayEvent;
        OpenServerActivityCenter.Instance.openServerActivityStateChange -= OpenServerActivityStateChange;
        MergeServerActivityModel.Instance.SelectEvent -= OnSelectType;
        CloseOtherWin();
    }

    //跳转问题
    //protected override void OnAfterClose()
    //{
    //    if (!WindowJumpMgr.Instance.IsJumpState)
    //    {
    //        WindowCenter.Instance.Open<MainInterfaceWin>();
    //    }
    //}

    void OnSelectType()
    {
        m_ActivityCtrl.m_Scorller.RefreshActiveCellViews();
        OnOpenActivity(MergeServerActivityModel.Instance.selectType);
    }

    private void TryClose()
    {
        WindowCenter.Instance.CloseIL<MergeServerActivityWin>();
    }

    int GetDefaultSelect()
    {
        openActivitys.Clear();
        priorityActivitys.Clear();

        for (int i = 0; i < m_MergeServerActivities.Count; i++)
        {
            var activityId = m_MergeServerActivities[i];
            if (OpenServerActivityCenter.Instance.IsActivityOpen(activityId, (int)OpenServerActivityCenter.ActivityType.AT_HFHD))
            {
                openActivitys.Add(activityId);
                if (OpenServerActivityCenter.Instance.IsPriorityOpenOpen(activityId, (int)OpenServerActivityCenter.ActivityType.AT_HFHD))
                {
                    priorityActivitys.Add(activityId);

                }
            }
        }
        if (priorityActivitys.Count > 0)
        {
            priorityActivitys.Sort(Compare);
            return priorityActivitys[0];
        }
        else
        {
            openActivitys.Sort(Compare);
            return openActivitys[0];
        }
    }


    void CheckAlreadyOpen()
    {
        alreadyOpenActivitys.Clear();
        for (int i = 0; i < m_MergeServerActivities.Count; i++)
        {
            if (OpenServerActivityCenter.Instance.IsActivityOpen(m_MergeServerActivities[i], (int)OpenServerActivityCenter.ActivityType.AT_HFHD))
            {
                alreadyOpenActivitys.Add(m_MergeServerActivities[i]);
            }
        }
    }

    private void OnMergeServerActivityRefresh(ScrollerDataType type, CellView cell)
    {
        switch (type)
        {
            case ScrollerDataType.Header:
                var _cell = cell.GetILBehaviour<MergeServerActivityCell>();
                _cell?.Display(cell.index);
                break;
        }
    }


    private void OnStepServerDayEvent()
    {
        UpdateFunctionBtns();
    }

        
    private void UpdateFunctionBtns()
    {
        m_ActivityCtrl.Refresh();
        for (int i = 0; i < m_MergeServerActivities.Count; i++)
        {
            var activityId = m_MergeServerActivities[i];
            if (!alreadyOpenActivitys.Contains(activityId))
            {
                continue;
            }
            m_ActivityCtrl.AddCell(ScrollerDataType.Header, activityId);
        }
        m_ActivityCtrl.Restart();
        m_ActivityCtrl.m_Scorller.RefreshActiveCellViews();
    }


    private void OnOpenActivity(int _order)
    {
        CloseOtherWin();

        var functionInfos = WindowConfig.GetWindowFunctionInfos("MergeServerActivityWin");
        var index = -1;

        for (int i = 0; i < functionInfos.Count; i++)
        {
            if (functionInfos[i].order == _order)
            {
                index = i;
            }
        }

        if (index != -1)
        {
            WindowCenter.Instance.Open(functionInfos[index].window, true);
        }
    }


    private void CloseOtherWin()
    {
        var children = WindowConfig.GetChildWindows("MergeServerActivityWin");
        for (int i = 0; i < children.Count; i++)
        {
            WindowCenter.Instance.Close(children[i]);
        }
    }

    private int Compare(int order_x, int order_y)
    {
        var index_x = m_MergeServerActivities.IndexOf(order_x);
        var index_y = m_MergeServerActivities.IndexOf(order_y);
        return index_x.CompareTo(index_y);
    }

    private void OpenServerActivityStateChange()
    {
        UpdateFunctionBtns();
    }
}