garden_client/Assets/Script/Social/FriendPanel.cs

using System;
using System.Collections;
using System.Collections.Generic;

using UnityEngine;
using UnityEngine.UI;

public class FriendPanel : Regist
{
    #region Config

    public static Text NicknameTitle;
	public static Text ContentTitle;
	public static Text CloseButtonTitle;
	public static Text ApplicantTitle;
	public static Text PanelTitle;
	public static Text AcceptAllButtonTitle;
	public static Text AddFriendTitle;
	public static Text FriendAmountText;
    public static Image NewApplicantFlagImage;
    public static Button OpenPanelButton;
    public static Button AcceptAllButton;
    public static Button AddFriendButton;
    public static Button CloseButton;
    public static Toggle ApplicantButton;
	public static Transform FriendGrid;
    public static Transform ApplicantGrid;
	public static Transform FriendPanelParentMask;
	public static Transform FriendPanelMask;
    public static CanvasGroup PanelParentCanvasGroup;
    public static VirtualScrollRectPlus FriendScrollRect;
    public static VirtualScrollRectPlus ApplicantScrollRect;

    private static float RefreshApplicantTime = 15f;
    private static float RefreshApplicantTimer = RefreshApplicantTime;
    private static List<ApplicantItem> ApplicantItems = new List<ApplicantItem>();
    public static List<AccountData> ApplicantAccountDatas = new List<AccountData>();

    public static int MaxFriend
    {
        get { return maxFriend; }
        set
        {
            maxFriend = value;
            UpdateFriendAmountText();
        }
    }
    public static int maxFriend = 25;
    private static float RefreshFriendTime = 15f;
    private static float RefreshFriendTimer = RefreshFriendTime;
    public static List<FriendItem> FriendItems = new List<FriendItem>();
    public static List<AccountData> FriendAccountDatas = new List<AccountData>();

    public static bool HaveNewApplicant;
    public static bool HaveNewPrivateMessage
    {
        get { return haveNewPrivateMessage; }
        set
        {
            haveNewPrivateMessage = value;
            UpdateFriendButtonOutlineStatus();
        }
    }
    public static bool haveNewPrivateMessage;
    public static TweenOutline OpenPanelButtonOutlineTween;

    public static int ActivateLevel = TutorialManager.VisitTutorialLevel;

    public static Action<List<AccountData>> OnFriendListRefresh;

    #endregion

    public override void ThirdInit()
    {
        RefreshFriendList();
    }

    public override void RegistReference()
    {
        NicknameTitle = ResourceManager.Get<Text>(ObjectLabel.AF_NicknameTitle);
        ContentTitle = ResourceManager.Get<Text>(ObjectLabel.AF_ContentTitle);
        CloseButtonTitle = ResourceManager.Get<Text>(ObjectLabel.AF_CloseButtonTitle);
        ApplicantTitle = ResourceManager.Get<Text>(ObjectLabel.AF_ApplicantTitle);
        PanelTitle = ResourceManager.Get<Text>(ObjectLabel.AF_PanelTitle);
        AcceptAllButtonTitle = ResourceManager.Get<Text>(ObjectLabel.AF_AcceptAllButtonTitle);
        AddFriendTitle = ResourceManager.Get<Text>(ObjectLabel.AF_AddFriendTitle);
        FriendAmountText = ResourceManager.Get<Text>(ObjectLabel.AF_FriendAmountText);
        NewApplicantFlagImage = ResourceManager.Get<Image>(ObjectLabel.AF_NewApplicantFlagImage);
        AcceptAllButton = ResourceManager.Get<Button>(ObjectLabel.AF_AcceptAllButton);
        AddFriendButton = ResourceManager.Get<Button>(ObjectLabel.AF_AddFriendButton);
        CloseButton = ResourceManager.Get<Button>(ObjectLabel.AF_CloseButton);
        ApplicantButton = ResourceManager.Get<Toggle>(ObjectLabel.AF_ApplicantButton);
        OpenPanelButton = ResourceManager.Get<Button>(ObjectLabel.C_FriendButton);
        FriendGrid = ResourceManager.Get(ObjectLabel.AF_FriendGrid);
        ApplicantGrid = ResourceManager.Get(ObjectLabel.AF_ApplicantGrid);
        FriendPanelParentMask = ResourceManager.Get(ObjectLabel.AF_FriendPanelParent);
        FriendPanelMask = ResourceManager.Get(ObjectLabel.AF_FriendPanelMask);
        PanelParentCanvasGroup = ResourceManager.Get<CanvasGroup>(ObjectLabel.AF_FriendPanelParent);
        FriendScrollRect = ResourceManager.Get<VirtualScrollRectPlus>(ObjectLabel.AF_FriendScrollRect);
        ApplicantScrollRect = ResourceManager.Get<VirtualScrollRectPlus>(ObjectLabel.AF_ApplicantScrollRect);

        LanguageManager.Add(NicknameTitle, Language.GetStr(LanguageLabel.UI__AF_NicknameTitle));
        LanguageManager.Add(ContentTitle, Language.GetStr(LanguageLabel.UI__AF_ContentTitle));
        LanguageManager.Add(CloseButtonTitle, Language.GetStr(LanguageLabel.UI__AF_CloseButtonTitle));
        LanguageManager.Add(ApplicantTitle, Language.GetStr(LanguageLabel.UI__AF_ApplicantTitle));
        LanguageManager.Add(PanelTitle, Language.GetStr(LanguageLabel.UI__AF_PanelTitle));
        LanguageManager.Add(AcceptAllButtonTitle, Language.GetStr(LanguageLabel.UI__AF_AcceptAllButtonTitle));
        LanguageManager.Add(AddFriendTitle, Language.GetStr(LanguageLabel.UI__AF_AddFriendTitle));

        OpenPanelButton.CreateTweenCG(0, 1, 0.25f, false, true, Curve.EaseOutQuad);
        FriendPanelParentMask.CreateTweenCG(0, 1, 0.25f, false, true, Curve.EaseOutQuad);
        FriendPanelMask.CreateTweenCG(0, 1, 0.25f, false, true, Curve.EaseOutQuad);
        OpenPanelButtonOutlineTween = OpenPanelButton.CreateTweenOutline(0, 201/255f, 1f, true, true, Curve.EaseOutQuad);
        OpenPanelButtonOutlineTween.PingPong = true;
        OpenPanelButtonOutlineTween.IgnoreActiveControll = true;

        OpenPanelButton.onClick.AddListener(OpenRootFriendPanel);
        CloseButton.onClick.AddListener(CloseRootFriendPanel);
        ApplicantButton.onValueChanged.AddListener(OnApplicantToggleClick);
        AddFriendButton.onClick.AddListener(OnAddFriendButtonClick);
        AcceptAllButton.onClick.AddListener(OnAcceptAllButtonClick);

        Manager.OnLevelChange += level =>
        {
            if (level >= ActivateLevel) OpenPanelButton.TweenForCG();
        };
    }


    private void Update()
    {
        RefreshApplicantTimer += Time.deltaTime;
        if (RefreshApplicantTimer >= RefreshApplicantTime)
        {
            RefreshApplicantTimer = 0;
            RefreshApplicant();
        }

        RefreshFriendTimer += Time.deltaTime;
        if (RefreshFriendTimer >= RefreshFriendTime)
        {
            RefreshFriendTimer = 0;
            RefreshFriendList();
        }
    }


    public static void PlayFriendButtonOutline()
    {
        if (!OpenPanelButtonOutlineTween.IsPlaying)
        {
            OpenPanelButtonOutlineTween.PingPong = true;
            OpenPanelButtonOutlineTween.StartForward();
        }
    }

    public static void StopFriendButtonOutline()
    {
        if (OpenPanelButtonOutlineTween.IsPlaying)
        {
            OpenPanelButtonOutlineTween.PingPong = false;
            OpenPanelButtonOutlineTween.StartBackward();
        }
    }

    public static void UpdateFriendButtonOutlineStatus()
    {
        if (HaveNewApplicant || HaveNewPrivateMessage)
        {
            PlayFriendButtonOutline();
        }
        else if (!HaveNewApplicant && !HaveNewPrivateMessage)
        {
            StopFriendButtonOutline();
        }
    }


    public static void AddFriendItem(AccountData accountData)
    {
        FriendItem item = ResourceManager.Get(FriendItemLabel.FriendItem, Folder.UI, false, ApplicantScrollRect.content, false, ObjType.FriendItem, typeof(FriendItem)).GetComponent<FriendItem>();
        item.Init();
        item.Reset(accountData);
        item.SetParent(FriendScrollRect.content);
        FriendItems.Add(item);
        FriendAccountDatas.Add(accountData);
        UpdateFriendAmountText();
    }

    public static void SaveFriendItem(FriendItem item)
    {
        ResourceManager.Save(item);
        FriendItems.Remove(item);
        FriendAccountDatas.Remove(item.AccountData);
        UpdateFriendAmountText();
    }

    public static void UpdateFriendAmountText()
    {
        FriendAmountText.text = $"{FriendItems.Count}/{maxFriend}";
    }

    public static void RefreshFriendList()
    {
        HttpManager.GetBuddyList(RefreshFriendListCallback, () => {});
    }

    private static void RefreshFriendListCallback(List<AccountData> accountDatas)
    {
        for (int i = 0; i < FriendItems.Count; i++)
        {
            SaveFriendItem(FriendItems[i--]);
        }
        foreach (var accountData in accountDatas)
        {
            AddFriendItem(accountData);
        }
        FriendAccountDatas = accountDatas;
        if (OnFriendListRefresh != null)
        {
            OnFriendListRefresh.Invoke(accountDatas);
        }
    }


    public static void AddApplicantItem(AccountData accountData)
    {
        ApplicantItem item = ResourceManager.Get(ApplicantItemLabel.ApplicantItem, Folder.UI, false, ApplicantScrollRect.content, false, ObjType.ApplicantItem, typeof(ApplicantItem)).GetComponent<ApplicantItem>();
        item.Init();
        item.Reset(accountData);
        ApplicantItems.Add(item);
        ApplicantAccountDatas.Add(accountData);
    }

    public static void SaveApplicantItem(ApplicantItem item)
    {
        ResourceManager.Save(item);
        ApplicantItems.Remove(item);
        ApplicantAccountDatas.Remove(item.AccountData);
        if (ApplicantItems.Count == 0)
        {
            OnDontHaveApplicant();
        }
        SaveLastApplicantSerialNumber();
        SetNewApplicantStatus();
    }

    private static void RefreshApplicant()
    {
        HttpManager.GetApplicantList(RefreshApplicantCallback, () => { });
    }

    private static void RefreshApplicantCallback(List<AccountData> accountDatas)
    {
        foreach (var applicantItem in ApplicantItems)
        {
            SaveApplicantItem(applicantItem);
        }   
        for (int i = 0; i < accountDatas.Count; i++)
        {
            AddApplicantItem(accountDatas[i]);
        }
        ApplicantAccountDatas = accountDatas;
        if (ApplicantItems.Count > 0)
        {
            OnHaveApplicant();
        }
        else
        {
            OnDontHaveApplicant();
        }
        SetNewApplicantStatus();
    }

    private static void OnHaveApplicant()
    {
        AcceptAllButton.image.material = null;
        AcceptAllButton.interactable = true;
    }

    private static void OnDontHaveApplicant()
    {
        AcceptAllButton.image.material = Lib.GrayMat;
        AcceptAllButton.interactable = false;
    }

    private static void SetNewApplicantStatus()
    {
        string lastApplicantSerialNumber = ConfigManager.GetStringFormConfig(PlayerConfigLabel.LastApplicantSerialNumber);
        if (ApplicantItems.Count == 0 || ApplicantItems.Back(0).AccountData.SerialNumber == lastApplicantSerialNumber)
        {
            NewApplicantFlagImage.SetActive(false);
            HaveNewApplicant = false;
        }
        else
        {
            NewApplicantFlagImage.SetActive(true);
            HaveNewApplicant = true;
        }
        UpdateFriendButtonOutlineStatus();
    }

    private static void SaveLastApplicantSerialNumber()
    {
        if (ApplicantItems.Count > 0)
        {
            ConfigManager.SaveStringToConfig(PlayerConfigLabel.LastApplicantSerialNumber, ApplicantItems.Back(0).AccountData.SerialNumber);
        }
    }


    public static void OpenRootFriendPanel()
    {
        AudioManager.PlayClip(ResourceLabel.BtnClip);
        FriendPanelParentMask.TweenForCG();
    }

    public static void CloseRootFriendPanel()
    {
        AudioManager.PlayClip(ResourceLabel.CloseClip);
        FriendPanelParentMask.TweenBacCG();
    }

    public static void OpenFriendPanel()
    {
        AudioManager.PlayClip(ResourceLabel.BtnClip);
        FriendPanelMask.TweenForCG();
    }

    public static void CloseFriendPanel()
    {
        AudioManager.PlayClip(ResourceLabel.CloseClip);
        FriendPanelMask.TweenBacCG();
    }

    private static void OnApplicantToggleClick(bool value)
    {
        AudioManager.PlayClip(ResourceLabel.BtnClip);
        if (value)
        {
            SaveLastApplicantSerialNumber();
            SetNewApplicantStatus();

            SaveLastApplicantSerialNumber();
            AcceptAllButton.SetActive(true);
            AddFriendButton.SetActive(false);
            ApplicantScrollRect.SetActive(true);
            FriendScrollRect.SetActive(false);
        }
        else
        {
            AcceptAllButton.SetActive(false);
            AddFriendButton.SetActive(true);
            ApplicantScrollRect.SetActive(false);
            FriendScrollRect.SetActive(true);
        }
    }

    private static void OnAddFriendButtonClick()
    {
        AudioManager.PlayClip(ResourceLabel.BtnClip);
        AddFriendPanel.OpenPanel();
    }

    private static void OnAcceptAllButtonClick()
    {
        AudioManager.PlayClip(ResourceLabel.BtnClip);
        foreach (var applicantItem in ApplicantItems)
        {
            applicantItem.OnAcceptButtonClick();
        }
    }


    public static bool IsFriendFull(bool showBubble)
    {
        if (FriendItems.Count >= MaxFriend)
        {
            if (showBubble)
            {
                Bubble.Show(null, Language.GetStr(LanguageLabel.ApplicantItem__FriendFullSelf));
            }
            return true;
        }
        else
        {
            return false;
        }
    }
}