using System;
using System.Collections.Generic;
using System.Diagnostics;
using SUISS.Core;
using SUISSEngine;
using UnityEngine;

[RequireComponent(typeof(Serializing))]
public sealed class CIGPurchasedBuildingsManager : SingletonMonobehaviour<CIGPurchasedBuildingsManager>
{
	//[DebuggerBrowsable(DebuggerBrowsableState.Never)]
	public event CIGPurchasedBuildingsManager.BuildingCountChangedHandler BuildingCountChangedEvent;

	private void FireBuildingCountChangedEvent()
	{
		if (this.BuildingCountChangedEvent != null)
		{
			this.BuildingCountChangedEvent();
		}
	}

	public void AddBuilding(CIGBuilding building)
	{
		this.AddPurchasedCount(building.CachedName, 1);
		this._serializing.Serialize();
		this.FireBuildingCountChangedEvent();
	}

	public void ConsumeBuilding(CIGBuilding building)
	{
		this.AddConsumedCount(building.CachedName, 1);
		this._serializing.Serialize();
		this.FireBuildingCountChangedEvent();
	}

	public bool IsUnconsumed(CIGBuilding building)
	{
		int num;
		if (this._purchasedBuildings.TryGetValue(building.CachedName, out num))
		{
			int num2;
			if (!this._consumedBuildings.TryGetValue(building.CachedName, out num2))
			{
				num2 = 0;
			}
			return num > num2;
		}
		return false;
	}

	public Dictionary<string, int> GetUnconsumedBuildings()
	{
		Dictionary<string, int> dictionary = new Dictionary<string, int>();
		foreach (KeyValuePair<string, int> keyValuePair in this._purchasedBuildings)
		{
			int num;
			if (!this._consumedBuildings.TryGetValue(keyValuePair.Key, out num))
			{
				num = 0;
			}
			if (num < keyValuePair.Value)
			{
				dictionary.Add(keyValuePair.Key, keyValuePair.Value - num);
			}
		}
		return dictionary;
	}

	public int TotalUnconsumedBuildings
	{
		get
		{
			int num = 0;
			int num2 = 0;
			foreach (KeyValuePair<string, int> keyValuePair in this._purchasedBuildings)
			{
				if (keyValuePair.Value > 0)
				{
					num2 += keyValuePair.Value;
				}
			}
			foreach (KeyValuePair<string, int> keyValuePair2 in this._consumedBuildings)
			{
				if (keyValuePair2.Value > 0)
				{
					num += keyValuePair2.Value;
				}
			}
			return Math.Max(0, num2 - num);
		}
	}

	private void AddPurchasedCount(string buildingName, int amount)
	{
		int num;
		if (!this._purchasedBuildings.TryGetValue(buildingName, out num))
		{
			num = amount;
		}
		else
		{
			num += amount;
		}
		this._purchasedBuildings[buildingName] = Mathf.Max(0, num);
	}

	private void AddConsumedCount(string buildingName, int amount)
	{
		int num;
		if (!this._consumedBuildings.TryGetValue(buildingName, out num))
		{
			num = amount;
		}
		else
		{
			num += amount;
		}
		this._consumedBuildings[buildingName] = Mathf.Max(0, num);
	}

	private void OnSerialize(Dictionary<string, object> values)
	{
		this.SaveDictionary<int>(values, "PurchasedBuildings", this._purchasedBuildings);
		this.SaveDictionary<int>(values, "ConsumedBuildings", this._consumedBuildings);
	}

	private void OnDeserialize(Dictionary<string, object> values)
	{
		this._purchasedBuildings = this.LoadDictionary<int>(values, "PurchasedBuildings");
		this._consumedBuildings = this.LoadDictionary<int>(values, "ConsumedBuildings");
	}

	private void OnDeserialized()
	{
		if (this._purchasedBuildings == null)
		{
			this._purchasedBuildings = new Dictionary<string, int>();
		}
		if (this._consumedBuildings == null)
		{
			this._consumedBuildings = new Dictionary<string, int>();
		}
	}

	private void SaveDictionary<T>(Dictionary<string, object> storage, string key, Dictionary<string, T> values)
	{
		Dictionary<string, object> dictionary = new Dictionary<string, object>();
		foreach (KeyValuePair<string, T> keyValuePair in values)
		{
			dictionary.Add(keyValuePair.Key, keyValuePair.Value);
		}
		storage[key] = dictionary;
	}

	private Dictionary<string, T> LoadDictionary<T>(Dictionary<string, object> storage, string key)
	{
		if (!storage.ContainsKey(key))
		{
			return new Dictionary<string, T>();
		}
		if (!(storage[key] is Dictionary<string, object>))
		{
			throw new InvalidOperationException(string.Format("Found {0} at storage[{1}]. Expecting {2}", storage[key].GetType().Name, key, typeof(Dictionary<string, object>).Name));
		}
		Dictionary<string, T> dictionary = new Dictionary<string, T>();
		Dictionary<string, object> dictionary2 = (Dictionary<string, object>)storage[key];
		foreach (KeyValuePair<string, object> keyValuePair in dictionary2)
		{
			if (!(dictionary2[keyValuePair.Key] is T))
			{
				throw new InvalidOperationException(string.Format("Found {0} at storage[{1}]. Expecting {2}", storage[key].GetType().Name, key, typeof(T).Name));
			}
			dictionary.Add(keyValuePair.Key, (T)((object)dictionary2[keyValuePair.Key]));
		}
		return dictionary;
	}

	private const string PurchasedBuildingsKey = "PurchasedBuildings";

	private const string ConsumedBuildingsKey = "ConsumedBuildings";

	[SerializeField]
	private Serializing _serializing;

	private Dictionary<string, int> _purchasedBuildings;

	private Dictionary<string, int> _consumedBuildings;

	public delegate void BuildingCountChangedHandler();
}