ZhenShiXunYouJi2/Assets/Scripts/SUISS/Cloud/MessageController.cs

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

namespace SUISS.Cloud
{
	public class MessageController : IMessageController
	{
		public MessageController(IPlayernameController playernames, string sparkSocGameId, int buildVersion)
		{
			this._playernames = playernames;
			this._sparkSocGameId = sparkSocGameId;
			this._buildVersion = buildVersion.ToString();
		}

		public CloudRequest<List<IReceivedMessage>, MessageErrors?> Inbox()
		{
			return new CloudRequest<List<IReceivedMessage>, MessageErrors?>(this.CoAccountInbox(string.Empty));
		}

		public CloudRequest<List<IReceivedMessage>, MessageErrors?> Inbox(string messageType)
		{
			return new CloudRequest<List<IReceivedMessage>, MessageErrors?>(this.CoAccountInbox(messageType));
		}

		public CloudRequest<MessageErrors?> MarkAsRead(IReceivedMessage message)
		{
			return new CloudRequest<MessageErrors?>(this.CoMarkAsRead(message));
		}

		public CloudRequest<MessageErrors?> SendMessage(Message message)
		{
			return new CloudRequest<MessageErrors?>(this.CoSendMessage(message));
		}

		public CloudRequest<MessageErrors?> UpdateMessage(IReceivedMessage message, IDictionary<string, object> updatedData)
		{
			return new CloudRequest<MessageErrors?>(this.CoUpdateMessage(message, updatedData));
		}

		public CloudRequest<IReceivedMessage, MessageErrors?> GetMessage(IReceivedMessage message)
		{
			return new CloudRequest<IReceivedMessage, MessageErrors?>(this.CoGetMessage(message));
		}

		public List<IReceivedMessage> AccountMessages
		{
			get
			{
				UnityEngine.Debug.LogWarning("TODO. MessageController.AccountMessages not yet done!");
				return new List<IReceivedMessage>();
			}
			private set
			{
			}
		}

		private IEnumerator CoUpdateMessage(IReceivedMessage message, IDictionary<string, object> updatedData)
		{
			if (this._playerAccessToken.HasExpired)
			{
				CloudRequest<IAccessToken, PlayernameErrors?> requestToken = this._playernames.RequestPlayerAccessToken("messages");
				yield return requestToken;
				if (requestToken.Result != null)
				{
					this._playerAccessToken = requestToken.Result;
				}
				else
				{
					PlayernameErrors value = requestToken.Error.Value;
					if (value != PlayernameErrors.NoInternet)
					{
						if (value != PlayernameErrors.LostValidRefreshToken)
						{
							yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.GeneralError));
						}
						else
						{
							yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.PlayernamesNotLoggedIn));
						}
					}
					else
					{
						yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.NoInternet));
					}
				}
			}
			string url = string.Format("{0}/messages/player/{1}/install/{2}/message/{3}?access_token={4}", new object[]
			{
				"https://messages.sparklingsociety.net",
				this._playernames.PlayerUuid,
				this._playernames.InstallUuid,
				message.MessageUuid,
				this._playerAccessToken.Token
			});
			if (Json.Encode(updatedData) == null)
			{
				UnityEngine.Debug.LogError("IMessageController.UpdateMessage was called with invalid json!");
				yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.GeneralError));
			}
			Dictionary<string, object> json = new Dictionary<string, object>
			{
				{
					"version",
					message.Version
				},
				{
					"data",
					updatedData
				},
				{
					"hash",
					MessageController.randomChars()
				}
			};
			ApiRequest request = ApiRequest.Post(url, json, this._buildVersion, this._sparkSocGameId);
			yield return request;
			if (request.Error != null)
			{
				if (request.Error.NoInternet)
				{
					yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.NoInternet));
				}
				else if (request.Error.ServerError)
				{
					UnityEngine.Debug.LogError("Server error in MessageController: " + request.Error.Error);
					yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.GeneralError));
				}
				else if (request.Error.ErrorCode == 807)
				{
					yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.ConcurrencyError));
				}
				else
				{
					UnityEngine.Debug.LogWarning("Api call failed in FriendsController: " + request.Error.Error);
					yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.GeneralError));
				}
			}
			yield break;
		}

		public IEnumerator CoGetMessage(IReceivedMessage message)
		{
			if (this._playerAccessToken.HasExpired)
			{
				CloudRequest<IAccessToken, PlayernameErrors?> requestToken = this._playernames.RequestPlayerAccessToken("messages");
				yield return requestToken;
				if (requestToken.Result != null)
				{
					this._playerAccessToken = requestToken.Result;
				}
				else
				{
					PlayernameErrors value = requestToken.Error.Value;
					if (value != PlayernameErrors.NoInternet)
					{
						if (value != PlayernameErrors.LostValidRefreshToken)
						{
							yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.GeneralError));
						}
						else
						{
							yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.PlayernamesNotLoggedIn));
						}
					}
					else
					{
						yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.NoInternet));
					}
				}
			}
			string url = string.Format("{0}/messages/player/{1}/install/{2}/message/{3}?access_token={4}", new object[]
			{
				"https://messages.sparklingsociety.net",
				this._playernames.PlayerUuid,
				this._playernames.InstallUuid,
				message.MessageUuid,
				this._playerAccessToken.Token
			});
			ApiRequest request = ApiRequest.Get(url, this._buildVersion, this._sparkSocGameId);
			yield return request;
			if (request.Result != null)
			{
				bool validJson = false;
				object json = Json.Decode(request.Result.Data.ToString(), ref validJson);
				if (validJson)
				{
					ReceivedMessage updatedMessage = ReceivedMessage.FromJson(json);
					if (updatedMessage != null)
					{
						yield return new YieldResult<IReceivedMessage>(updatedMessage);
					}
					else
					{
						UnityEngine.Debug.LogError(string.Format("Api call {0} return unexpected json!", "{0}/messages/player/{1}/install/{2}/message/{3}?access_token={4}"));
						yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.GeneralError));
					}
				}
				else
				{
					UnityEngine.Debug.LogError(string.Format("Api call {0} return unexpected json!", "{0}/messages/player/{1}/install/{2}/message/{3}?access_token={4}"));
					yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.GeneralError));
				}
			}
			else if (request.Error.NoInternet)
			{
				yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.NoInternet));
			}
			else if (request.Error.ServerError)
			{
				UnityEngine.Debug.LogError("Server error in MessageController: " + request.Error.Error);
				yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.GeneralError));
			}
			else
			{
				UnityEngine.Debug.LogWarning("Api call failed in FriendsController: " + request.Error.Error);
				yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.GeneralError));
			}
			yield break;
		}

		private IEnumerator CoAccountInbox(string messageType = "")
		{
			if (this._playerAccessToken.HasExpired)
			{
				CloudRequest<IAccessToken, PlayernameErrors?> requestToken = this._playernames.RequestPlayerAccessToken("messages");
				yield return requestToken;
				if (requestToken.Result != null)
				{
					this._playerAccessToken = requestToken.Result;
				}
				else
				{
					PlayernameErrors value = requestToken.Error.Value;
					if (value != PlayernameErrors.NoInternet)
					{
						if (value != PlayernameErrors.LostValidRefreshToken)
						{
							yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.GeneralError));
						}
						else
						{
							yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.PlayernamesNotLoggedIn));
						}
					}
					else
					{
						yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.NoInternet));
					}
				}
			}
			string url = string.Format("{0}/messages/inbox/{1}/player/{2}?access_token={3}", new object[]
			{
				"https://messages.sparklingsociety.net",
				this._playernames.InstallUuid,
				this._playernames.PlayerUuid,
				this._playerAccessToken.Token
			});
			if (!string.IsNullOrEmpty(messageType))
			{
				url = string.Format("{0}/messages/inbox/{1}/player/{2}/tag/{3}?access_token={4}", new object[]
				{
					"https://messages.sparklingsociety.net",
					this._playernames.InstallUuid,
					this._playernames.PlayerUuid,
					messageType,
					this._playerAccessToken.Token
				});
			}
			ApiRequest request = ApiRequest.Get(url, this._buildVersion, this._sparkSocGameId);
			yield return request;
			if (request.Result != null)
			{
				bool validJson = false;
				object json = Json.Decode(request.Result.Data.ToString(), ref validJson);
				if (validJson && json is Dictionary<string, object>)
				{
					Dictionary<string, object> jsonDict = (Dictionary<string, object>)json;
					if (jsonDict.ContainsKey("playerMessages"))
					{
						List<IReceivedMessage> messages = this.MessagesFromJson(jsonDict["playerMessages"]);
						if (messages != null)
						{
							yield return new YieldResult<List<IReceivedMessage>>(messages);
						}
					}
				}
				UnityEngine.Debug.LogError(string.Format("Api call {0} return unexpected json!", "{0}/messages/player/{1}/install/{2}/message/{3}?access_token={4}"));
				yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.GeneralError));
			}
			else if (request.Error.NoInternet)
			{
				yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.NoInternet));
			}
			else
			{
				if (request.Error.ServerError)
				{
					UnityEngine.Debug.LogError("Server error in MessageController: " + request.Error.Error);
				}
				else
				{
					UnityEngine.Debug.LogWarning("Api call failed in FriendsController: " + request.Error.Error);
				}
				yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.GeneralError));
			}
			yield break;
		}

		private IEnumerator CoMarkAsRead(IReceivedMessage message)
		{
			if (this._playerAccessToken.HasExpired)
			{
				CloudRequest<IAccessToken, PlayernameErrors?> requestToken = this._playernames.RequestPlayerAccessToken("messages");
				yield return requestToken;
				if (requestToken.Result != null)
				{
					this._playerAccessToken = requestToken.Result;
				}
				else
				{
					PlayernameErrors value = requestToken.Error.Value;
					if (value != PlayernameErrors.NoInternet)
					{
						if (value != PlayernameErrors.LostValidRefreshToken)
						{
							yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.GeneralError));
						}
						else
						{
							yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.PlayernamesNotLoggedIn));
						}
					}
					else
					{
						yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.NoInternet));
					}
				}
			}
			string url = string.Format("{0}/messages/read/{1}/player/{2}?access_token={3}", new object[]
			{
				"https://messages.sparklingsociety.net",
				this._playernames.InstallUuid,
				this._playernames.PlayerUuid,
				this._playerAccessToken.Token
			});
			Dictionary<string, object> json = new Dictionary<string, object>
			{
				{
					"messageUuid",
					message.MessageUuid
				}
			};
			ApiRequest request = ApiRequest.Post(url, json, this._buildVersion, this._sparkSocGameId);
			yield return request;
			if (request.Error != null)
			{
				if (request.Error.NoInternet)
				{
					yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.NoInternet));
				}
				else
				{
					if (request.Error.ServerError)
					{
						UnityEngine.Debug.LogError("Server error in MessageController: " + request.Error.Error);
					}
					else
					{
						UnityEngine.Debug.LogWarning("Api call failed in FriendsController: " + request.Error.Error);
					}
					yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.GeneralError));
				}
			}
			yield break;
		}

		private IEnumerator CoSendMessage(Message message)
		{
			if (this._playerAccessToken.HasExpired)
			{
				CloudRequest<IAccessToken, PlayernameErrors?> requestToken = this._playernames.RequestPlayerAccessToken("messages");
				yield return requestToken;
				if (requestToken.Result != null)
				{
					this._playerAccessToken = requestToken.Result;
				}
				else
				{
					PlayernameErrors value = requestToken.Error.Value;
					if (value != PlayernameErrors.NoInternet)
					{
						if (value != PlayernameErrors.LostValidRefreshToken)
						{
							yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.GeneralError));
						}
						else
						{
							yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.PlayernamesNotLoggedIn));
						}
					}
					else
					{
						yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.NoInternet));
					}
				}
			}
			string url = string.Format("{0}/messages/send?access_token={1}", "https://messages.sparklingsociety.net", this._playerAccessToken.Token);
			Dictionary<string, object> json = new Dictionary<string, object>
			{
				{
					"data",
					message.Data
				},
				{
					"fromAccountUuid",
					this._playernames.PlayerUuid
				},
				{
					"fromInstallUuid",
					this._playernames.InstallUuid
				},
				{
					"toAccountUuid",
					message.ToAccountUuid
				},
				{
					"messageType",
					message.MessageType
				}
			};
			ApiRequest request = ApiRequest.Post(url, json, this._buildVersion, this._sparkSocGameId);
			yield return request;
			if (request.Error != null)
			{
				if (request.Error.NoInternet)
				{
					yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.NoInternet));
				}
				else
				{
					if (request.Error.ServerError)
					{
						UnityEngine.Debug.LogError("Server error in MessageController: " + request.Error.Error);
					}
					else
					{
						UnityEngine.Debug.LogWarning("Api call failed in MessageController: " + request.Error.Error);
					}
					yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.GeneralError));
				}
			}
			yield break;
		}

		private static string randomChars()
		{
			string text = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
			char[] array = new char[8];
			System.Random random = new System.Random();
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = text[random.Next(text.Length)];
			}
			return new string(array);
		}

		private List<IReceivedMessage> MessagesFromJson(object json)
		{
			List<object> list = json as List<object>;
			if (list != null)
			{
				List<IReceivedMessage> list2 = new List<IReceivedMessage>();
				foreach (object json2 in list)
				{
					ReceivedMessage receivedMessage = ReceivedMessage.FromJson(json2);
					if (receivedMessage != null)
					{
						list2.Add(receivedMessage);
					}
				}
				return list2;
			}
			return null;
		}

		private const string MessageResourceName = "messages";

		private const string AccountInboxCall = "{0}/messages/inbox/{1}/player/{2}?access_token={3}";

		private const string MarkAsReadCall = "{0}/messages/read/{1}/player/{2}?access_token={3}";

		private const string SendMessageCall = "{0}/messages/send?access_token={1}";

		private const string UpdateMessageCall = "{0}/messages/player/{1}/install/{2}/message/{3}?access_token={4}";

		private const string GetMessageCall = "{0}/messages/player/{1}/install/{2}/message/{3}?access_token={4}";

		private const string AccountInboxCallWithTag = "{0}/messages/inbox/{1}/player/{2}/tag/{3}?access_token={4}";

		private const string ServerUrl = "https://messages.sparklingsociety.net";

		private IPlayernameController _playernames;

		private string _sparkSocGameId;

		private string _buildVersion;

		private IAccessToken _playerAccessToken = new AccessToken();
	}
}