garden_client/Assets/Script/Social/FriendPanel.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Xml;
using Sfs2X.Util;
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 OpenPanelButtonParent;
	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;
    public static List<FriendItem> FriendItems = new List<FriendItem>();
    public static List<AccountData> FriendAccountDatas = new List<AccountData>();

    private static float RefreshPrivateMessageTime = 15f;
    private static float RefreshPrivateMessageTimer;

    public static bool HaveNewApplicant;
    public static bool HaveNewPrivateMessage
    {
        get
        {
            foreach (var friendItem in FriendItems)
            {
                if (HaveNewMessage(friendItem.AccountData.SerialNumber))
                {
                    return true;
                }
            }
            return false;
        }
    }
    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>(CanvasLabel.AF_NicknameTitle);
        ContentTitle = ResourceManager.Get<Text>(CanvasLabel.AF_ContentTitle);
        CloseButtonTitle = ResourceManager.Get<Text>(CanvasLabel.AF_CloseButtonTitle);
        ApplicantTitle = ResourceManager.Get<Text>(CanvasLabel.AF_ApplicantTitle);
        PanelTitle = ResourceManager.Get<Text>(CanvasLabel.AF_PanelTitle);
        AcceptAllButtonTitle = ResourceManager.Get<Text>(CanvasLabel.AF_AcceptAllButtonTitle);
        AddFriendTitle = ResourceManager.Get<Text>(CanvasLabel.AF_AddFriendTitle);
        FriendAmountText = ResourceManager.Get<Text>(CanvasLabel.AF_FriendAmountText);
        NewApplicantFlagImage = ResourceManager.Get<Image>(CanvasLabel.AF_NewApplicantFlagImage);
        AcceptAllButton = ResourceManager.Get<Button>(CanvasLabel.AF_AcceptAllButton);
        AddFriendButton = ResourceManager.Get<Button>(CanvasLabel.AF_AddFriendButton);
        CloseButton = ResourceManager.Get<Button>(CanvasLabel.AF_CloseButton);
        ApplicantButton = ResourceManager.Get<Toggle>(CanvasLabel.AF_ApplicantButton);
        OpenPanelButton = ResourceManager.Get<Button>(CanvasLabel.C_FriendButton);
        OpenPanelButtonParent = ResourceManager.Get(CanvasLabel.C_FriendButtonParent);
        FriendGrid = ResourceManager.Get(CanvasLabel.AF_FriendGrid);
        ApplicantGrid = ResourceManager.Get(CanvasLabel.AF_ApplicantGrid);
        FriendPanelParentMask = ResourceManager.Get(CanvasLabel.AF_FriendPanelParent);
        FriendPanelMask = ResourceManager.Get(CanvasLabel.AF_FriendPanelMask);
        PanelParentCanvasGroup = ResourceManager.Get<CanvasGroup>(CanvasLabel.AF_FriendPanelParent);
        FriendScrollRect = ResourceManager.Get<VirtualScrollRectPlus>(CanvasLabel.AF_FriendScrollRect);
        ApplicantScrollRect = ResourceManager.Get<VirtualScrollRectPlus>(CanvasLabel.AF_ApplicantScrollRect);

        LanguageManager.Add(NicknameTitle, new MulLanStr(LanguageLabel.UI__AF_NicknameTitle));
        LanguageManager.Add(ContentTitle, new MulLanStr(LanguageLabel.UI__AF_ContentTitle));
        LanguageManager.Add(CloseButtonTitle, new MulLanStr(LanguageLabel.UI__AF_CloseButtonTitle));
        LanguageManager.Add(ApplicantTitle, new MulLanStr(LanguageLabel.UI__AF_ApplicantTitle));
        LanguageManager.Add(PanelTitle, new MulLanStr(LanguageLabel.UI__AF_PanelTitle));
        LanguageManager.Add(AcceptAllButtonTitle, new MulLanStr(LanguageLabel.UI__AF_AcceptAllButtonTitle));
        LanguageManager.Add(AddFriendTitle, new MulLanStr(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();
                OpenPanelButtonParent.SetActive(true);
            }
        };

        MessagePanel.OnHaveNewMessage += SortFriendItems;
        VisitManager.OnEnterVisteeGarden += OnEnterVisiteeGarden;
        VisitManager.OnExitVisteeGarden += OnExitVisiteeGarden;
        HttpManager.OnConnect += OnConnect;
    }


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

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

        RefreshPrivateMessageTimer += Time.deltaTime;
        if (RefreshPrivateMessageTimer >= RefreshPrivateMessageTime)
        {
            RefreshPrivateMessageTimer = 0;
            //RefreshPrivateMessage();
        }
    }


    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);
        }
        SortFriendItems(null);
        RefreshPrivateMessage();
    }

    public static void SortFriendItems(string targetSerialNumber)
    {
        FriendItem friendItem = null;
        List<FriendItem> haveNewPrivateMessageItems = new List<FriendItem>();
        List<FriendItem> dontHaveNewPrivateMessageItems = new List<FriendItem>();
        foreach (var item in FriendItems)
        {
            if (item.AccountData.SerialNumber == targetSerialNumber)
            {
                friendItem = item;
            }
            else if (HaveNewMessage(item.AccountData.SerialNumber))
            {
                haveNewPrivateMessageItems.Add(item);
            }
            else
            {
                dontHaveNewPrivateMessageItems.Add(item);
            }
        }

        haveNewPrivateMessageItems.MySort((item0, item1) => item0.AccountData.LastLoginDate.Ticks < item1.AccountData.LastLoginDate.Ticks);
        dontHaveNewPrivateMessageItems.MySort((item0, item1) => item0.AccountData.LastLoginDate.Ticks < item1.AccountData.LastLoginDate.Ticks);

        List<FriendItem> friendItems = new List<FriendItem>();
        friendItems.AddRange(haveNewPrivateMessageItems);
        friendItems.AddRange(dontHaveNewPrivateMessageItems);
        for (int i = 0; i < friendItems.Count; i++)
        {
            friendItems[i].transform.SetSiblingIndex(i);
        }
        if (friendItem != null)
        {
            friendItem.transform.SetAsFirstSibling();
        }
    }


    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)
    {
        for (int i = 0; i < ApplicantItems.Count; i++)
        {
            SaveApplicantItem(ApplicantItems[i--]);
        }
        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);
        }
    }


    private static void RefreshPrivateMessage()
    {
        foreach (var friendAccountData in FriendAccountDatas)
        {
            HttpManager.GetPrivateMessage(friendAccountData.SerialNumber, "0", MessagePanel.RefreshPrivateMessageSucceedCallback, MessagePanel.RefreshPrivateMessageFailedCallback);
        }
    }


    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;
        }
    }


    public static bool IsPrivateMessageNew(string targetSerialNumber, DateTime dateTime)
    {
        XmlNodeList nodes = ConfigManager.ConfigRootNode.SelectSingleNode(PlayerConfigLabel.LastPrivateMessageDate).SelectNodes(PlayerConfigLabel.LastPrivateMessageDate);
        for (int i = 0; i < nodes.Count; i++)
        {
            string[] strings = nodes[i].Attributes[0].Value.Split('|');
            string serialNumber = strings[0];
            DateTime lastDateTime = DateTime.Parse(strings[1]);
            //Debug.Log(dateTime + "    " + lastDateTime);
            //Debug.Log(targetSerialNumber == serialNumber && dateTime == lastDateTime);
            if (targetSerialNumber == serialNumber && dateTime == lastDateTime)
            {
                return false;
            }
        }
        return true;
    }

    public static bool HaveNewMessage(string targetSerialNumber)
    {
        if (MessagePanel.PrivateMessageDataDictionary.ContainsKey(targetSerialNumber))
        {
            PrivateMessageDataStash dataStash = MessagePanel.PrivateMessageDataDictionary[targetSerialNumber];
            if (dataStash.PrivateMessageDatas.Count > 0)
            {
                return IsPrivateMessageNew(targetSerialNumber, dataStash.PrivateMessageDatas[0].Date);
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
    }

    public static void SaveLastPrivateMessageDate(string targetSerialNumber, DateTime dateTime)
    {
        XmlNode parentNode = ConfigManager.ConfigRootNode.SelectSingleNode(PlayerConfigLabel.LastPrivateMessageDate);
        XmlNodeList nodes = parentNode.SelectNodes(PlayerConfigLabel.LastPrivateMessageDate);
        for (int i = 0; i < nodes.Count; i++)
        {
            string[] strings = nodes[i].Attributes[0].Value.Split('|');
            string serialNumber = strings[0];
            if (targetSerialNumber == serialNumber)
            {
                nodes[i].Attributes[0].Value = $"{targetSerialNumber}|{dateTime}";
                //ConfigManager.SaveConfigDocument();
                return;
            }
        }
        
        XmlNode node = ConfigManager.ConfigDocument.CreateNode(XmlNodeType.Element, PlayerConfigLabel.LastPrivateMessageDate, null);
        XmlAttribute attribute = node.Attributes.Append(ConfigManager.ConfigDocument.CreateAttribute(PlayerConfigLabel.AttributeName));
        attribute.Value = $"{targetSerialNumber}|{dateTime}";
        parentNode.AppendChild(node);
        //ConfigManager.SaveConfigDocument();
    }

    public static void DeleteLastPrivateMessageDate(string targetSerialNumber)
    {
        XmlNode parentNode = ConfigManager.ConfigRootNode.SelectSingleNode(PlayerConfigLabel.LastPrivateMessageDate);
        XmlNodeList nodes = parentNode.SelectNodes(PlayerConfigLabel.LastPrivateMessageDate);
        for (int i = 0; i < nodes.Count; i++)
        {
            string[] strings = nodes[i].Attributes[0].Value.Split('|');
            string serialNumber = strings[0];
            if (targetSerialNumber == serialNumber)
            {
                parentNode.RemoveChild(nodes[i]);
                return;
            }
        }
    }


    public static void OnConnect()
    {
        MaxFriend = HttpManager.MaxFriend;
    }

    public static void OnEnterVisiteeGarden()
    {
        OpenPanelButtonParent.SetActive(false);
    }

    public static void OnExitVisiteeGarden()
    {
        OpenPanelButtonParent.SetActive(true);
    }
}