garden_client/Assets/Script/Social/MessagePanel.cs

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

public class PrivateMessageDataStash
{
    private static int MaxPageAmount = 20;

    public int CurrentPage;
    public List<PrivateMessageData> PrivateMessageDatas = new List<PrivateMessageData>();

    public void Add(int page, List<PrivateMessageData> datas)
    {
        if (page < CurrentPage)
        {
            return;
        }
        
        CurrentPage = page;
        if (PrivateMessageDatas.Count <= page*MaxPageAmount)
        {
            PrivateMessageDatas.AddRange(datas);
        }
        else 
        {
            for (int i = page * MaxPageAmount; i < PrivateMessageDatas.Count; i++)
            {
                PrivateMessageDatas.RemoveAt(i--);
            }
            PrivateMessageDatas.AddRange(datas);
        }
    }

    public int GetNextPageIndex()
    {
        return PrivateMessageDatas.Count/ MaxPageAmount;
    }
}

public class MessagePanel : Regist
{
    #region Config

    public static Action OnPanelClosed;

    public static Text NicknameTitle;
    public static Text ContentTitle;
    public static Text TimeTitle;
    public static Text PanelTitle;
    public static Text PlaceholderTitle;
    public static Text InputText;
    public static Text SendMessageButtonTitle;
    public static Text CloseButtonTitle;
    public static Text LoadingTitle;
    public static Button CloseButton;
    public static Button SendMessageButton;
    public static Transform Grid;
    public static Transform MessagePanelMask;
    public static InputField InputField;
    public static VirtualScrollRectPlus ScrollRect;

    private static Coroutine LoadingTitleFadeOut;

    private static int MaxRollAmount = 4;
    private static int MaxChildAmount = 10;
    private static bool DownloadingPrivateMessageFlag;

    public static bool IsPanelOpen;
    public static AccountData AccountData;
    public static List<PrivateMessageItem> PrivateMessageItems = new List<PrivateMessageItem>();
    public static Dictionary<string, PrivateMessageDataStash> PrivateMessageDataDictionary = new Dictionary<string, PrivateMessageDataStash>();

    public static Action<string> OnHaveNewMessage;
    public static Action<string> OnDontHaveNewMessage;

    #endregion

    public override void RegistReference()
    {
        NicknameTitle = ResourceManager.Get<Text>(ObjectLabel.AH_NicknameTitle);
        ContentTitle = ResourceManager.Get<Text>(ObjectLabel.AH_ContentTitle);
        TimeTitle = ResourceManager.Get<Text>(ObjectLabel.AH_TimeTitle);
        PanelTitle = ResourceManager.Get<Text>(ObjectLabel.AH_PanelTitle);
        PlaceholderTitle = ResourceManager.Get<Text>(ObjectLabel.AH_PlaceholderTitle);
        InputText = ResourceManager.Get<Text>(ObjectLabel.AH_InputText);
        SendMessageButtonTitle = ResourceManager.Get<Text>(ObjectLabel.AH_SendMessageButtonTitle);
        CloseButtonTitle = ResourceManager.Get<Text>(ObjectLabel.AH_CloseButtonTitle);
        LoadingTitle = ResourceManager.Get<Text>(ObjectLabel.AH_LoadingTitle);
        CloseButton = ResourceManager.Get<Button>(ObjectLabel.AH_CloseButton);
        SendMessageButton = ResourceManager.Get<Button>(ObjectLabel.AH_SendMessageButton);
        Grid = ResourceManager.Get(ObjectLabel.AH_Grid);
        MessagePanelMask = ResourceManager.Get(ObjectLabel.AH_MessagePanelMask);
        InputField = ResourceManager.Get<InputField>(ObjectLabel.AH_InputField);
        ScrollRect = ResourceManager.Get<VirtualScrollRectPlus>(ObjectLabel.AH_ScrollRect);
        ScrollRect.Init(MaxRollAmount, MaxChildAmount, GetNextItem, GetPreviousItem, OnSaveItem);

        LoadingTitle.CreateTweenCG(0, 1, 0.25f, false, true, Curve.EaseOutQuad);
        TweenRoot tweenRoot = MessagePanelMask.CreateTweenCG(0, 1, 0.25f, false, true, Curve.EaseOutQuad);
        tweenRoot.OnBackwardFinish += () => { OnPanelClosed.SafeInvoke(); };

        LanguageManager.Add(NicknameTitle, new MulLanStr(LanguageLabel.UI__AH_NicknameTitle));
        LanguageManager.Add(ContentTitle, new MulLanStr(LanguageLabel.UI__AH_ContentTitle));
        LanguageManager.Add(TimeTitle, new MulLanStr(LanguageLabel.UI__AH_TimeTitle));
        LanguageManager.Add(PanelTitle, new MulLanStr(LanguageLabel.UI__AH_PanelTitle));
        LanguageManager.Add(PlaceholderTitle, new MulLanStr(LanguageLabel.UI__AH_PlaceholderTitle));
        LanguageManager.Add(SendMessageButtonTitle, new MulLanStr(LanguageLabel.UI__AH_SendMessageButtonTitle));
        LanguageManager.Add(CloseButtonTitle, new MulLanStr(LanguageLabel.UI__AH_CloseButtonTitle));

        CloseButton.onClick.AddListener(ClosePanel);
        SendMessageButton.onClick.AddListener(SendMessage);
    }


    public static void OpenPanel(AccountData accountData)
    {
        IsPanelOpen = true;
        DownloadingPrivateMessageFlag = false;
        AccountData = accountData;
        MessagePanelMask.TweenForCG();
        RefreshScrollRect();

        PrivateMessageDataStash dataStash = PrivateMessageDataDictionary[AccountData.SerialNumber];
        if (dataStash.PrivateMessageDatas.Count > 0)
        {
            FriendPanel.SaveLastPrivateMessageDate(AccountData.SerialNumber, dataStash.PrivateMessageDatas[0].Date);
            OnDontHaveNewMessage.Invoke(AccountData.SerialNumber);
            FriendPanel.SortFriendItems(null);
        }
    }

    public static void ClosePanel()
    {
        AudioManager.PlayClip(ResourceLabel.CloseClip);
        IsPanelOpen = false;
        MessagePanelMask.TweenBacCG();
    }


    private void OnSaveItem(int dataIndex, VirtualScrollRectItem item)
    {
        ResourceManager.Save(item);
        PrivateMessageItems.Remove((PrivateMessageItem) item);
    }

    private VirtualScrollRectItem GetNextItem(int dataIndex)
    {
        TryCreateNewPrivateMessageDataStash(AccountData.SerialNumber);
        PrivateMessageDataStash dataStash = PrivateMessageDataDictionary[AccountData.SerialNumber];
        if (dataStash.PrivateMessageDatas.Count > dataIndex)
        {
            PrivateMessageData data = dataStash.PrivateMessageDatas[dataIndex];
            data.Nickname = AccountData.Nickname;
            PrivateMessageItem item = GetItem(data);
            PrivateMessageItems.Add(item);
            return item;
        }
        else
        {
            if (!DownloadingPrivateMessageFlag)
            {
                DownloadingPrivateMessageFlag = true;
                if (LoadingTitleFadeOut!=null)
                {
                    DelayCall.stopCoroutine(LoadingTitleFadeOut);
                }
                LoadingTitle.text = Language.GetStr(LanguageLabel.UI__AH_Loading);
                LoadingTitle.TweenForCG();
                HttpManager.GetPrivateMessage(AccountData.SerialNumber, dataStash.GetNextPageIndex().ToString(), DownloadPrivateMessageSucceedCallback, DownloadPrivateMessageFailedCallback);
            }
            return null;
        }
    }

    private VirtualScrollRectItem GetPreviousItem(int dataIndex)
    {
        if (dataIndex < 0)
        {
            return null;
        }

        PrivateMessageDataStash dataStash = PrivateMessageDataDictionary[AccountData.SerialNumber];
        PrivateMessageData data = dataStash.PrivateMessageDatas[dataIndex];
        data.Nickname = AccountData.Nickname;
        PrivateMessageItem item = GetItem(data);
        PrivateMessageItems.Insert(0, item);
        return item;
    }

    public static PrivateMessageItem GetItem(PrivateMessageData data)
    {
        PrivateMessageItem item = ResourceManager.Get(PrivateMessageItemLabel.MessageItem, Folder.UI, false, ScrollRect.content, false, ObjType.PrivateMessageItem, typeof(PrivateMessageItem)).GetComponent<PrivateMessageItem>();
        item.Init();
        item.Reset(data);
        return item;
    }


    public static void RefreshPrivateMessageFailedCallback()
    {
        
    }

    public static void RefreshPrivateMessageSucceedCallback(string targetSerialNumber, string page, List<PrivateMessageData> datas)
    {
        if (datas.Count == 0)
        {
            return;
        }

        TryCreateNewPrivateMessageDataStash(targetSerialNumber);
        PrivateMessageDataStash dataStash = PrivateMessageDataDictionary[targetSerialNumber];
        dataStash.Add(int.Parse(page), datas);

        if (IsPanelOpen && targetSerialNumber == AccountData.SerialNumber && FriendPanel.IsPrivateMessageNew(targetSerialNumber, datas[0].Date))
        {
            RefreshScrollRect();
            FriendPanel.SaveLastPrivateMessageDate(targetSerialNumber, datas[0].Date);
            OnDontHaveNewMessage.Invoke(targetSerialNumber);
        }
        else if (FriendPanel.IsPrivateMessageNew(targetSerialNumber, datas[0].Date))
        {
            //Debug.Log(targetSerialNumber);
            OnHaveNewMessage.Invoke(targetSerialNumber);
        }
    }

    public static void RefreshScrollRect()
    {
        ScrollRect.SaveAllChild();
        ScrollRect.NextPage();
        ScrollRect.NextPage();
    }


    public static void DownloadPrivateMessageFailedCallback()
    {
        DownloadingPrivateMessageFlag = false;
        LoadingTitle.text = Language.GetStr(LanguageLabel.UI__AH_LoadFailed);
        LoadingTitleFadeOut = DelayCall.Call(1f, () => LoadingTitle.TweenBacCG());
    }

    public static void DownloadPrivateMessageSucceedCallback(string targetSerialNumber, string page, List<PrivateMessageData> datas)
    {
        DownloadingPrivateMessageFlag = false;
        LoadingTitle.text = Language.GetStr(LanguageLabel.UI__AH_LoadSucceed);
        LoadingTitleFadeOut = DelayCall.Call(1f, () => LoadingTitle.TweenBacCG());

        TryCreateNewPrivateMessageDataStash(targetSerialNumber);
        PrivateMessageDataStash dataStash = PrivateMessageDataDictionary[targetSerialNumber];
        dataStash.Add(int.Parse(page), datas);
    }


    public static void TryCreateNewPrivateMessageDataStash(string targetSerialNumber)
    {
        if (!PrivateMessageDataDictionary.ContainsKey(targetSerialNumber))
        {
            PrivateMessageDataDictionary.Add(targetSerialNumber, new PrivateMessageDataStash());
        }
    }


    private static void SendMessage()
    {
        if (string.IsNullOrEmpty(InputField.text))
        {
            Bubble.Show(null, Language.GetStr(LanguageLabel.UI__AH_PrivateMessageEmpty));
            return;
        }

        AudioManager.PlayClip(ResourceLabel.BtnClip);
        HttpManager.SendPrivateMessage(AccountData.SerialNumber, StringFilter.GetFilteredString(InputField.text), SendMessageSucceedCallback, SendMessageFailedCallback);
        InputField.text = "";
        SendMessageButton.interactable = false;
    }

    private static void SendMessageFailedCallback()
    {
        SendMessageButton.interactable = true;
        Bubble.Show(null, Language.GetStr(LanguageLabel.UI__AH_SendPrivateMessageFailed));
    }

    private static void SendMessageSucceedCallback(string targetSerialNumber, string content)
    {
        SendMessageButton.interactable = true;
        if (IsPanelOpen && targetSerialNumber == AccountData.SerialNumber)
        {
            List<VirtualScrollRectItem> keys = ScrollRect.ChildrenDataIndexDictionary.Keys.ToList();
            for (int i = 0; i < keys.Count; i++)
            {
                ScrollRect.ChildrenDataIndexDictionary[keys[i]] = ScrollRect.ChildrenDataIndexDictionary[keys[i]] + 1;
            }
            PrivateMessageData data = new PrivateMessageData(HttpManager.SerialNumber, NickNameManager.NickName, content, HttpManager.CurrentDateTime);
            PrivateMessageItem item = GetItem(data);
            ScrollRect.InsertChildToFirst(0, item, true, -1);

            HttpManager.GetPrivateMessage(targetSerialNumber, "0", RefreshPrivateMessageSucceedCallback, RefreshPrivateMessageFailedCallback);
        }
    }
}