battlearray_client/Assets/Scripts/UI/Team/InviteManager.cs

using UnityEngine;
using UnityEngine.Events;
using System.Collections;
using System.Collections.Generic;
using Sfs2X.Entities.Data;

public class InviteManager
{

	public const int MAX_TEAM_MENBERS = 2;

	private List<InviteData> list;
	private Dictionary<int, InviteData> dict;
	private ClanData clanData;

	private bool clanSet = false;
	private bool dataSet = false;

	public UnityEvent InitCompleted = new UnityEvent();
	public UnityEvent SortUpdate = new UnityEvent ();
	public IntegerEvent StateUpdate = new IntegerEvent ();
	public IntegerEvent ActionUpdate = new IntegerEvent ();

	private int leader;
	private List<int> teamList;

	public UnityEvent TeamUpdated = new UnityEvent();
	public IntegerEvent TeamJoin = new IntegerEvent();
	public IntegerEvent TeamLeft = new IntegerEvent();

	public InviteManager()
	{
		list = new List<InviteData> ();
		dict = new Dictionary<int, InviteData> ();

		teamList = new List<int> ();
	}

	public void Clear()
	{
		clanData = null;
		dict.Clear ();
		list.Clear ();
		clanSet = dataSet = false;
	}

	public void Init()
	{
		if(CheckInitCompleted())
		{
			InitCompleted.Invoke ();
			return;
		}

		ClanManager.GetInstance ().GetClan (Session.GetInstance ().myUserData.clanId, (ClanData data) => {
			clanData = data;
			clanSet = true;
			if(!CheckInitCompleted())
				Session.GetInstance().GetBattleSession().GetMessageManager().ClanInit();
		});
	}

	private bool CheckInitCompleted()
	{
		if(dataSet && clanSet)
		{
			InitCompleted.Invoke ();
			return true;
		}
		return false;
	}

	public void SetData(ISFSArray arr)
	{
		dict.Clear ();
		list.Clear ();

		if (clanData != null) {
			for(int i=0; i<clanData.userList.Count; i++)
			{
				UserData userData = clanData.userList [i];
				Add (userData.id, InviteData.State.Offline);
			}
		}

		for(int i=0; i<arr.Size(); i++)
		{
			Add (StringUtil.ToInt(arr.GetUtfString(i)), InviteData.State.Online);
		}

		dataSet = true;
		Sort ();

		if (!CheckInitCompleted ()) {
			Init ();
		}
	}

	public InviteData GetData(int id)
	{
		InviteData data = null;
		dict.TryGetValue(id, out data);
		return data;
	}

	public List<InviteData> GetDataList()
	{
		return list;
	}

	public void Add(int id, InviteData.State state)
	{
		if (dict.ContainsKey (id)) {
			InviteData data = dict [id];
			data.state = state;
		} else {
			InviteData data = new InviteData ();
			data.id = id;
			data.state = state;
			dict.Add (id, data);
			list.Add (data);
		}

		StateUpdate.Invoke (id);
	}

	public void Offline(int id)
	{
		if(dict.ContainsKey(id))
		{
			InviteData data = dict [id];
			data.state = InviteData.State.Offline;
			Sort ();

			StateUpdate.Invoke (id);
		}
	}

	public void Battle(int id)
	{
		if(dict.ContainsKey(id))
		{
			InviteData data = dict [id];
			data.state = InviteData.State.Battle;
			Sort ();

			StateUpdate.Invoke (id);
		}
	}

	public void Remove(int id)
	{
		if(dict.ContainsKey(id))
		{
			InviteData data = dict [id];
			dict.Remove (id);
			list.Remove (data);
			Sort ();

			StateUpdate.Invoke (id);
		}
	}

	public void Sort()
	{
		list.Sort (SortCompare);
	}

	private static int SortCompare(InviteData a, InviteData b)
	{
		if (a.state == b.state)
			return 0;
		
		if(a.state == InviteData.State.Online && (b.state == InviteData.State.Battle && b.state == InviteData.State.Offline))
		{
			return -1;
		}
		else if(a.state == InviteData.State.Battle && b.state == InviteData.State.Offline)
		{
			return -1;
		}
		else if(a.state == InviteData.State.Battle && b.state == InviteData.State.Online)
		{
			return 1;
		}
		else if(a.state == InviteData.State.Offline && (b.state == InviteData.State.Battle && b.state == InviteData.State.Offline))
		{
			return 1;
		}

		return 0;
	}

	private void SetInTeam(int id)
	{
		if(dict.ContainsKey(id))
		{
			InviteData data = dict [id];
			data.action = InviteData.Action.InTeam;

			ActionUpdate.Invoke (id);
		}
	}

	private void SetOutTeam(int id)
	{
		if(dict.ContainsKey(id))
		{
			InviteData data = dict [id];
			data.action = InviteData.Action.Invite;

			ActionUpdate.Invoke (id);
		}
	}




	public void TeamState(int leader, ISFSArray teamArr)
	{
		this.leader = leader;

		List<int> oldList = teamList;
		teamList = new List<int> ();
		if(teamArr != null)
		{
			for(int i=0; i<teamArr.Size(); i++)
			{
				int id = StringUtil.ToInt(teamArr.GetUtfString (i));
				if (id <= 0) {
					Debuger.LogError ("illegal team mate id "+id);
					continue;
				}

				if(!oldList.Contains(id))
				{
					TeamJoin.Invoke (id);
				}
				else
				{
					oldList.Remove (id);
				}

				teamList.Add (id);
				SetInTeam (id);
			}
		}

		for(int i=0; i<oldList.Count; i++)
		{
			int id = oldList [i];
			SetOutTeam (id);
			TeamLeft.Invoke (id);
		}

		TeamUpdated.Invoke ();
	}



	public bool IsLeader(int id)
	{
		return id == leader;
	}

	public bool IsInTeam(int id)
	{
		if (teamList.Count <= 1)
			return false;

		return teamList.Contains (id);
	}

	public List<int> GetTeamList()
	{
		return teamList;
	}



	private static InviteManager instance;
	public static InviteManager GetInstance()
	{
		if (instance == null)
			instance = new InviteManager ();
		return instance;
	}

}