using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.Linq;
using System.Numerics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Archipelago.Gifting.Net.Service.Result;
using Archipelago.Gifting.Net.Service.TraitAcceptance;
using Archipelago.Gifting.Net.Utilities;
using Archipelago.Gifting.Net.Versioning;
using Archipelago.Gifting.Net.Versioning.GiftBoxes;
using Archipelago.Gifting.Net.Versioning.GiftBoxes.Current;
using Archipelago.Gifting.Net.Versioning.GiftBoxes.Version2;
using Archipelago.Gifting.Net.Versioning.Gifts;
using Archipelago.Gifting.Net.Versioning.Gifts.Current;
using Archipelago.Gifting.Net.Versioning.Gifts.Version1;
using Archipelago.Gifting.Net.Versioning.Gifts.Version2;
using Archipelago.MultiClient.Net;
using Archipelago.MultiClient.Net.Enums;
using Archipelago.MultiClient.Net.Helpers;
using Archipelago.MultiClient.Net.Models;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: ComVisible(false)]
[assembly: Guid("d87ec5d2-c3db-4f65-897d-8068f3e2da7d")]
[assembly: InternalsVisibleTo("Archipelago.Gifting.Net.Tests")]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("KaitoKid")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription(".NET library for Archipelago Gifting")]
[assembly: AssemblyFileVersion("0.4.3")]
[assembly: AssemblyInformationalVersion("0.4.3+0939ad9dbf643d73b4c0f49fac03d54700d4fa80")]
[assembly: AssemblyProduct("Archipelago.Gifting.Net")]
[assembly: AssemblyTitle("Archipelago.Gifting.Net")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/agilbert1412/Archipelago.Gifting.Net")]
[assembly: AssemblyVersion("0.4.3.0")]
namespace Archipelago.Gifting.Net.Utilities
{
	internal class PlayerProvider
	{
		private ArchipelagoSession _session;

		public PlayerInfo CurrentPlayer => GetPlayer(_session.ConnectionInfo.Slot);

		public string CurrentPlayerName => CurrentPlayer.Name;

		public int CurrentPlayerTeam => _session.ConnectionInfo.Team;

		public int CurrentPlayerSlot => _session.ConnectionInfo.Slot;

		public string CurrentPlayerGame => _session.ConnectionInfo.Game;

		public PlayerProvider(ArchipelagoSession session)
		{
			_session = session;
		}

		public bool TryGetPlayer(string playerName, out PlayerInfo player)
		{
			return TryGetPlayer(playerName, CurrentPlayerTeam, out player);
		}

		public bool TryGetPlayer(string playerName, int playerTeam, out PlayerInfo player)
		{
			foreach (PlayerInfo item in _session.Players.Players[playerTeam])
			{
				if (item.Name == playerName)
				{
					player = item;
					return true;
				}
			}
			player = null;
			int num = 0;
			foreach (PlayerInfo item2 in _session.Players.Players[playerTeam])
			{
				Match match = Regex.Match(item2.Alias, "(.+) \\((.+)\\)");
				if (match.Success && match.Groups.Count >= 3 && match.Groups[1].Value == playerName)
				{
					num++;
					player = item2;
				}
			}
			return num == 1;
		}

		public PlayerInfo GetPlayer(string playerName)
		{
			return GetPlayer(playerName, CurrentPlayerTeam);
		}

		public PlayerInfo GetPlayer(string playerName, int playerTeam)
		{
			return _session.Players.Players[playerTeam].First((PlayerInfo player) => player.Name == playerName);
		}

		public PlayerInfo GetPlayer(int playerSlot)
		{
			return GetPlayer(playerSlot, CurrentPlayerTeam);
		}

		public PlayerInfo GetPlayer(int playerSlot, int playerTeam)
		{
			return _session.Players.Players[playerTeam].First((PlayerInfo player) => player.Slot == playerSlot);
		}

		public IEnumerable<int> GetAllTeams()
		{
			return _session.Players.Players.Keys;
		}

		public IEnumerable<int> GetAllPlayerSlotsInTeam(int playerTeam)
		{
			return _session.Players.Players[playerTeam].Select((PlayerInfo x) => x.Slot);
		}
	}
}
namespace Archipelago.Gifting.Net.Utilities.CloseTraitParser
{
	public class BKTreeCloseTraitParser<T> : ICloseTraitParser<T>
	{
		public delegate double DistanceDelegate(Archipelago.Gifting.Net.Versioning.Gifts.Current.GiftTrait[] giftTraits, Dictionary<string, Tuple<double, double>> traits, out bool isCompatible);

		private readonly List<T> _items;

		private readonly Dictionary<string, Tuple<double, double>> _traits;

		private readonly Dictionary<double, BKTreeCloseTraitParser<T>> _children;

		private readonly DistanceDelegate _distance;

		public BKTreeCloseTraitParser(DistanceDelegate distanceDelegate = null)
		{
			_items = new List<T>();
			_traits = new Dictionary<string, Tuple<double, double>>();
			_children = new Dictionary<double, BKTreeCloseTraitParser<T>>();
			_distance = distanceDelegate ?? new DistanceDelegate(DefaultDistance);
		}

		private static double DefaultDistance(Archipelago.Gifting.Net.Versioning.Gifts.Current.GiftTrait[] giftTraits, Dictionary<string, Tuple<double, double>> traits, out bool isCompatible)
		{
			Dictionary<string, Tuple<double, double>> dictionary = new Dictionary<string, Tuple<double, double>>(traits);
			double num = 0.0;
			foreach (Archipelago.Gifting.Net.Versioning.Gifts.Current.GiftTrait giftTrait in giftTraits)
			{
				if (dictionary.TryGetValue(giftTrait.Trait, out var value))
				{
					dictionary.Remove(giftTrait.Trait);
					if (value.Item1 * giftTrait.Quality <= 0.0)
					{
						num += 1.0;
					}
					else
					{
						double num2 = value.Item1 / giftTrait.Quality;
						num += 1.0 - ((num2 > 1.0) ? (1.0 / num2) : num2);
					}
					if (value.Item2 * giftTrait.Duration <= 0.0)
					{
						num += 1.0;
						continue;
					}
					double num3 = value.Item2 / giftTrait.Duration;
					num += 1.0 - ((num3 > 1.0) ? (1.0 / num3) : num3);
				}
				else
				{
					num += 1.0;
				}
			}
			num += (double)dictionary.Count;
			isCompatible = dictionary.Count != traits.Count;
			return num;
		}

		public void RegisterAvailableGift(T availableGift, Archipelago.Gifting.Net.Versioning.Gifts.Current.GiftTrait[] traits)
		{
			if (_items.Count == 0)
			{
				_items.Add(availableGift);
				foreach (Archipelago.Gifting.Net.Versioning.Gifts.Current.GiftTrait giftTrait in traits)
				{
					if (_traits.TryGetValue(giftTrait.Trait, out var value))
					{
						_traits[giftTrait.Trait] = new Tuple<double, double>(value.Item1 + giftTrait.Quality, value.Item2 + giftTrait.Duration);
					}
					else
					{
						_traits[giftTrait.Trait] = new Tuple<double, double>(giftTrait.Quality, giftTrait.Duration);
					}
				}
				return;
			}
			bool isCompatible;
			double num = _distance(traits, _traits, out isCompatible);
			if (num == 0.0)
			{
				_items.Add(availableGift);
				return;
			}
			if (!_children.TryGetValue(num, out var value2))
			{
				value2 = new BKTreeCloseTraitParser<T>(_distance);
				_children[num] = value2;
			}
			value2.RegisterAvailableGift(availableGift, traits);
		}

		private void FindClosestAvailableGift(Archipelago.Gifting.Net.Versioning.Gifts.Current.GiftTrait[] giftTraits, ref double bestDistance, ref List<T> closestItems)
		{
			bool isCompatible;
			double num = _distance(giftTraits, _traits, out isCompatible);
			if (isCompatible)
			{
				if (Math.Abs(num - bestDistance) < 0.0001)
				{
					closestItems.AddRange(_items);
				}
				else if (num < bestDistance)
				{
					closestItems.Clear();
					closestItems.AddRange(_items);
					bestDistance = num;
				}
			}
			foreach (KeyValuePair<double, BKTreeCloseTraitParser<T>> child in _children)
			{
				if (num - child.Key < bestDistance + 0.0001)
				{
					child.Value.FindClosestAvailableGift(giftTraits, ref bestDistance, ref closestItems);
				}
			}
		}

		public List<T> FindClosestAvailableGift(Archipelago.Gifting.Net.Versioning.Gifts.Current.GiftTrait[] giftTraits)
		{
			List<T> closestItems = new List<T>();
			double bestDistance = double.MaxValue;
			FindClosestAvailableGift(giftTraits, ref bestDistance, ref closestItems);
			return closestItems;
		}
	}
	public interface ICloseTraitParser<T>
	{
		void RegisterAvailableGift(T availableGift, Archipelago.Gifting.Net.Versioning.Gifts.Current.GiftTrait[] traits);

		List<T> FindClosestAvailableGift(Archipelago.Gifting.Net.Versioning.Gifts.Current.GiftTrait[] traits);
	}
}
namespace Archipelago.Gifting.Net.Traits
{
	public class GiftFlag
	{
		public const string None = "None";

		public const string Speed = "Speed";

		public const string Consumable = "Consumable";

		public const string Food = "Food";

		public const string Drink = "Drink";

		public const string Heal = "Heal";

		public const string Mana = "Mana";

		public const string Key = "Key";

		public const string Trap = "Trap";

		public const string Buff = "Buff";

		public const string Life = "Life";

		public const string Weapon = "Weapon";

		public const string Armor = "Armor";

		public const string Tool = "Tool";

		public const string Fish = "Fish";

		public const string Animal = "Animal";

		public const string Cure = "Cure";

		public const string Seed = "Seed";

		public const string Metal = "Metal";

		public const string Bomb = "Bomb";

		public const string Monster = "Monster";

		public const string Resource = "Resource";

		public const string Material = "Material";

		public const string Wood = "Wood";

		public const string Stone = "Stone";

		public const string Ore = "Ore";

		public const string Grass = "Grass";

		public const string Meat = "Meat";

		public const string Vegetable = "Vegetable";

		public const string Fruit = "Fruit";

		public const string Egg = "Egg";

		public const string Slowness = "Slowness";

		public const string Currency = "Currency";

		public const string Damage = "Damage";

		public const string Fire = "Fire";

		public const string Ice = "Ice";

		public const string Energy = "Energy";

		public const string Light = "Light";

		public static readonly string[] AllFlags = new string[37]
		{
			"Speed", "Consumable", "Food", "Drink", "Heal", "Mana", "Key", "Trap", "Buff", "Life",
			"Weapon", "Armor", "Tool", "Fish", "Animal", "Cure", "Seed", "Metal", "Bomb", "Monster",
			"Resource", "Material", "Wood", "Stone", "Ore", "Grass", "Meat", "Vegetable", "Fruit", "Slowness",
			"Currency", "Damage", "Fire", "Ice", "Egg", "Energy", "Light"
		};
	}
}
namespace Archipelago.Gifting.Net.Versioning
{
	internal static class DataVersion
	{
		public const int GIFT_DATA_VERSION_1 = 1;

		public const int GIFT_DATA_VERSION_2 = 2;

		public const int GIFT_DATA_VERSION_3 = 3;

		public static int FirstVersion => 1;

		public static int Current => 3;
	}
	internal interface IVersionedConverter<TKey, TCurrentObject, TPreviousObject>
	{
		int Version { get; }

		int PreviousVersion { get; }

		Dictionary<TKey, TCurrentObject> ReadFromDataStorage(DataStorageElement element);

		Dictionary<TKey, TCurrentObject> ReadFromDataStorage(JToken element);

		TCurrentObject ConvertToCurrentVersion(TPreviousObject olderItem);

		TPreviousObject ConvertToPreviousVersion(TCurrentObject currentItem);

		IDictionary CreateDataStorageUpdateEntry(TKey key, TCurrentObject item, int version);
	}
}
namespace Archipelago.Gifting.Net.Versioning.GiftBoxes
{
	internal class GiftBoxKeyProvider
	{
		public const string MOTHERBOX_KEY_FORMAT = "GiftBoxes;{0}";

		public const string GIFTBOX_KEY_FORMAT = "GiftBox;{0};{1}";

		private ArchipelagoSession _session;

		private PlayerProvider _playerProvider;

		public GiftBoxKeyProvider(ArchipelagoSession session, PlayerProvider playerProvider)
		{
			_session = session;
			_playerProvider = playerProvider;
		}

		public string GetMotherBoxDataStorageKey()
		{
			return GetMotherBoxDataStorageKey(_playerProvider.CurrentPlayerTeam);
		}

		public string GetMotherBoxDataStorageKey(int playerTeam)
		{
			return $"GiftBoxes;{playerTeam}";
		}

		public string GetGiftBoxDataStorageKey()
		{
			return GetGiftBoxDataStorageKey(_playerProvider.CurrentPlayerSlot);
		}

		public string GetGiftBoxDataStorageKey(int playerSlot)
		{
			return GetGiftBoxDataStorageKey(_playerProvider.CurrentPlayerTeam, playerSlot);
		}

		public string GetGiftBoxDataStorageKey(int playerTeam, int playerSlot)
		{
			return $"GiftBox;{playerTeam};{playerSlot}";
		}
	}
	internal interface IVersionedGiftBoxConverter<TCurrentGiftBox, TPreviousGiftBox> : IVersionedConverter<int, TCurrentGiftBox, TPreviousGiftBox>
	{
	}
}
namespace Archipelago.Gifting.Net.Versioning.GiftBoxes.Version2
{
	internal class GiftBox
	{
		public bool IsOpen { get; set; }

		public bool AcceptsAnyGift { get; set; }

		public string[] DesiredTraits { get; set; }

		public int MinimumGiftDataVersion { get; set; }

		public int MaximumGiftDataVersion { get; set; }

		internal GiftBox()
		{
		}

		internal GiftBox(bool isOpen)
			: this()
		{
			IsOpen = isOpen;
			AcceptsAnyGift = true;
			DesiredTraits = new string[0];
			MinimumGiftDataVersion = DataVersion.FirstVersion;
			MaximumGiftDataVersion = 2;
		}

		internal GiftBox(bool acceptsAnyGift, string[] desiredTraits)
			: this(isOpen: true)
		{
			AcceptsAnyGift = acceptsAnyGift;
			DesiredTraits = desiredTraits;
		}
	}
	internal class GiftBoxConverter : IVersionedGiftBoxConverter<GiftBox, object>, IVersionedConverter<int, GiftBox, object>
	{
		public int Version => 1;

		public int PreviousVersion => Version - 1;

		public Dictionary<int, GiftBox> ReadFromDataStorage(DataStorageElement element)
		{
			try
			{
				return element.To<Dictionary<int, GiftBox>>() ?? new Dictionary<int, GiftBox>();
			}
			catch (Exception)
			{
				return new Dictionary<int, GiftBox>();
			}
		}

		public Dictionary<int, GiftBox> ReadFromDataStorage(JToken element)
		{
			try
			{
				return element.ToObject<Dictionary<int, GiftBox>>() ?? new Dictionary<int, GiftBox>();
			}
			catch (Exception)
			{
				return new Dictionary<int, GiftBox>();
			}
		}

		public IDictionary CreateDataStorageUpdateEntry(int ownerSlot, GiftBox giftBox, int version)
		{
			if (version < Version)
			{
				throw new VersionNotFoundException($"Tried to create a giftBox for an unknown version: {version}");
			}
			return new Dictionary<int, GiftBox> { { ownerSlot, giftBox } };
		}

		public GiftBox ConvertToCurrentVersion(object olderGiftBox)
		{
			throw new NotImplementedException();
		}

		public object ConvertToPreviousVersion(GiftBox currentGiftBox)
		{
			throw new NotImplementedException();
		}
	}
}
namespace Archipelago.Gifting.Net.Versioning.GiftBoxes.Current
{
	public class GiftBox
	{
		[JsonProperty("is_open")]
		public bool IsOpen { get; set; }

		[JsonProperty("accepts_any_gift")]
		public bool AcceptsAnyGift { get; set; }

		[JsonProperty("desired_traits")]
		public string[] DesiredTraits { get; set; }

		[JsonProperty("minimum_gift_data_version")]
		public int MinimumGiftDataVersion { get; set; }

		[JsonProperty("maximum_gift_data_version")]
		public int MaximumGiftDataVersion { get; set; }

		public GiftBox()
		{
		}

		internal GiftBox(bool isOpen)
			: this()
		{
			IsOpen = isOpen;
			AcceptsAnyGift = true;
			DesiredTraits = new string[0];
			MinimumGiftDataVersion = DataVersion.FirstVersion;
			MaximumGiftDataVersion = DataVersion.Current;
		}

		internal GiftBox(bool acceptsAnyGift, string[] desiredTraits)
			: this(isOpen: true)
		{
			AcceptsAnyGift = acceptsAnyGift;
			DesiredTraits = desiredTraits;
		}
	}
	internal class GiftBoxConverter : IVersionedGiftBoxConverter<GiftBox, Archipelago.Gifting.Net.Versioning.GiftBoxes.Version2.GiftBox>, IVersionedConverter<int, GiftBox, Archipelago.Gifting.Net.Versioning.GiftBoxes.Version2.GiftBox>
	{
		private IVersionedGiftBoxConverter<Archipelago.Gifting.Net.Versioning.GiftBoxes.Version2.GiftBox, object> _previousConverter;

		public int Version => 3;

		public int PreviousVersion => 2;

		public GiftBoxConverter()
		{
			_previousConverter = new Archipelago.Gifting.Net.Versioning.GiftBoxes.Version2.GiftBoxConverter();
		}

		public Dictionary<int, GiftBox> ReadFromDataStorage(DataStorageElement element)
		{
			try
			{
				Dictionary<int, GiftBox> dictionary = element.To<Dictionary<int, GiftBox>>() ?? new Dictionary<int, GiftBox>();
				Dictionary<int, Archipelago.Gifting.Net.Versioning.GiftBoxes.Version2.GiftBox> dictionary2 = _previousConverter.ReadFromDataStorage(element);
				foreach (int key in dictionary2.Keys)
				{
					try
					{
						if (!dictionary.ContainsKey(key) || HasInvalidFields(dictionary[key]))
						{
							dictionary[key] = ConvertToCurrentVersion(dictionary2[key]);
						}
					}
					catch (Exception)
					{
					}
				}
				return dictionary;
			}
			catch (Exception)
			{
				return new Dictionary<int, GiftBox>();
			}
		}

		public Dictionary<int, GiftBox> ReadFromDataStorage(JToken element)
		{
			try
			{
				Dictionary<int, GiftBox> dictionary = element.ToObject<Dictionary<int, GiftBox>>() ?? new Dictionary<int, GiftBox>();
				Dictionary<int, Archipelago.Gifting.Net.Versioning.GiftBoxes.Version2.GiftBox> dictionary2 = _previousConverter.ReadFromDataStorage(element);
				foreach (int key in dictionary2.Keys)
				{
					try
					{
						if (!dictionary.ContainsKey(key) || HasInvalidFields(dictionary[key]))
						{
							dictionary[key] = ConvertToCurrentVersion(dictionary2[key]);
						}
					}
					catch (Exception)
					{
					}
				}
				return dictionary;
			}
			catch (Exception)
			{
				return new Dictionary<int, GiftBox>();
			}
		}

		private bool HasInvalidFields(GiftBox giftBox)
		{
			if (giftBox != null && giftBox.MinimumGiftDataVersion >= DataVersion.FirstVersion)
			{
				return giftBox.MaximumGiftDataVersion < DataVersion.FirstVersion;
			}
			return true;
		}

		public IDictionary CreateDataStorageUpdateEntry(int ownerSlot, GiftBox giftBox, int version)
		{
			if (version < Version)
			{
				return _previousConverter.CreateDataStorageUpdateEntry(ownerSlot, ConvertToPreviousVersion(giftBox), version);
			}
			return new Dictionary<int, GiftBox> { { ownerSlot, giftBox } };
		}

		public GiftBox ConvertToCurrentVersion(Archipelago.Gifting.Net.Versioning.GiftBoxes.Version2.GiftBox olderGift)
		{
			return new GiftBox
			{
				AcceptsAnyGift = olderGift.AcceptsAnyGift,
				DesiredTraits = olderGift.DesiredTraits,
				IsOpen = olderGift.IsOpen,
				MaximumGiftDataVersion = olderGift.MaximumGiftDataVersion,
				MinimumGiftDataVersion = olderGift.MinimumGiftDataVersion
			};
		}

		public Archipelago.Gifting.Net.Versioning.GiftBoxes.Version2.GiftBox ConvertToPreviousVersion(GiftBox currentGift)
		{
			return new Archipelago.Gifting.Net.Versioning.GiftBoxes.Version2.GiftBox
			{
				AcceptsAnyGift = currentGift.AcceptsAnyGift,
				DesiredTraits = currentGift.DesiredTraits,
				IsOpen = currentGift.IsOpen,
				MaximumGiftDataVersion = currentGift.MaximumGiftDataVersion,
				MinimumGiftDataVersion = currentGift.MinimumGiftDataVersion
			};
		}
	}
}
namespace Archipelago.Gifting.Net.Versioning.Gifts
{
	public class GiftItem
	{
		public string Name { get; set; }

		public int Amount { get; set; }

		public BigInteger Value { get; set; }

		public GiftItem(string name, int amount, BigInteger value)
		{
			Name = name;
			Amount = amount;
			Value = value;
		}
	}
	internal interface IVersionedGiftConverter<TCurrentGift, TPreviousGift> : IVersionedConverter<string, TCurrentGift, TPreviousGift>
	{
	}
}
namespace Archipelago.Gifting.Net.Versioning.Gifts.Version2
{
	internal class Gift
	{
		public string ID { get; set; }

		public string ItemName { get; set; }

		public int Amount { get; set; }

		public BigInteger ItemValue { get; set; }

		public GiftTrait[] Traits { get; set; }

		public int SenderSlot { get; set; }

		public int ReceiverSlot { get; set; }

		public int SenderTeam { get; set; }

		public int ReceiverTeam { get; set; }

		public bool IsRefund { get; set; }

		public Gift()
		{
		}

		public Gift(string itemName, int amount, BigInteger itemValue, GiftTrait[] traits, int senderSlot, int receiverSlot, int senderTeam, int receiverTeam)
		{
			ID = Guid.NewGuid().ToString();
			ItemName = itemName;
			Amount = amount;
			ItemValue = itemValue;
			Traits = traits;
			SenderSlot = senderSlot;
			ReceiverSlot = receiverSlot;
			SenderTeam = senderTeam;
			ReceiverTeam = receiverTeam;
			IsRefund = false;
		}
	}
	internal class GiftConverter : IVersionedGiftConverter<Gift, Archipelago.Gifting.Net.Versioning.Gifts.Version1.Gift>, IVersionedConverter<string, Gift, Archipelago.Gifting.Net.Versioning.Gifts.Version1.Gift>
	{
		private PlayerProvider _playerProvider;

		private Validator _validator;

		private IVersionedGiftConverter<Archipelago.Gifting.Net.Versioning.Gifts.Version1.Gift, object> _previousConverter;

		public int Version => 2;

		public int PreviousVersion => 1;

		public GiftConverter(PlayerProvider playerProvider)
		{
			_playerProvider = playerProvider;
			_validator = new Validator();
			_previousConverter = new Archipelago.Gifting.Net.Versioning.Gifts.Version1.GiftConverter();
		}

		public Dictionary<string, Gift> ReadFromDataStorage(DataStorageElement element)
		{
			try
			{
				Dictionary<string, Gift> dictionary = element.To<Dictionary<string, Gift>>() ?? new Dictionary<string, Gift>();
				if (_validator.Validate(dictionary, out var errors))
				{
					return dictionary;
				}
				foreach (KeyValuePair<string, Archipelago.Gifting.Net.Versioning.Gifts.Version1.Gift> item in _previousConverter.ReadFromDataStorage(element))
				{
					try
					{
						string key = item.Key;
						Archipelago.Gifting.Net.Versioning.Gifts.Version1.Gift value = item.Value;
						if (!dictionary.ContainsKey(key) || errors.Contains(key))
						{
							dictionary[key] = ConvertToCurrentVersion(value);
						}
					}
					catch (Exception)
					{
					}
				}
				return dictionary;
			}
			catch (Exception)
			{
				return new Dictionary<string, Gift>();
			}
		}

		public Dictionary<string, Gift> ReadFromDataStorage(JToken element)
		{
			try
			{
				Dictionary<string, Gift> dictionary = element.ToObject<Dictionary<string, Gift>>() ?? new Dictionary<string, Gift>();
				if (_validator.Validate(dictionary, out var errors))
				{
					return dictionary;
				}
				foreach (KeyValuePair<string, Archipelago.Gifting.Net.Versioning.Gifts.Version1.Gift> item in _previousConverter.ReadFromDataStorage(element))
				{
					string key = item.Key;
					Archipelago.Gifting.Net.Versioning.Gifts.Version1.Gift value = item.Value;
					if (!dictionary.ContainsKey(key) || errors.Contains(key))
					{
						dictionary[key] = ConvertToCurrentVersion(value);
					}
				}
				return dictionary;
			}
			catch (Exception)
			{
				return new Dictionary<string, Gift>();
			}
		}

		public IDictionary CreateDataStorageUpdateEntry(string id, Gift gift, int version)
		{
			if (version < Version)
			{
				return _previousConverter.CreateDataStorageUpdateEntry(id, ConvertToPreviousVersion(gift), version);
			}
			return new Dictionary<string, Gift> { { id, gift } };
		}

		public Gift ConvertToCurrentVersion(Archipelago.Gifting.Net.Versioning.Gifts.Version1.Gift olderGift)
		{
			PlayerInfo player = _playerProvider.GetPlayer(olderGift.SenderName, olderGift.SenderTeam);
			PlayerInfo player2 = _playerProvider.GetPlayer(olderGift.ReceiverName, olderGift.ReceiverTeam);
			return new Gift(olderGift.Item.Name, olderGift.Item.Amount, olderGift.Item.Value, ConvertTraits(olderGift.Traits), player.Slot, player2.Slot, olderGift.SenderTeam, olderGift.ReceiverTeam)
			{
				ID = olderGift.ID
			};
		}

		public Archipelago.Gifting.Net.Versioning.Gifts.Version1.Gift ConvertToPreviousVersion(Gift currentGift)
		{
			GiftItem item = new GiftItem(currentGift.ItemName, currentGift.Amount, currentGift.ItemValue);
			PlayerInfo player = _playerProvider.GetPlayer(currentGift.SenderSlot, currentGift.SenderTeam);
			return new Archipelago.Gifting.Net.Versioning.Gifts.Version1.Gift(receiverName: _playerProvider.GetPlayer(currentGift.ReceiverSlot, currentGift.ReceiverTeam).Name, item: item, traits: ConvertTraits(currentGift.Traits), senderName: player.Name, senderTeam: currentGift.SenderTeam, receiverTeam: currentGift.ReceiverTeam)
			{
				ID = currentGift.ID
			};
		}

		private GiftTrait[] ConvertTraits(Archipelago.Gifting.Net.Versioning.Gifts.Version1.GiftTrait[] olderGiftTraits)
		{
			return olderGiftTraits.Select((Archipelago.Gifting.Net.Versioning.Gifts.Version1.GiftTrait x) => new GiftTrait(x.Trait, x.Duration, x.Quality)).ToArray();
		}

		private Archipelago.Gifting.Net.Versioning.Gifts.Version1.GiftTrait[] ConvertTraits(GiftTrait[] newerGiftTraits)
		{
			return newerGiftTraits.Select((GiftTrait x) => new Archipelago.Gifting.Net.Versioning.Gifts.Version1.GiftTrait(x.Trait, x.Duration, x.Quality)).ToArray();
		}
	}
	internal class GiftTrait
	{
		public string Trait { get; set; }

		public double Quality { get; set; }

		public double Duration { get; set; }

		public GiftTrait(string trait, double duration, double quality)
		{
			Trait = trait;
			Quality = quality;
			Duration = duration;
		}
	}
	internal class Validator
	{
		public bool Validate(Dictionary<string, Gift> gifts, out IList<string> errors)
		{
			errors = new List<string>();
			if (gifts == null)
			{
				return false;
			}
			bool result = true;
			foreach (KeyValuePair<string, Gift> gift in gifts)
			{
				if (!Validate(gift.Value))
				{
					errors.Add(gift.Key);
					result = false;
				}
			}
			return result;
		}

		public bool Validate(Gift gift)
		{
			if (gift == null)
			{
				return false;
			}
			if (gift.ItemName == null || gift.Amount <= 0 || gift.Traits == null)
			{
				return false;
			}
			return true;
		}
	}
}
namespace Archipelago.Gifting.Net.Versioning.Gifts.Version1
{
	internal class Gift
	{
		public string ID { get; set; }

		public GiftItem Item { get; set; }

		public GiftTrait[] Traits { get; set; }

		public string SenderName { get; set; }

		public string ReceiverName { get; set; }

		public int SenderTeam { get; set; }

		public int ReceiverTeam { get; set; }

		public bool IsRefund { get; set; }

		public BigInteger GiftValue => Item.Amount * Item.Value;

		public Gift()
		{
		}

		public Gift(GiftItem item, GiftTrait[] traits, string senderName, string receiverName, int senderTeam, int receiverTeam)
		{
			ID = Guid.NewGuid().ToString();
			Item = item;
			Traits = traits;
			SenderName = senderName;
			ReceiverName = receiverName;
			SenderTeam = senderTeam;
			ReceiverTeam = receiverTeam;
			IsRefund = false;
		}
	}
	internal class GiftConverter : IVersionedGiftConverter<Gift, object>, IVersionedConverter<string, Gift, object>
	{
		public int Version => 1;

		public int PreviousVersion => Version - 1;

		public Dictionary<string, Gift> ReadFromDataStorage(DataStorageElement element)
		{
			try
			{
				return (element.To<Dictionary<string, Gift>>() ?? new Dictionary<string, Gift>()).ToDictionary((KeyValuePair<string, Gift> x) => x.Key.ToString(), (KeyValuePair<string, Gift> x) => x.Value);
			}
			catch (Exception)
			{
				return new Dictionary<string, Gift>();
			}
		}

		public Dictionary<string, Gift> ReadFromDataStorage(JToken element)
		{
			try
			{
				return (element.ToObject<Dictionary<string, Gift>>() ?? new Dictionary<string, Gift>()).ToDictionary((KeyValuePair<string, Gift> x) => x.Key.ToString(), (KeyValuePair<string, Gift> x) => x.Value);
			}
			catch (Exception)
			{
				return new Dictionary<string, Gift>();
			}
		}

		public IDictionary CreateDataStorageUpdateEntry(string id, Gift gift, int version)
		{
			if (version < Version)
			{
				throw new VersionNotFoundException($"Tried to create a gift for an unknown version: {version}");
			}
			return new Dictionary<Guid, Gift> { 
			{
				Guid.Parse(id),
				gift
			} };
		}

		public Gift ConvertToCurrentVersion(object olderGift)
		{
			throw new NotImplementedException();
		}

		public object ConvertToPreviousVersion(Gift currentGift)
		{
			throw new NotImplementedException();
		}
	}
	internal class GiftTrait
	{
		public string Trait { get; set; }

		public double Quality { get; set; }

		public double Duration { get; set; }

		public GiftTrait(string trait, double duration, double quality)
		{
			Trait = trait;
			Quality = quality;
			Duration = duration;
		}
	}
}
namespace Archipelago.Gifting.Net.Versioning.Gifts.Current
{
	public class Gift
	{
		[JsonProperty("id")]
		public string ID { get; set; }

		[JsonProperty("item_name")]
		public string ItemName { get; set; }

		[JsonProperty("amount")]
		public int Amount { get; set; }

		[JsonProperty("item_value")]
		public BigInteger ItemValue { get; set; }

		[JsonProperty("traits")]
		public GiftTrait[] Traits { get; set; }

		[JsonProperty("sender_slot")]
		public int SenderSlot { get; set; }

		[JsonProperty("receiver_slot")]
		public int ReceiverSlot { get; set; }

		[JsonProperty("sender_team")]
		public int SenderTeam { get; set; }

		[JsonProperty("receiver_team")]
		public int ReceiverTeam { get; set; }

		[JsonProperty("is_refund")]
		public bool IsRefund { get; set; }

		public Gift()
		{
		}

		public Gift(string itemName, int amount, BigInteger itemValue, GiftTrait[] traits, int senderSlot, int receiverSlot, int senderTeam, int receiverTeam)
		{
			ID = Guid.NewGuid().ToString();
			ItemName = itemName;
			Amount = amount;
			ItemValue = itemValue;
			Traits = traits;
			SenderSlot = senderSlot;
			ReceiverSlot = receiverSlot;
			SenderTeam = senderTeam;
			ReceiverTeam = receiverTeam;
			IsRefund = false;
		}
	}
	internal class GiftConverter : IVersionedGiftConverter<Gift, Archipelago.Gifting.Net.Versioning.Gifts.Version2.Gift>, IVersionedConverter<string, Gift, Archipelago.Gifting.Net.Versioning.Gifts.Version2.Gift>
	{
		private readonly Validator _validator;

		private readonly IVersionedGiftConverter<Archipelago.Gifting.Net.Versioning.Gifts.Version2.Gift, Archipelago.Gifting.Net.Versioning.Gifts.Version1.Gift> _previousConverter;

		public int Version => 3;

		public int PreviousVersion => 2;

		public GiftConverter(PlayerProvider playerProvider)
		{
			_validator = new Validator();
			_previousConverter = new Archipelago.Gifting.Net.Versioning.Gifts.Version2.GiftConverter(playerProvider);
		}

		public Dictionary<string, Gift> ReadFromDataStorage(DataStorageElement element)
		{
			try
			{
				Dictionary<string, Gift> dictionary = element.To<Dictionary<string, Gift>>() ?? new Dictionary<string, Gift>();
				if (_validator.Validate(dictionary, out var errors))
				{
					return dictionary;
				}
				foreach (KeyValuePair<string, Archipelago.Gifting.Net.Versioning.Gifts.Version2.Gift> item in _previousConverter.ReadFromDataStorage(element))
				{
					try
					{
						string key = item.Key;
						Archipelago.Gifting.Net.Versioning.Gifts.Version2.Gift value = item.Value;
						if (!dictionary.ContainsKey(key) || errors.Contains(key))
						{
							dictionary[key] = ConvertToCurrentVersion(value);
						}
					}
					catch (Exception)
					{
					}
				}
				return dictionary;
			}
			catch (Exception)
			{
				return new Dictionary<string, Gift>();
			}
		}

		public Dictionary<string, Gift> ReadFromDataStorage(JToken element)
		{
			try
			{
				Dictionary<string, Gift> dictionary = element.ToObject<Dictionary<string, Gift>>() ?? new Dictionary<string, Gift>();
				if (_validator.Validate(dictionary, out var errors))
				{
					return dictionary;
				}
				foreach (KeyValuePair<string, Archipelago.Gifting.Net.Versioning.Gifts.Version2.Gift> item in _previousConverter.ReadFromDataStorage(element))
				{
					string key = item.Key;
					Archipelago.Gifting.Net.Versioning.Gifts.Version2.Gift value = item.Value;
					if (!dictionary.ContainsKey(key) || errors.Contains(key))
					{
						dictionary[key] = ConvertToCurrentVersion(value);
					}
				}
				return dictionary;
			}
			catch (Exception)
			{
				return new Dictionary<string, Gift>();
			}
		}

		public IDictionary CreateDataStorageUpdateEntry(string id, Gift gift, int version)
		{
			if (version < Version)
			{
				return _previousConverter.CreateDataStorageUpdateEntry(id, ConvertToPreviousVersion(gift), version);
			}
			JObject val = JObject.FromObject((object)gift);
			RemoveDefaultValueProperties((JToken)(object)val, new string[1] { "item_value" }, BigInteger.Zero);
			foreach (JProperty item in val.Properties())
			{
				if (item.Name != "traits")
				{
					continue;
				}
				foreach (JToken item2 in (IEnumerable<JToken>)item.Value)
				{
					RemoveDefaultValueProperties(item2, new string[2] { "quality", "duration" }, 1.0);
				}
			}
			return new Dictionary<string, JObject> { { id, val } };
		}

		private static void RemoveDefaultValueProperties(JToken trait, string[] propertiesToCheck, double valueToOmit)
		{
			foreach (string text in propertiesToCheck)
			{
				JToken val = trait[(object)text];
				if (val != null && IsDefaultValue(val, valueToOmit))
				{
					((JToken)val.Parent).Remove();
				}
			}
		}

		private static void RemoveDefaultValueProperties(JToken trait, string[] propertiesToCheck, BigInteger valueToOmit)
		{
			foreach (string text in propertiesToCheck)
			{
				JToken val = trait[(object)text];
				if (val != null && IsDefaultValue(val, valueToOmit))
				{
					((JToken)val.Parent).Remove();
				}
			}
		}

		private static bool IsDefaultValue(JToken quality, double defaultValue)
		{
			return Math.Abs(Extensions.Value<double>((IEnumerable<JToken>)quality) - defaultValue) < 0.001;
		}

		private static bool IsDefaultValue(JToken quality, BigInteger defaultValue)
		{
			return Extensions.Value<BigInteger>((IEnumerable<JToken>)quality) == defaultValue;
		}

		public Gift ConvertToCurrentVersion(Archipelago.Gifting.Net.Versioning.Gifts.Version2.Gift olderGift)
		{
			return new Gift(olderGift.ItemName, olderGift.Amount, olderGift.ItemValue, ConvertTraits(olderGift.Traits), olderGift.SenderSlot, olderGift.ReceiverSlot, olderGift.SenderTeam, olderGift.ReceiverTeam)
			{
				ID = olderGift.ID
			};
		}

		public Archipelago.Gifting.Net.Versioning.Gifts.Version2.Gift ConvertToPreviousVersion(Gift currentGift)
		{
			return new Archipelago.Gifting.Net.Versioning.Gifts.Version2.Gift(currentGift.ItemName, currentGift.Amount, currentGift.ItemValue, ConvertTraits(currentGift.Traits), currentGift.SenderSlot, currentGift.ReceiverSlot, currentGift.SenderTeam, currentGift.ReceiverTeam)
			{
				ID = currentGift.ID
			};
		}

		private GiftTrait[] ConvertTraits(Archipelago.Gifting.Net.Versioning.Gifts.Version2.GiftTrait[] olderGiftTraits)
		{
			return olderGiftTraits.Select((Archipelago.Gifting.Net.Versioning.Gifts.Version2.GiftTrait x) => new GiftTrait(x.Trait, x.Duration, x.Quality)).ToArray();
		}

		private Archipelago.Gifting.Net.Versioning.Gifts.Version2.GiftTrait[] ConvertTraits(GiftTrait[] newerGiftTraits)
		{
			return newerGiftTraits.Select((GiftTrait x) => new Archipelago.Gifting.Net.Versioning.Gifts.Version2.GiftTrait(x.Trait, x.Duration, x.Quality)).ToArray();
		}
	}
	public class GiftTrait
	{
		[JsonProperty("trait")]
		public string Trait { get; set; }

		[JsonProperty("quality")]
		public double Quality { get; set; }

		[JsonProperty("duration")]
		public double Duration { get; set; }

		public GiftTrait()
			: this(null)
		{
		}

		public GiftTrait(string trait)
			: this(trait, 1.0)
		{
		}

		public GiftTrait(string trait, double quality)
			: this(trait, quality, 1.0)
		{
		}

		public GiftTrait(string trait, double quality, double duration)
		{
			Trait = trait;
			Quality = quality;
			Duration = duration;
		}
	}
	internal class Validator
	{
		public bool Validate(Dictionary<string, Gift> gifts, out IList<string> errors)
		{
			errors = new List<string>();
			if (gifts == null)
			{
				return false;
			}
			bool result = true;
			foreach (KeyValuePair<string, Gift> gift in gifts)
			{
				if (!Validate(gift.Value))
				{
					errors.Add(gift.Key);
					result = false;
				}
			}
			return result;
		}

		public bool Validate(Gift gift)
		{
			if (gift == null)
			{
				return false;
			}
			if (gift.ItemName == null || gift.Amount <= 0 || gift.Traits == null)
			{
				return false;
			}
			return true;
		}
	}
}
namespace Archipelago.Gifting.Net.Service
{
	public class GiftingService : IGiftingService, IGiftingServiceSync, IGiftingServiceAsync
	{
		public delegate void GiftReceivedHandler(Archipelago.Gifting.Net.Versioning.Gifts.Current.Gift newGift);

		private ArchipelagoSession _session;

		private PlayerProvider _playerProvider;

		private GiftBoxKeyProvider _keyProvider;

		private Archipelago.Gifting.Net.Versioning.GiftBoxes.Current.GiftBoxConverter _currentGiftBoxConverter;

		private Archipelago.Gifting.Net.Versioning.Gifts.Current.GiftConverter _currentGiftConverter;

		private GiftReceivedHandler _giftReceivedHandler;

		private JToken EmptyMotherboxDictionary => JToken.FromObject((object)new Dictionary<int, Archipelago.Gifting.Net.Versioning.GiftBoxes.Current.GiftBox>());

		private JToken EmptyGiftDictionary => JToken.FromObject((object)new Dictionary<string, Archipelago.Gifting.Net.Versioning.Gifts.Current.Gift>());

		internal PlayerProvider PlayerProvider => _playerProvider;

		public event GiftReceivedHandler OnNewGift
		{
			add
			{
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Expected O, but got Unknown
				if (_giftReceivedHandler == null)
				{
					string giftBoxDataStorageKey = _keyProvider.GetGiftBoxDataStorageKey();
					_session.DataStorage[giftBoxDataStorageKey].OnValueChanged += new DataStorageUpdatedHandler(GiftListener);
				}
				_giftReceivedHandler = (GiftReceivedHandler)Delegate.Combine(_giftReceivedHandler, value);
			}
			remove
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Expected O, but got Unknown
				_giftReceivedHandler = (GiftReceivedHandler)Delegate.Remove(_giftReceivedHandler, value);
				if (_giftReceivedHandler == null)
				{
					string giftBoxDataStorageKey = _keyProvider.GetGiftBoxDataStorageKey();
					_session.DataStorage[giftBoxDataStorageKey].OnValueChanged -= new DataStorageUpdatedHandler(GiftListener);
				}
			}
		}

		public GiftingService(ArchipelagoSession session)
		{
			_session = session;
			_playerProvider = new PlayerProvider(_session);
			_keyProvider = new GiftBoxKeyProvider(_session, _playerProvider);
			_currentGiftBoxConverter = new Archipelago.Gifting.Net.Versioning.GiftBoxes.Current.GiftBoxConverter();
			_currentGiftConverter = new Archipelago.Gifting.Net.Versioning.Gifts.Current.GiftConverter(_playerProvider);
			string motherBoxDataStorageKey = _keyProvider.GetMotherBoxDataStorageKey();
			CreateMotherboxIfNeeded(motherBoxDataStorageKey);
		}

		public string GetMyGiftBoxKey()
		{
			return _keyProvider.GetGiftBoxDataStorageKey();
		}

		public void OpenGiftBox()
		{
			UpdateGiftBox(new Archipelago.Gifting.Net.Versioning.GiftBoxes.Current.GiftBox(isOpen: true));
		}

		public void OpenGiftBox(bool acceptAnyGift, string[] desiredTraits)
		{
			UpdateGiftBox(new Archipelago.Gifting.Net.Versioning.GiftBoxes.Current.GiftBox(acceptAnyGift, desiredTraits));
		}

		public void CloseGiftBox()
		{
			UpdateGiftBox(new Archipelago.Gifting.Net.Versioning.GiftBoxes.Current.GiftBox(isOpen: false));
			EmptyGiftBox();
		}

		public Archipelago.Gifting.Net.Versioning.GiftBoxes.Current.GiftBox GetCurrentGiftBoxState()
		{
			int currentPlayerTeam = _playerProvider.CurrentPlayerTeam;
			int currentPlayerSlot = _playerProvider.CurrentPlayerSlot;
			Dictionary<int, Archipelago.Gifting.Net.Versioning.GiftBoxes.Current.GiftBox> motherbox = GetMotherbox(currentPlayerTeam);
			if (!motherbox.ContainsKey(currentPlayerSlot))
			{
				return null;
			}
			return motherbox[currentPlayerSlot];
		}

		internal void UpdateGiftBox(Archipelago.Gifting.Net.Versioning.GiftBoxes.Current.GiftBox entry)
		{
			string motherBoxDataStorageKey = _keyProvider.GetMotherBoxDataStorageKey();
			Dictionary<int, Archipelago.Gifting.Net.Versioning.GiftBoxes.Current.GiftBox> dictionary = new Dictionary<int, Archipelago.Gifting.Net.Versioning.GiftBoxes.Current.GiftBox> { { _playerProvider.CurrentPlayerSlot, entry } };
			IDataStorageHelper dataStorage = _session.DataStorage;
			string text = motherBoxDataStorageKey;
			dataStorage[(Scope)0, text] = dataStorage[(Scope)0, text] + Operation.Update((IDictionary)dictionary);
		}

		public AcceptedTraitsByTeam GetAcceptedTraitsByTeam(IEnumerable<string> giftTraits)
		{
			AcceptedTraitsByTeam acceptedTraitsByTeam = new AcceptedTraitsByTeam();
			foreach (int allTeam in _playerProvider.GetAllTeams())
			{
				AcceptedTraitsByPlayer acceptedTraitsByPlayer = GetAcceptedTraitsByPlayer(allTeam, giftTraits);
				if (acceptedTraitsByPlayer.Any())
				{
					acceptedTraitsByTeam.Add(allTeam, acceptedTraitsByPlayer);
				}
			}
			return acceptedTraitsByTeam;
		}

		public AcceptedTraitsByPlayer GetAcceptedTraitsByPlayer(int team, IEnumerable<string> giftTraits)
		{
			AcceptedTraitsByPlayer acceptedTraitsByPlayer = new AcceptedTraitsByPlayer();
			Dictionary<int, Archipelago.Gifting.Net.Versioning.GiftBoxes.Current.GiftBox> motherbox = GetMotherbox(team);
			if (motherbox == null || !motherbox.Any())
			{
				return acceptedTraitsByPlayer;
			}
			foreach (KeyValuePair<int, Archipelago.Gifting.Net.Versioning.GiftBoxes.Current.GiftBox> item in motherbox)
			{
				int key = item.Key;
				Archipelago.Gifting.Net.Versioning.GiftBoxes.Current.GiftBox value = item.Value;
				AcceptedTraits acceptedTraits = GetAcceptedTraits(team, key, value, giftTraits);
				if (acceptedTraits.Any())
				{
					acceptedTraitsByPlayer.Add(key, acceptedTraits);
				}
			}
			return acceptedTraitsByPlayer;
		}

		private static AcceptedTraits GetAcceptedTraits(int team, int player, Archipelago.Gifting.Net.Versioning.GiftBoxes.Current.GiftBox giftBox, IEnumerable<string> giftTraits)
		{
			if (giftBox == null || !giftBox.IsOpen)
			{
				return new AcceptedTraits(team, player);
			}
			IEnumerable<string> source = giftTraits.Where((string x) => giftBox.AcceptsAnyGift || giftBox.DesiredTraits.Contains(x));
			return new AcceptedTraits(team, player, source.ToArray());
		}

		public GiftingResult SendGift(GiftItem item, string playerName)
		{
			return SendGift(item, new Archipelago.Gifting.Net.Versioning.Gifts.Current.GiftTrait[0], playerName);
		}

		public async Task<GiftingResult> SendGiftAsync(GiftItem item, string playerName)
		{
			return await SendGiftAsync(item, new Archipelago.Gifting.Net.Versioning.Gifts.Current.GiftTrait[0], playerName);
		}

		public GiftingResult SendGift(GiftItem item, Archipelago.Gifting.Net.Versioning.Gifts.Current.GiftTrait[] traits, string playerName)
		{
			return SendGift(item, traits, playerName, _session.ConnectionInfo.Team);
		}

		public async Task<GiftingResult> SendGiftAsync(GiftItem item, Archipelago.Gifting.Net.Versioning.Gifts.Current.GiftTrait[] traits, string playerName)
		{
			return await SendGiftAsync(item, traits, playerName, _session.ConnectionInfo.Team);
		}

		public GiftingResult SendGift(GiftItem item, string playerName, int playerTeam)
		{
			return SendGift(item, new Archipelago.Gifting.Net.Versioning.Gifts.Current.GiftTrait[0], playerName, playerTeam);
		}

		public async Task<GiftingResult> SendGiftAsync(GiftItem item, string playerName, int playerTeam)
		{
			return await SendGiftAsync(item, new Archipelago.Gifting.Net.Versioning.Gifts.Current.GiftTrait[0], playerName, playerTeam);
		}

		public GiftingResult SendGift(GiftItem item, Archipelago.Gifting.Net.Versioning.Gifts.Current.GiftTrait[] traits, string playerName, int playerTeam)
		{
			CanGiftResult canGift = CanGiftToPlayer(playerName, playerTeam, traits.Select((Archipelago.Gifting.Net.Versioning.Gifts.Current.GiftTrait x) => x.Trait));
			return SendGift(item, traits, playerName, playerTeam, canGift);
		}

		public async Task<GiftingResult> SendGiftAsync(GiftItem item, Archipelago.Gifting.Net.Versioning.Gifts.Current.GiftTrait[] traits, string playerName, int playerTeam)
		{
			return SendGift(item, traits, playerName, playerTeam, await CanGiftToPlayerAsync(playerName, playerTeam, traits.Select((Archipelago.Gifting.Net.Versioning.Gifts.Current.GiftTrait x) => x.Trait)));
		}

		private GiftingResult SendGift(GiftItem item, Archipelago.Gifting.Net.Versioning.Gifts.Current.GiftTrait[] traits, string playerName, int playerTeam, CanGiftResult canGift)
		{
			if (!canGift.CanGift)
			{
				return new FailedGifting(canGift.Message);
			}
			if (!_playerProvider.TryGetPlayer(playerName, playerTeam, out var player))
			{
				return new FailedGifting($"Could not find a player named {playerName} on team {playerTeam}");
			}
			int currentPlayerSlot = _playerProvider.CurrentPlayerSlot;
			int currentPlayerTeam = _playerProvider.CurrentPlayerTeam;
			int slot = player.Slot;
			Archipelago.Gifting.Net.Versioning.Gifts.Current.Gift gift = new Archipelago.Gifting.Net.Versioning.Gifts.Current.Gift(item.Name, item.Amount, item.Value, traits, currentPlayerSlot, slot, currentPlayerTeam, playerTeam);
			return SendGift(gift);
		}

		public GiftingResult RefundGift(Archipelago.Gifting.Net.Versioning.Gifts.Current.Gift gift)
		{
			if (gift.IsRefund)
			{
				return new FailedGifting("Cannot refund a gift that is already a refund");
			}
			gift.IsRefund = true;
			return SendGift(gift);
		}

		private GiftingResult SendGift(Archipelago.Gifting.Net.Versioning.Gifts.Current.Gift gift)
		{
			try
			{
				PlayerInfo val = (gift.IsRefund ? _playerProvider.GetPlayer(gift.SenderSlot, gift.SenderTeam) : _playerProvider.GetPlayer(gift.ReceiverSlot, gift.ReceiverTeam));
				int num = GetMotherbox(val.Team)[val.Slot].MaximumGiftDataVersion;
				if (num < DataVersion.FirstVersion)
				{
					num = DataVersion.FirstVersion;
				}
				string giftBoxDataStorageKey = _keyProvider.GetGiftBoxDataStorageKey(val.Team, val.Slot);
				CreateGiftBoxIfNeeded(giftBoxDataStorageKey);
				IDictionary dictionary = _currentGiftConverter.CreateDataStorageUpdateEntry(gift.ID, gift, num);
				IDataStorageHelper dataStorage = _session.DataStorage;
				string text = giftBoxDataStorageKey;
				dataStorage[(Scope)0, text] = dataStorage[(Scope)0, text] + Operation.Update(dictionary);
				return new SuccessfulGifting(gift.ID);
			}
			catch (Exception ex)
			{
				return new FailedGifting(gift.ID, ex.Message);
			}
		}

		public Dictionary<string, Archipelago.Gifting.Net.Versioning.Gifts.Current.Gift> GetAllGiftsAndEmptyGiftBox()
		{
			Dictionary<string, Archipelago.Gifting.Net.Versioning.Gifts.Current.Gift> dictionary = CheckGiftBox();
			RemoveGiftsFromGiftBox(dictionary.Keys);
			return dictionary;
		}

		public async Task<Dictionary<string, Archipelago.Gifting.Net.Versioning.Gifts.Current.Gift>> GetAllGiftsAndEmptyGiftBoxAsync()
		{
			Dictionary<string, Archipelago.Gifting.Net.Versioning.Gifts.Current.Gift> dictionary = await CheckGiftBoxAsync();
			RemoveGiftsFromGiftBox(dictionary.Keys);
			return dictionary;
		}

		public Dictionary<string, Archipelago.Gifting.Net.Versioning.Gifts.Current.Gift> CheckGiftBox()
		{
			string giftBoxDataStorageKey = _keyProvider.GetGiftBoxDataStorageKey(_playerProvider.CurrentPlayerTeam, _playerProvider.CurrentPlayerSlot);
			return GetGiftBoxContent(giftBoxDataStorageKey);
		}

		public async Task<Dictionary<string, Archipelago.Gifting.Net.Versioning.Gifts.Current.Gift>> CheckGiftBoxAsync()
		{
			string giftBoxDataStorageKey = _keyProvider.GetGiftBoxDataStorageKey(_playerProvider.CurrentPlayerTeam, _playerProvider.CurrentPlayerSlot);
			return await GetGiftBoxContentAsync(giftBoxDataStorageKey);
		}

		private void EmptyGiftBox()
		{
			GetAllGiftsAndEmptyGiftBox();
		}

		public void RemoveGiftsFromGiftBox(IEnumerable<string> giftsIds)
		{
			foreach (string giftsId in giftsIds)
			{
				RemoveGiftFromGiftBox(giftsId);
			}
		}

		public void RemoveGiftFromGiftBox(string giftId)
		{
			string giftBoxDataStorageKey = _keyProvider.GetGiftBoxDataStorageKey(_playerProvider.CurrentPlayerTeam, _playerProvider.CurrentPlayerSlot);
			IDataStorageHelper dataStorage = _session.DataStorage;
			string text = giftBoxDataStorageKey;
			dataStorage[(Scope)0, text] = dataStorage[(Scope)0, text] + Operation.Pop(JToken.op_Implicit(giftId));
		}

		private Dictionary<string, Archipelago.Gifting.Net.Versioning.Gifts.Current.Gift> GetGiftBoxContent(string giftBoxKey)
		{
			CreateGiftBoxIfNeeded(giftBoxKey);
			DataStorageElement element = _session.DataStorage[(Scope)0, giftBoxKey];
			return _currentGiftConverter.ReadFromDataStorage(element);
		}

		private async Task<Dictionary<string, Archipelago.Gifting.Net.Versioning.Gifts.Current.Gift>> GetGiftBoxContentAsync(string giftBoxKey)
		{
			CreateGiftBoxIfNeeded(giftBoxKey);
			JToken element = await _session.DataStorage[(Scope)0, giftBoxKey].GetAsync();
			return _currentGiftConverter.ReadFromDataStorage(element);
		}

		public CanGiftResult CanGiftToPlayer(string playerName)
		{
			return CanGiftToPlayer(playerName, _playerProvider.CurrentPlayerTeam);
		}

		public async Task<CanGiftResult> CanGiftToPlayerAsync(string playerName)
		{
			return await CanGiftToPlayerAsync(playerName, _playerProvider.CurrentPlayerTeam);
		}

		public CanGiftResult CanGiftToPlayer(string playerName, int playerTeam)
		{
			return CanGiftToPlayer(playerName, playerTeam, Enumerable.Empty<string>());
		}

		public async Task<CanGiftResult> CanGiftToPlayerAsync(string playerName, int playerTeam)
		{
			return await CanGiftToPlayerAsync(playerName, playerTeam, Enumerable.Empty<string>());
		}

		public CanGiftResult CanGiftToPlayer(string playerName, IEnumerable<string> giftTraits)
		{
			return CanGiftToPlayer(playerName, _playerProvider.CurrentPlayerTeam, giftTraits);
		}

		public async Task<CanGiftResult> CanGiftToPlayerAsync(string playerName, IEnumerable<string> giftTraits)
		{
			return await CanGiftToPlayerAsync(playerName, _playerProvider.CurrentPlayerTeam, giftTraits);
		}

		public CanGiftResult CanGiftToPlayer(string playerName, int playerTeam, IEnumerable<string> giftTraits)
		{
			if (!_playerProvider.TryGetPlayer(playerName, out var player))
			{
				return new CanGiftResult("Could not find a player named " + playerName);
			}
			return CanGiftToPlayer(player.Slot, playerTeam, giftTraits);
		}

		public async Task<CanGiftResult> CanGiftToPlayerAsync(string playerName, int playerTeam, IEnumerable<string> giftTraits)
		{
			if (!_playerProvider.TryGetPlayer(playerName, out var player))
			{
				return new CanGiftResult("Could not find a player named " + playerName);
			}
			return await CanGiftToPlayerAsync(player.Slot, playerTeam, giftTraits);
		}

		public CanGiftResult CanGiftToPlayer(int playerSlot)
		{
			return CanGiftToPlayer(playerSlot, _playerProvider.CurrentPlayerTeam);
		}

		public async Task<CanGiftResult> CanGiftToPlayerAsync(int playerSlot)
		{
			return await CanGiftToPlayerAsync(playerSlot, _playerProvider.CurrentPlayerTeam);
		}

		public CanGiftResult CanGiftToPlayer(int playerSlot, int playerTeam)
		{
			return CanGiftToPlayer(playerSlot, playerTeam, Enumerable.Empty<string>());
		}

		public async Task<CanGiftResult> CanGiftToPlayerAsync(int playerSlot, int playerTeam)
		{
			return await CanGiftToPlayerAsync(playerSlot, playerTeam, Enumerable.Empty<string>());
		}

		public CanGiftResult CanGiftToPlayer(int playerSlot, IEnumerable<string> giftTraits)
		{
			return CanGiftToPlayer(playerSlot, _playerProvider.CurrentPlayerTeam, giftTraits);
		}

		public async Task<CanGiftResult> CanGiftToPlayerAsync(int playerSlot, IEnumerable<string> giftTraits)
		{
			return await CanGiftToPlayerAsync(playerSlot, _playerProvider.CurrentPlayerTeam, giftTraits);
		}

		public CanGiftResult CanGiftToPlayer(int playerSlot, int playerTeam, IEnumerable<string> giftTraits)
		{
			Dictionary<int, Archipelago.Gifting.Net.Versioning.GiftBoxes.Current.GiftBox> motherbox = GetMotherbox(playerTeam);
			return CanGiftToPlayer(playerSlot, playerTeam, giftTraits, motherbox);
		}

		public async Task<CanGiftResult> CanGiftToPlayerAsync(int playerSlot, int playerTeam, IEnumerable<string> giftTraits)
		{
			return CanGiftToPlayer(playerSlot, playerTeam, giftTraits, await GetMotherboxAsync(playerTeam));
		}

		private CanGiftResult CanGiftToPlayer(int playerSlot, int playerTeam, IEnumerable<string> giftTraits, Dictionary<int, Archipelago.Gifting.Net.Versioning.GiftBoxes.Current.GiftBox> motherBox)
		{
			if (!motherBox.ContainsKey(playerSlot))
			{
				return new CanGiftResult("Player does not exist or does not have a giftbox");
			}
			Archipelago.Gifting.Net.Versioning.GiftBoxes.Current.GiftBox giftBox = motherBox[playerSlot];
			if (!giftBox.IsOpen)
			{
				return new CanGiftResult("This giftbox is currently closed");
			}
			if (giftBox.MinimumGiftDataVersion > DataVersion.Current)
			{
				return new CanGiftResult($"This player can only receive gifts from a more recent data version. Your client should update to gifting Data Version {giftBox.MinimumGiftDataVersion}. If you are not the developer, you should contact them to tell them about this.");
			}
			_playerProvider.GetPlayer(playerSlot, playerTeam);
			if (giftBox.AcceptsAnyGift)
			{
				return new CanGiftResult();
			}
			if (!giftBox.DesiredTraits.Any((string trait) => giftTraits.Contains<string>(trait, StringComparer.OrdinalIgnoreCase)))
			{
				return new CanGiftResult("This player cannot accept this gift. They can only accept the following traits: [" + string.Join(",", giftBox.DesiredTraits) + "]");
			}
			return new CanGiftResult();
		}

		private Dictionary<int, Archipelago.Gifting.Net.Versioning.GiftBoxes.Current.GiftBox> GetMotherbox(int playerTeam)
		{
			string motherBoxDataStorageKey = _keyProvider.GetMotherBoxDataStorageKey(playerTeam);
			return _currentGiftBoxConverter.ReadFromDataStorage(_session.DataStorage[(Scope)0, motherBoxDataStorageKey]);
		}

		private async Task<Dictionary<int, Archipelago.Gifting.Net.Versioning.GiftBoxes.Current.GiftBox>> GetMotherboxAsync(int playerTeam)
		{
			string motherBoxDataStorageKey = _keyProvider.GetMotherBoxDataStorageKey(playerTeam);
			JToken element = await _session.DataStorage[(Scope)0, motherBoxDataStorageKey].GetAsync();
			return _currentGiftBoxConverter.ReadFromDataStorage(element);
		}

		private void CreateMotherboxIfNeeded(string motherboxKey)
		{
			_session.DataStorage[(Scope)0, motherboxKey].Initialize(EmptyMotherboxDictionary);
		}

		private void CreateGiftBoxIfNeeded(string giftBoxKey)
		{
			_session.DataStorage[(Scope)0, giftBoxKey].Initialize(EmptyGiftDictionary);
		}

		private void GiftListener(JToken originalValue, JToken newValue, Dictionary<string, JToken> additionalArguments)
		{
			Dictionary<string, Archipelago.Gifting.Net.Versioning.Gifts.Current.Gift> dictionary = _currentGiftConverter.ReadFromDataStorage(originalValue);
			Dictionary<string, Archipelago.Gifting.Net.Versioning.Gifts.Current.Gift> dictionary2 = _currentGiftConverter.ReadFromDataStorage(newValue);
			foreach (string key in dictionary.Keys)
			{
				dictionary2.Remove(key);
			}
			foreach (Archipelago.Gifting.Net.Versioning.Gifts.Current.Gift value in dictionary2.Values)
			{
				_giftReceivedHandler?.Invoke(value);
			}
		}

		[Obsolete("SubscribeToNewGifts is deprecated. Instead, use the event OnNewGift and subscribe by adding the handlers you need")]
		public void SubscribeToNewGifts(Action<Dictionary<string, Archipelago.Gifting.Net.Versioning.Gifts.Current.Gift>> newGiftsCallback)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			string giftBoxDataStorageKey = _keyProvider.GetGiftBoxDataStorageKey();
			_session.DataStorage[(Scope)0, giftBoxDataStorageKey].OnValueChanged += (DataStorageUpdatedHandler)delegate(JToken originalValue, JToken newValue, Dictionary<string, JToken> additionalArguments)
			{
				OnNewGiftObsolete(originalValue, newValue, newGiftsCallback);
			};
		}

		[Obsolete("Obsolete private event used by SubscribeToNewGifts")]
		private void OnNewGiftObsolete(JToken originalValue, JToken newValue, Action<Dictionary<string, Archipelago.Gifting.Net.Versioning.Gifts.Current.Gift>> newGiftsCallback)
		{
			Dictionary<string, Archipelago.Gifting.Net.Versioning.Gifts.Current.Gift> dictionary = _currentGiftConverter.ReadFromDataStorage(newValue);
			if (dictionary.Any())
			{
				newGiftsCallback(dictionary);
			}
		}

		[Obsolete("The overloads with out parameters are now deprecated, please use the overloads that return a GiftingResult instead")]
		public bool SendGift(GiftItem item, string playerName, out string giftId)
		{
			GiftingResult giftingResult = SendGift(item, playerName);
			giftId = giftingResult.GiftId;
			return giftingResult.Success;
		}

		[Obsolete("The overloads with out parameters are now deprecated, please use the overloads that return a GiftingResult instead")]
		public bool SendGift(GiftItem item, string playerName, int playerTeam, out string giftId)
		{
			GiftingResult giftingResult = SendGift(item, playerName, playerTeam);
			giftId = giftingResult.GiftId;
			return giftingResult.Success;
		}

		[Obsolete("The overloads with out parameters are now deprecated, please use the overloads that return a GiftingResult instead")]
		public bool SendGift(GiftItem item, Archipelago.Gifting.Net.Versioning.Gifts.Current.GiftTrait[] traits, string playerName, out string giftId)
		{
			GiftingResult giftingResult = SendGift(item, traits, playerName);
			giftId = giftingResult.GiftId;
			return giftingResult.Success;
		}

		[Obsolete("The overloads with out parameters are now deprecated, please use the overloads that return a GiftingResult instead")]
		public bool SendGift(GiftItem item, Archipelago.Gifting.Net.Versioning.Gifts.Current.GiftTrait[] traits, string playerName, int playerTeam, out string giftId)
		{
			GiftingResult giftingResult = SendGift(item, traits, playerName, playerTeam);
			giftId = giftingResult.GiftId;
			return giftingResult.Success;
		}
	}
	public interface IGiftingService : IGiftingServiceSync, IGiftingServiceAsync
	{
		event GiftingService.GiftReceivedHandler OnNewGift;
	}
	public interface IGiftingServiceAsync
	{
		Task<Dictionary<string, Archipelago.Gifting.Net.Versioning.Gifts.Current.Gift>> CheckGiftBoxAsync();

		Task<CanGiftResult> CanGiftToPlayerAsync(string playerName);

		Task<CanGiftResult> CanGiftToPlayerAsync(string playerName, int playerTeam);

		Task<CanGiftResult> CanGiftToPlayerAsync(string playerName, IEnumerable<string> giftTraits);

		Task<CanGiftResult> CanGiftToPlayerAsync(string playerName, int playerTeam, IEnumerable<string> giftTraits);

		Task<CanGiftResult> CanGiftToPlayerAsync(int playerSlot);

		Task<CanGiftResult> CanGiftToPlayerAsync(int playerSlot, int playerTeam);

		Task<CanGiftResult> CanGiftToPlayerAsync(int playerSlot, IEnumerable<string> giftTraits);

		Task<CanGiftResult> CanGiftToPlayerAsync(int playerSlot, int playerTeam, IEnumerable<string> giftTraits);

		Task<GiftingResult> SendGiftAsync(GiftItem item, string playerName);

		Task<GiftingResult> SendGiftAsync(GiftItem item, string playerName, int playerTeam);

		Task<GiftingResult> SendGiftAsync(GiftItem item, Archipelago.Gifting.Net.Versioning.Gifts.Current.GiftTrait[] traits, string playerName);

		Task<GiftingResult> SendGiftAsync(GiftItem item, Archipelago.Gifting.Net.Versioning.Gifts.Current.GiftTrait[] traits, string playerName, int playerTeam);
	}
	public interface IGiftingServiceSync
	{
		string GetMyGiftBoxKey();

		void OpenGiftBox();

		void OpenGiftBox(bool acceptAnyGift, string[] desiredTraits);

		void CloseGiftBox();

		Archipelago.Gifting.Net.Versioning.GiftBoxes.Current.GiftBox GetCurrentGiftBoxState();

		CanGiftResult CanGiftToPlayer(string playerName);

		CanGiftResult CanGiftToPlayer(string playerName, int playerTeam);

		CanGiftResult CanGiftToPlayer(string playerName, IEnumerable<string> giftTraits);

		CanGiftResult CanGiftToPlayer(string playerName, int playerTeam, IEnumerable<string> giftTraits);

		CanGiftResult CanGiftToPlayer(int playerSlot);

		CanGiftResult CanGiftToPlayer(int playerSlot, int playerTeam);

		CanGiftResult CanGiftToPlayer(int playerSlot, IEnumerable<string> giftTraits);

		CanGiftResult CanGiftToPlayer(int playerSlot, int playerTeam, IEnumerable<string> giftTraits);

		AcceptedTraitsByTeam GetAcceptedTraitsByTeam(IEnumerable<string> giftTraits);

		AcceptedTraitsByPlayer GetAcceptedTraitsByPlayer(int team, IEnumerable<string> giftTraits);

		GiftingResult SendGift(GiftItem item, string playerName);

		GiftingResult SendGift(GiftItem item, string playerName, int playerTeam);

		GiftingResult SendGift(GiftItem item, Archipelago.Gifting.Net.Versioning.Gifts.Current.GiftTrait[] traits, string playerName);

		GiftingResult SendGift(GiftItem item, Archipelago.Gifting.Net.Versioning.Gifts.Current.GiftTrait[] traits, string playerName, int playerTeam);

		GiftingResult RefundGift(Archipelago.Gifting.Net.Versioning.Gifts.Current.Gift gift);

		Dictionary<string, Archipelago.Gifting.Net.Versioning.Gifts.Current.Gift> GetAllGiftsAndEmptyGiftBox();

		Dictionary<string, Archipelago.Gifting.Net.Versioning.Gifts.Current.Gift> CheckGiftBox();

		void RemoveGiftsFromGiftBox(IEnumerable<string> giftIds);

		void RemoveGiftFromGiftBox(string giftId);

		[Obsolete("SubscribeToNewGifts is deprecated. Instead, use the event OnNewGift and subscribe by adding the handlers you need")]
		void SubscribeToNewGifts(Action<Dictionary<string, Archipelago.Gifting.Net.Versioning.Gifts.Current.Gift>> newGiftsCallback);

		[Obsolete("The overloads with out parameters are now deprecated, please use the overloads that return a GiftingResult instead")]
		bool SendGift(GiftItem item, string playerName, out string giftId);

		[Obsolete("The overloads with out parameters are now deprecated, please use the overloads that return a GiftingResult instead")]
		bool SendGift(GiftItem item, string playerName, int playerTeam, out string giftId);

		[Obsolete("The overloads with out parameters are now deprecated, please use the overloads that return a GiftingResult instead")]
		bool SendGift(GiftItem item, Archipelago.Gifting.Net.Versioning.Gifts.Current.GiftTrait[] traits, string playerName, out string giftId);

		[Obsolete("The overloads with out parameters are now deprecated, please use the overloads that return a GiftingResult instead")]
		bool SendGift(GiftItem item, Archipelago.Gifting.Net.Versioning.Gifts.Current.GiftTrait[] traits, string playerName, int playerTeam, out string giftId);
	}
}
namespace Archipelago.Gifting.Net.Service.TraitAcceptance
{
	public class AcceptedTraits
	{
		public int Team { get; }

		public int Player { get; }

		public string[] Traits { get; }

		internal AcceptedTraits(int team, int player)
			: this(team, player, new string[0])
		{
		}

		internal AcceptedTraits(int team, int player, string[] traits)
		{
			Team = team;
			Player = player;
			Traits = traits;
		}

		public bool Any()
		{
			return Traits.Any();
		}
	}
	public class AcceptedTraitsByPlayer : IDictionary<int, AcceptedTraits>, ICollection<KeyValuePair<int, AcceptedTraits>>, IEnumerable<KeyValuePair<int, AcceptedTraits>>, IEnumerable
	{
		private IDictionary<int, AcceptedTraits> _traitsByPlayer;

		public int Count => _traitsByPlayer.Count;

		public bool IsReadOnly => _traitsByPlayer.IsReadOnly;

		public AcceptedTraits this[int key]
		{
			get
			{
				return _traitsByPlayer[key];
			}
			set
			{
				_traitsByPlayer[key] = value;
			}
		}

		public ICollection<int> Keys => _traitsByPlayer.Keys;

		public ICollection<AcceptedTraits> Values => _traitsByPlayer.Values;

		internal AcceptedTraitsByPlayer()
			: this(new Dictionary<int, AcceptedTraits>())
		{
		}

		internal AcceptedTraitsByPlayer(IDictionary<int, AcceptedTraits> traitsByPlayer)
		{
			_traitsByPlayer = traitsByPlayer;
		}

		public IEnumerator<KeyValuePair<int, AcceptedTraits>> GetEnumerator()
		{
			return _traitsByPlayer.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		public void Add(KeyValuePair<int, AcceptedTraits> item)
		{
			_traitsByPlayer.Add(item);
		}

		public void Clear()
		{
			_traitsByPlayer.Clear();
		}

		public bool Contains(KeyValuePair<int, AcceptedTraits> item)
		{
			return _traitsByPlayer.Contains(item);
		}

		public void CopyTo(KeyValuePair<int, AcceptedTraits>[] array, int arrayIndex)
		{
			_traitsByPlayer.CopyTo(array, arrayIndex);
		}

		public bool Remove(KeyValuePair<int, AcceptedTraits> item)
		{
			return _traitsByPlayer.Remove(item);
		}

		public bool ContainsKey(int key)
		{
			return _traitsByPlayer.ContainsKey(key);
		}

		public void Add(int key, AcceptedTraits value)
		{
			_traitsByPlayer.Add(key, value);
		}

		public bool Remove(int key)
		{
			return _traitsByPlayer.Remove(key);
		}

		public bool TryGetValue(int key, out AcceptedTraits value)
		{
			return _traitsByPlayer.TryGetValue(key, out value);
		}
	}
	public class AcceptedTraitsByTeam : IDictionary<int, AcceptedTraitsByPlayer>, ICollection<KeyValuePair<int, AcceptedTraitsByPlayer>>, IEnumerable<KeyValuePair<int, AcceptedTraitsByPlayer>>, IEnumerable
	{
		private IDictionary<int, AcceptedTraitsByPlayer> _traitsByTeam;

		public int Count => _traitsByTeam.Count;

		public bool IsReadOnly => _traitsByTeam.IsReadOnly;

		public AcceptedTraitsByPlayer this[int key]
		{
			get
			{
				return _traitsByTeam[key];
			}
			set
			{
				_traitsByTeam[key] = value;
			}
		}

		public ICollection<int> Keys => _traitsByTeam.Keys;

		public ICollection<AcceptedTraitsByPlayer> Values => _traitsByTeam.Values;

		internal AcceptedTraitsByTeam()
			: this(new Dictionary<int, AcceptedTraitsByPlayer>())
		{
		}

		internal AcceptedTraitsByTeam(IDictionary<int, AcceptedTraitsByPlayer> traitsByTeam)
		{
			_traitsByTeam = traitsByTeam;
		}

		public IEnumerator<KeyValuePair<int, AcceptedTraitsByPlayer>> GetEnumerator()
		{
			return _traitsByTeam.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		public void Add(KeyValuePair<int, AcceptedTraitsByPlayer> item)
		{
			_traitsByTeam.Add(item);
		}

		public void Clear()
		{
			_traitsByTeam.Clear();
		}

		public bool Contains(KeyValuePair<int, AcceptedTraitsByPlayer> item)
		{
			return _traitsByTeam.Contains(item);
		}

		public void CopyTo(KeyValuePair<int, AcceptedTraitsByPlayer>[] array, int arrayIndex)
		{
			_traitsByTeam.CopyTo(array, arrayIndex);
		}

		public bool Remove(KeyValuePair<int, AcceptedTraitsByPlayer> item)
		{
			return _traitsByTeam.Remove(item);
		}

		public bool ContainsKey(int key)
		{
			return _traitsByTeam.ContainsKey(key);
		}

		public void Add(int key, AcceptedTraitsByPlayer value)
		{
			_traitsByTeam.Add(key, value);
		}

		public bool Remove(int key)
		{
			return _traitsByTeam.Remove(key);
		}

		public bool TryGetValue(int key, out AcceptedTraitsByPlayer value)
		{
			return _traitsByTeam.TryGetValue(key, out value);
		}
	}
}
namespace Archipelago.Gifting.Net.Service.Result
{
	public class CanGiftResult
	{
		public bool CanGift => string.IsNullOrWhiteSpace(Message);

		public string Message { get; }

		public CanGiftResult()
			: this(string.Empty)
		{
		}

		public CanGiftResult(string message)
		{
			Message = message;
		}
	}
	public class FailedGifting : GiftingResult
	{
		public override bool Success => false;

		public override string GiftId { get; }

		public string ErrorMessage { get; }

		public FailedGifting(string errorMessage)
			: this(string.Empty, errorMessage)
		{
		}

		public FailedGifting(string giftId, string errorMessage)
		{
			GiftId = giftId;
			ErrorMessage = errorMessage;
		}
	}
	public abstract class GiftingResult
	{
		public abstract bool Success { get; }

		public abstract string GiftId { get; }
	}
	public class SuccessfulGifting : GiftingResult
	{
		public override bool Success => true;

		public override string GiftId { get; }

		public SuccessfulGifting(string giftId)
		{
			GiftId = giftId;
		}
	}
}