using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Sfs2X.Core;
using Sfs2X.Entities;
using Sfs2X.Entities.Data;
using UnityEngine;
using UnityEngine.UI;

public class PlazaRoomManager : Regist
{
    #region Config

    public static float ItemHeight
    {
        get
        {
            if (itemHeight == 0)
            {
                itemHeight = Grid.GetChild(0).GetComponent<RectTransform>().rect.height + Grid.GetComponent<VerticalLayoutGroup>().spacing;
            }
            
            return itemHeight;
        }
    }
    private static float itemHeight;

    public static float DownLoadTimespan = 30;
    public static bool DownloadLock;

    public static int LastIndex;
    public static int FirstIndex;
    public static int CustomLastIndex;
    public static int CustomFirstIndex;
    public static bool FilterEnabled;
    public static Transform Grid;
    public static VirtualScrollRect ScrollRect;

    public static List<PlazaRoomItem> PlazaRoomItems = new List<PlazaRoomItem>();
    public static Dictionary<int, RoomData> RoomDatas = new Dictionary<int, RoomData>();

    public static List<PlazaRoomItem> CustomPlazaRoomItems = new List<PlazaRoomItem>();
    public static Dictionary<int, RoomData> CustomRoomDatas = new Dictionary<int, RoomData>();

    #endregion

    private float RefreshTime = 10;
    private float RefreshTimer = 0;
    private void Update()
    {
        RefreshTimer += Time.deltaTime;
        if (RefreshTimer >= RefreshTime)
        {
            RefreshTimer = 0;
            if (FilterEnabled)
                RefreshRoomStatus(CustomPlazaRoomItems);
            else
                RefreshRoomStatus(PlazaRoomItems);
        }
    }


    public override void ThirdInit()
    {
        VirtualScrollRect virtualScrollRect = ResourceManager.Get<VirtualScrollRect>(ObjectLabel.Z_ScrollRect);
        virtualScrollRect.OnVerticalLessEqual0 = NextPageGate;
        virtualScrollRect.OnVerticalGreaterEqual1 = PreviousPageGate;

        CostFml = ConfigManager.GetPlazaRoomConfig()[1].Value;
        ValueFml = ConfigManager.GetPlazaRoomConfig()[2].Value;
    }

    public override void RegistReference()
    {
        Grid = ResourceManager.Get(ObjectLabel.Z_Grid);
        ScrollRect = ResourceManager.Get<VirtualScrollRect>(ObjectLabel.Z_ScrollRect);
        DurationLab = ResourceManager.Get<Text>(ObjectLabel.AAa_ValueLab);
        DurationSlider = ResourceManager.Get<Slider>(ObjectLabel.AAa_Slider);
        MaxPlayerLab = ResourceManager.Get<Text>(ObjectLabel.AAb_ValueLab);
        MaxPlayerSlider = ResourceManager.Get<Slider>(ObjectLabel.AAb_Slider);
        
        DurationSlider.onValueChanged.AddListener(OnSliderValueChange);
        DurationSlider.onValueChanged.AddListener(f => AudioManager.PlayClip(AudioLabel.ClickButton));
        MaxPlayerSlider.onValueChanged.AddListener(OnSliderValueChange);
        MaxPlayerSlider.onValueChanged.AddListener(f => AudioManager.PlayClip(AudioLabel.ClickButton));
    }


    public static void RefreshRoomStatus(List<PlazaRoomItem> plazaRoomItems)
    {
        List<int> databaseRoomIDs = new List<int>();
        foreach (var plazaRoomItem in plazaRoomItems)
        {
            databaseRoomIDs.Add(plazaRoomItem.RoomData.ID);
        }
        SFSManager.GardenSmartFox.EventManager.PlazaRoomEvent.GetRoomFullStatus(databaseRoomIDs);
    }

    public static void DownloadRoomData()
    {
        LanguageManager.Add(ResourceManager.Get<Text>(ObjectLabel.Z_Tip), new MulLanStr(LanguageLabel.UI__Loading));
        ResourceManager.Get(ObjectLabel.Z_Tip).TweenForCG();
        DownloadLock = true;
        SFSManager.GardenSmartFox.ExecuteAfterCheckConection
        (
            () => SFSManager.GardenSmartFox.EventManager.PlazaRoomEvent.GetRoomData(LastIndex),
            (succeed, baseEvent) => { if (!succeed) { LanguageManager.Add(ResourceManager.Get<Text>(ObjectLabel.Z_Tip), new MulLanStr(LanguageLabel.UI__LoadFailed)); DelayCall.Call(DownLoadTimespan, () => { DownloadLock = false; ResourceManager.Get(ObjectLabel.Z_Tip).TweenBacCG(); }); } },
            (succeed, baseEvent) => { if (!succeed) { LanguageManager.Add(ResourceManager.Get<Text>(ObjectLabel.Z_Tip), new MulLanStr(LanguageLabel.UI__LoadFailed)); DelayCall.Call(DownLoadTimespan, () => { DownloadLock = false; ResourceManager.Get(ObjectLabel.Z_Tip).TweenBacCG(); }); } }
         );
    }

    public static void DownloadCustomRoomData()
    {
        LanguageManager.Add(ResourceManager.Get<Text>(ObjectLabel.Z_Tip), new MulLanStr(LanguageLabel.UI__Loading));
        ResourceManager.Get(ObjectLabel.Z_Tip).TweenForCG();
        DownloadLock = true;
        SFSManager.GardenSmartFox.ExecuteAfterCheckConection
        (
            () => SFSManager.GardenSmartFox.EventManager.PlazaRoomEvent.GetCustomRoomData(CustomLastIndex, long.Parse(HttpManager.SerialNumber)),
            (succeed, baseEvent) => { if (!succeed) { LanguageManager.Add(ResourceManager.Get<Text>(ObjectLabel.Z_Tip), new MulLanStr(LanguageLabel.UI__LoadFailed)); DelayCall.Call(DownLoadTimespan, () => { DownloadLock = false; ResourceManager.Get(ObjectLabel.Z_Tip).TweenBacCG(); }); } },
            (succeed, baseEvent) => { if (!succeed) { LanguageManager.Add(ResourceManager.Get<Text>(ObjectLabel.Z_Tip), new MulLanStr(LanguageLabel.UI__LoadFailed)); DelayCall.Call(DownLoadTimespan, () => { DownloadLock = false; ResourceManager.Get(ObjectLabel.Z_Tip).TweenBacCG(); }); } }
        );
    }

    public static void OnReceiveRoomData(ISFSArray sfsArray)
    {
        //Debug.LogWarning("receive " + sfsArray.Count);

        int count = RoomDatas.Count;
        for (int i = 0; i < sfsArray.Count; i++)
        {
            RoomData roomData = new RoomData(sfsArray.GetSFSObject(i));
            if (!RoomDatas.Values.Contains(roomData))
            {
                RoomDatas.Add(count + i, roomData);
            }
        }

        if (FilterEnabled)
        {
            return;
        }

        LanguageManager.Add(ResourceManager.Get<Text>(ObjectLabel.Z_Tip), new MulLanStr(LanguageLabel.UI__LoadSucceed));
        DelayCall.Call(0.5f, () => { ResourceManager.Get(ObjectLabel.Z_Tip).TweenBacCG(); });

        if (sfsArray.Count == 0)
        {
            DelayCall.Call(DownLoadTimespan, () => { DownloadLock = false; });
        }
        else
        {
            int availableItemAmt = MaxRoomItem - PlazaRoomItems.Count;
            NextPage(availableItemAmt, ref FirstIndex, ref LastIndex, RoomDatas);
            DownloadLock = false;
        }

        RefreshRoomStatus(PlazaRoomItems);
    }

    public static void OnReceiveCustomRoomData(ISFSArray sfsArray)
    {
        //Debug.LogWarning("receive custom " + sfsArray.Count);

        int count = CustomRoomDatas.Count;
        for (int i = 0; i < sfsArray.Count; i++)
        {
            RoomData roomData = new RoomData(sfsArray.GetSFSObject(i));
            if (!CustomRoomDatas.Values.Contains(roomData))
            {
                CustomRoomDatas.Add(count + i, roomData);
            }
        }

        if (!FilterEnabled)
        {
            return;
        }

        LanguageManager.Add(ResourceManager.Get<Text>(ObjectLabel.Z_Tip), new MulLanStr(LanguageLabel.UI__LoadSucceed));
        DelayCall.Call(0.5f, () => { ResourceManager.Get(ObjectLabel.Z_Tip).TweenBacCG(); });

        if (sfsArray.Count == 0)
        {
            DelayCall.Call(DownLoadTimespan, () => { DownloadLock = false; });
        }
        else
        {
            int availableItemAmt = MaxRoomItem - PlazaRoomItems.Count;
            NextPage(availableItemAmt, ref CustomFirstIndex, ref CustomLastIndex, CustomRoomDatas);
            DownloadLock = false;
        }

        RefreshRoomStatus(CustomPlazaRoomItems);
    }

    public static void OnReceiveRoomFullStatus(List<int> ids, List<bool> statuses)
    {
        foreach (var plazaRoomItem in PlazaRoomItems)
        {
            int index = ids.IndexOf(plazaRoomItem.RoomData.ID);
            if (index != -1)
            {
                plazaRoomItem.RefreshStatus(statuses[index]);
            }
        }
    }


    private static int PageVolume = 5;
    public static void NextPageGate()
    {
        if (FilterEnabled)
        {
            NextPage(PageVolume, ref CustomFirstIndex, ref CustomLastIndex, CustomRoomDatas);
        }
        else
        {
            NextPage(PageVolume, ref FirstIndex, ref LastIndex, RoomDatas);
        }
    }

    public static void PreviousPageGate()
    {
        if (FilterEnabled)
        {
            PreviousPage(PageVolume, ref CustomFirstIndex, ref CustomLastIndex, CustomRoomDatas);
        }
        else
        {
            PreviousPage(PageVolume, ref FirstIndex, ref LastIndex, RoomDatas);
        }
    }

    public static void NextPage(int nextAmt, ref int firstIndex, ref int lastIndex, Dictionary<int, RoomData> dictionary)
    {
        if (lastIndex >= dictionary.Count)
        {
            if (!DownloadLock)
            {
                //Debug.LogWarning("Download Page");
                if (FilterEnabled)
                {
                    DownloadCustomRoomData();   
                }
                else
                {
                    DownloadRoomData();
                }
            }
        }
        else
        {
            //Debug.LogWarning("Next Page");
            for (int i = 0; i < nextAmt; i++)
            {
                RoomData roomData;
                if (dictionary.TryGetValue(lastIndex, out roomData))
                {
                    CreateNextRoomItem(ref firstIndex, ref lastIndex, roomData);
                }
                else
                {
                    break;
                }
            }
        }
    }

    public static void PreviousPage(int nextAmt, ref int firstIndex, ref int lastIndex, Dictionary<int, RoomData> dictionary)
    {
        if (firstIndex == 0)
        {
            return;
        }

        //Debug.LogWarning("Prev Page");
        for (int i = 0; i < nextAmt; i++)
        {
            RoomData roomData;
            if (dictionary.TryGetValue(firstIndex - 1, out roomData))
            {
                CreatePreviousRoomItem(ref firstIndex, ref lastIndex, roomData);
            }
            else
            {
                break;
            }
        }
    }

    private static int MaxRoomItem = 10;
    private static void CreateNextRoomItem(ref int firstIndex, ref int lastIndex, RoomData roomData)
    {
        if (PlazaRoomItems.Count >= MaxRoomItem)
        {
            firstIndex++;
            lastIndex++;

            Transform firstChild = Grid.GetChild(0);
            firstChild.GetComponent<PlazaRoomItem>().Init(roomData);
            ScrollRect.Recycle(new Vector2(0, -ItemHeight));
            Grid.position += new Vector3(0, -ItemHeight);
            firstChild.SetAsLastSibling();
        }
        else
        {
            lastIndex++;

            PlazaRoomItems.Add(roomData.CreateItem().Init(roomData));
        }
    }

    private static void CreatePreviousRoomItem(ref int firstIndex, ref int lastIndex, RoomData roomData)
    {
        if (PlazaRoomItems.Count >= MaxRoomItem)
        {
            firstIndex--;
            lastIndex--;

            Transform lastChild = Grid.GetChild(Grid.childCount - 1);
            lastChild.GetComponent<PlazaRoomItem>().Init(roomData);
            ScrollRect.Recycle(new Vector2(0, ItemHeight));
            Grid.position += new Vector3(0, ItemHeight);
            lastChild.SetAsFirstSibling();
        }
    }


    public static void OpenPanel()
    {
        if (!DownloadLock)
        {
            DownloadRoomData();
            DownloadCustomRoomData();
        }
        OnSliderValueChange(0);
        ResourceManager.Get(ObjectLabel.Z_BK).TweenForCG();
    }

    public static void ClosePanel()
    {
        ResourceManager.Get(ObjectLabel.Z_BK).TweenBacCG();
    }

    public static void EnableFilter()
    {
        FilterEnabled = true;
        ResourceManager.SetActive(ObjectLabel.Z_InfoImg51, true);
        ClearGrid();
        NextPage(PageVolume, ref CustomFirstIndex, ref CustomLastIndex, CustomRoomDatas);
    }

    public static void DisableFilter()
    {
        FilterEnabled = false;
        ResourceManager.SetActive(ObjectLabel.Z_InfoImg51, false);
        ClearGrid();
        NextPage(PageVolume, ref FirstIndex, ref LastIndex, RoomDatas);
    }

    private static void ClearGrid()
    {
        LastIndex = 0;
        FirstIndex = 0;
        CustomLastIndex = 0;
        CustomFirstIndex = 0;

        while (Grid.childCount > 0)
        {
            ResourceManager.Save(Grid.GetChild(0));
        }

        PlazaRoomItems = new List<PlazaRoomItem>();

        ResourceManager.Get(ObjectLabel.Z_Tip).GetTweenCG().InOrigin = true;

        DownloadLock = false;
    }


    public static int Cost;
    public static int Duration;
    public static int MaxPlayer;
    public static int MaxRoomNameChar = 24;
    public static string CostFml;
    public static string ValueFml;
    private static Text DurationLab;
    private static Text MaxPlayerLab;
    private static Slider DurationSlider;
    private static Slider MaxPlayerSlider;
    public static void CreateRoom()
    {
        string roomName = ResourceManager.Get<InputField>(ObjectLabel.AA_InputField).text;

        if (string.IsNullOrEmpty(roomName))
        {
            Bubble.Show(null, Language.GetStr(LanguageLabel.UI__AA_AllWhiteSpace));
            return;
        }

        if (roomName.GetBytes() > MaxRoomNameChar)
        {
            Bubble.Show(null, Language.GetStr(LanguageLabel.UI__AA_TooLong));
            return;
        }

        if (StringFilter.ContainSensitiveWord(roomName))
        {
            Bubble.Show(null, Language.GetStr(LanguageLabel.Common__ContainSensitiveWord));
            return;
        }

        LanguageManager.Add(ResourceManager.Get<Text>(ObjectLabel.AA_Tip), new MulLanStr(LanguageLabel.UI__AA_SendRequest));
        ResourceManager.Get(ObjectLabel.AA_Tip).TweenForCG();
        ResourceManager.Get<CanvasGroup>(ObjectLabel.AA_CreatePlazaRoom).interactable = false;

        int value = (int) Auxiliary.FmlParse(ValueFml, "c", Cost.ToString(), "p", MaxPlayer.ToString(), "h", Duration.ToString());
        SFSManager.GardenSmartFox.EventManager.PlazaRoomEvent.CreateRoom(roomName, long.Parse(HttpManager.SerialNumber), Duration, MaxPlayer, value);
    }

    public static void OnCreateRoomError()
    {
        LanguageManager.Add(ResourceManager.Get<Text>(ObjectLabel.AA_Tip), new MulLanStr(LanguageLabel.UI__AA_CreateError));
        ResourceManager.Get(ObjectLabel.AA_Tip).TweenBacCG();
        ResourceManager.Get<CanvasGroup>(ObjectLabel.AA_CreatePlazaRoom).interactable = true;

        Debug.Log("create error");
    }

    public static void OnCreateRoomSucceed(RoomData roomData)
    {
        if (!RoomDatas.Values.Contains(roomData))
        {
            RoomDatas.Add(RoomDatas.Count, roomData);
        }
        if (!CustomRoomDatas.Values.Contains(roomData))
        {
            CustomRoomDatas.Add(CustomRoomDatas.Count, roomData);
        }
        int availableItemAmt = MaxRoomItem - PlazaRoomItems.Count;
        if (FilterEnabled)
        {
            NextPage(availableItemAmt, ref CustomFirstIndex, ref CustomLastIndex, CustomRoomDatas);
        }
        else
        {
            NextPage(availableItemAmt, ref FirstIndex, ref LastIndex, RoomDatas);
        }


        Manager.CreateRoomAmt++;

        LanguageManager.Add(ResourceManager.Get<Text>(ObjectLabel.AA_Tip), new MulLanStr(LanguageLabel.UI__AA_CreateSucceed));
        ResourceManager.Get(ObjectLabel.AA_Tip).TweenBacCG();
        ResourceManager.Get<CanvasGroup>(ObjectLabel.AA_CreatePlazaRoom).interactable = true;
        DownloadRoomData();

        Manager.AddDiamond(-Cost, StaticsManager.ItemID.创建派对, StaticsManager.ConsumeModule.Charge);

        PlazaRoomItem.OnJoinBtn(roomData);
        CloseCreatePanel();
    }

    public static void OnSliderValueChange(float value)
    {
        Duration = (int) DurationSlider.value;
        MaxPlayer = (int) MaxPlayerSlider.value;
        DurationLab.text = Duration + Language.GetStr(LanguageLabel.UI__AAa_Value);
        MaxPlayerLab.text = MaxPlayer + Language.GetStr(LanguageLabel.UI__AAb_Value);

        Cost = (int) Auxiliary.FmlParse(CostFml, "h", Duration.ToString(), "p", MaxPlayer.ToString());
        ResourceManager.SetText(ObjectLabel.AA_Desc, Language.GetStr(LanguageLabel.UI__AA_Cost) + TransferLabel.DiamondSprite + Cost);
        
        if (Cost > Manager.Diamond)
        {
            ResourceManager.SetText(ObjectLabel.AA_BtnLab, Language.GetStr(LanguageLabel.UI__AA_NoEnoughDiamond));
            ResourceManager.Get<Button>(ObjectLabel.AA_Btn).image.material = Lib.GrayMat;
            ResourceManager.Get<Button>(ObjectLabel.AA_Btn).interactable = false;
        }
        else
        {
            ResourceManager.SetText(ObjectLabel.AA_BtnLab, Language.GetStr(LanguageLabel.UI__AA_Create));
            ResourceManager.Get<Button>(ObjectLabel.AA_Btn).image.material = null;
            ResourceManager.Get<Button>(ObjectLabel.AA_Btn).interactable = true;
        }
    }

    public static void OpenCreatePanel()
    {
        ResourceManager.Get(ObjectLabel.AA_CreatePlazaRoom).TweenForCG();

        string defaultName = Language.GetStr(LanguageLabel.UI__AA_DefaultName).Replace(TransferLabel.Value, NickNameManager.NickName);
        ResourceManager.Get<InputField>(ObjectLabel.AA_InputField).text = defaultName;
    }

    public static void CloseCreatePanel()
    {
        ResourceManager.Get(ObjectLabel.AA_CreatePlazaRoom).TweenBacCG();
    }
}