using System;
using System.Collections.Generic;
using CIG.Extensions;
using CIG.Translation;
using CIGEnums;
using SparkLinq;
using SUISS.Core;
using SUISSEngine;
using UnityEngine;

public class BuildDemolishPopupState : PopupBaseState
{
	public override void Enter(State oldState)
	{
		base.Enter(oldState);
		this._buildList = from x in SingletonMonobehaviour<CIGBuilderManager>.Instance.BuildList
		orderby x.finishTime
		select x;
		Destroyer destroyer = IsometricIsland.Current.destroyer;
		List<Building> demolishList = destroyer.DemolishList;
		Dictionary<Building, double> demolishTimeOf = demolishList.ToDictionary((Building x) => x, (Building x) => destroyer.GetTimeTillDestroyed(x));
		this._demolishList = from x in demolishList
		orderby demolishTimeOf[x]
		select x;
		this._lastOpenedTab = ((this._demolishList.Count <= 0 || this._buildList.Count != 0) ? BuildDemolishTabs.Build : BuildDemolishTabs.Demolish);
		this.InvokeNextFrame(delegate
		{
			this.SwitchTab(this._lastOpenedTab);
		});
	}

	public override void ClosePopup(Action callback, bool animate, bool synchronous)
	{
		this._buildList.Clear();
		this._demolishList.Clear();
		base.ClosePopup(callback, animate, synchronous);
	}

	public void OpenCranesShop()
	{
		base.ClosePopup(delegate()
		{
			SingletonMonobehaviour<PopupManager>.Instance.OpenShopMenu(ShopMenuTabs.Cranes);
		});
	}

	public void Speedup(Currencies cost)
	{
		if (this._buildList.Count == 0 && this._demolishList.Count == 0)
		{
			return;
		}
		BuildDemolishTabs tab = this._lastOpenedTab;
		SingletonMonobehaviour<PopupManager>.Instance.RequestGenericPopup(null, Localization.Key("speedup"), Localization.Format(Localization.Key("speedup_for"), new ILocalizedString[]
		{
			cost.LocalizedString()
		}), Localization.Key("ok"), Localization.Key("not_now"), delegate()
		{
			SingletonMonobehaviour<CIGGameState>.Instance.SpendCurrencies(cost, false, delegate(bool ok, Currencies spent)
			{
				if (ok)
				{
					if (tab != BuildDemolishTabs.Build)
					{
						if (tab != BuildDemolishTabs.Demolish)
						{
							UnityEngine.Debug.LogErrorFormat("Missing speedup action for '{0}'", new object[]
							{
								tab
							});
						}
						else
						{
							int spent2 = Mathf.RoundToInt((float)cost.GetValue("Cash"));
							SingletonMonobehaviour<CIGGameStats>.Instance.AddSpeedupExecuted(0);
							SingletonMonobehaviour<CIGGameStats>.Instance.AddCashSpent_BulldozerQueue(spent2);
							CityIsland.Current.isometricIsland.destroyer.FinishAll();
						}
					}
					else
					{
						int num = Mathf.RoundToInt((float)cost.GetValue("Gold"));
						SingletonMonobehaviour<CIGGameStats>.Instance.AddSpeedupExecuted(num);
						SingletonMonobehaviour<CIGGameStats>.Instance.AddGoldSpent_CraneQueue(num);
						SingletonMonobehaviour<CIGBuilderManager>.Instance.SpeedupAll();
					}
				}
			});
		}, null, null, true);
		base.ClosePopup();
	}

	public void SwitchTab(BuildDemolishTabs buildDemolishTab)
	{
		this._lastOpenedTab = buildDemolishTab;
		((BuildDemolishPopupView)this.View).SwitchTab(buildDemolishTab);
	}

	public Currencies DemolishQueueSpeedupCost(out int totalTime)
	{
		totalTime = 0;
		int num = 0;
		foreach (Building building in this._demolishList)
		{
			int num2 = this.BuildingTimeLeft(building);
			if (num2 > 0)
			{
				totalTime += num2;
				num++;
			}
		}
		decimal value = num * CIGBuilding.GetSpeedupCostCashForSeconds(300L);
		return new Currencies("Cash", value);
	}

	public Currencies BuildQueueSpeedupCost(out int totalTime)
	{
		decimal num = 0m;
		decimal num2 = 0m;
		totalTime = 0;
		int num3 = 0;
		foreach (CIGBuilderManager.BuildInfo buildInfo in this._buildList)
		{
			if (!buildInfo.IsFinished)
			{
				int num4 = (int)buildInfo.Timeleft;
				decimal speedupCostGoldForSeconds = CIGBuilding.GetSpeedupCostGoldForSeconds((long)num4);
				num2 = Math.Max(num2, speedupCostGoldForSeconds);
				num += speedupCostGoldForSeconds;
				totalTime += num4;
				num3++;
			}
		}
		if (num3 > 1)
		{
			num = Math.Max(1m, Math.Round(0.75m * num));
		}
		num = Math.Max(num, num2);
		return new Currencies("Gold", num);
	}

	public bool CancelDemolish(Building building)
	{
		if (this._lastOpenedTab != BuildDemolishTabs.Demolish)
		{
			return false;
		}
		if (this._demolishList.Remove(building))
		{
			building.CancelDemolishment();
			IsometricIsland.Current.destroyer.CancelDestroyBuilding(building);
			return true;
		}
		return false;
	}

	public CIGBuilderManager.BuildInfo GetBuildListItem(int index)
	{
		return this._buildList[index];
	}

	public Building GetDemolishListItem(int index)
	{
		return this._demolishList[index];
	}

	public bool IsFirstBuildingBuilt()
	{
		if (this._buildList.Count == 0)
		{
			return false;
		}
		CIGBuilderManager.BuildInfo buildInfo = this._buildList[0];
		return buildInfo.IsFinished && this._buildList.Remove(buildInfo);
	}

	public bool IsFirstBuildingDemolished()
	{
		if (this._demolishList.Count == 0)
		{
			return false;
		}
		Building building = this._demolishList[0];
		return this.BuildingTimeLeft(building) <= 0 && this._demolishList.Remove(building);
	}

	public int BuildListCount
	{
		get
		{
			return this._buildList.Count;
		}
	}

	public int DemolishListCount
	{
		get
		{
			return this._demolishList.Count;
		}
	}

	private int BuildingTimeLeft(Building building)
	{
		if (building == null || building.tile == null || building.tile.status == GridTile.Status.Destroyed)
		{
			return -1;
		}
		double num = Math.Max(building.ConstructionTimeLeft, building.DemolishTimeLeft);
		CIGBuilding cigbuilding = building as CIGBuilding;
		if (cigbuilding != null)
		{
			if (building.state == BuildingState.Normal && !cigbuilding.IsUpgrading)
			{
				return -1;
			}
			num = Math.Max(num, cigbuilding.UpgradeTimeLeft);
		}
		else if (building.state == BuildingState.Normal)
		{
			return -1;
		}
		return (int)num;
	}

	private BuildDemolishTabs _lastOpenedTab;

	private List<CIGBuilderManager.BuildInfo> _buildList = new List<CIGBuilderManager.BuildInfo>();

	private List<Building> _demolishList = new List<Building>();
}