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

namespace SUISS.Cloud
{
	public class SSPStorage
	{
		public SSPStorage(string storageKey, Dictionary<string, object> storage, IMessageController messageController, IPlayernameController playernameController)
		{
			this._storageKey = storageKey;
			this._messageController = messageController;
			this._playernames = playernameController;
			this._storage = storage;
		}

		public Dictionary<string, object> Contents
		{
			get
			{
				return this._storage;
			}
			private set
			{
				Dictionary<string, object> contents = this.Contents;
				contents.Clear();
				foreach (KeyValuePair<string, object> keyValuePair in value)
				{
					contents.Add(keyValuePair.Key, keyValuePair.Value);
				}
			}
		}

		public CloudRequest<MessageErrors?> TrySendToServer()
		{
			return new CloudRequest<MessageErrors?>(this.CoTrySendToServer());
		}

		private IEnumerator CoTrySendToServer()
		{
			CloudRequest<List<IReceivedMessage>, MessageErrors?> inboxCall = this._messageController.Inbox(this._storageKey);
			yield return inboxCall;
			if (inboxCall.Error != null)
			{
				yield return new YieldError<MessageErrors?>(inboxCall.Error);
			}
			if (inboxCall.Result.Count == 0)
			{
				CloudRequest<MessageErrors?> newMessageCall = this._messageController.SendMessage(new Message(this._playernames.PlayerUuid, this._storageKey, this.Contents));
				yield return newMessageCall;
				if (newMessageCall.Error != null)
				{
					yield return new YieldError<MessageErrors?>(newMessageCall.Error);
				}
			}
			else
			{
				IReceivedMessage storageMessage = inboxCall.Result[0];
				CloudRequest<MessageErrors?> updateCall = this._messageController.UpdateMessage(storageMessage, this.Contents);
				yield return updateCall;
				if (updateCall.Error != null)
				{
					if (updateCall.Error.Value == MessageErrors.ConcurrencyError)
					{
						CloudRequest<IReceivedMessage, MessageErrors?> fetchNewVersionCall = this._messageController.GetMessage(storageMessage);
						yield return fetchNewVersionCall;
						if (fetchNewVersionCall.Error != null)
						{
							yield return new YieldError<MessageErrors?>(fetchNewVersionCall.Error);
						}
						this.Contents.Clear();
						foreach (KeyValuePair<string, object> keyValuePair in fetchNewVersionCall.Result.Data)
						{
							this.Contents.Add(keyValuePair.Key, keyValuePair.Value);
						}
						yield return new YieldError<MessageErrors?>(new MessageErrors?(MessageErrors.ConcurrencyError));
					}
					else
					{
						yield return new YieldError<MessageErrors?>(updateCall.Error);
					}
				}
			}
			yield break;
		}

		private IMessageController _messageController;

		private IPlayernameController _playernames;

		private Dictionary<string, object> _storage;

		private string _storageKey;
	}
}