using System;
using System.Collections.Generic;
using CIG.Translation;
using CIG3.ExtensionMethods;
using CIGEnums;
using SUISS.Core;
using SUISSEngine;
using UnityEngine;

public sealed class CIGCityAdvisor : SingletonMonobehaviour<CIGCityAdvisor>
{
	public void Show()
	{
		if (this.RetrieveComponents())
		{
			this.ConstructAdvice();
		}
	}

	public void Build()
	{
		if (this._advice.advicedBuilding != null)
		{
			this._island.StartBuilding(this._advice.advicedBuilding.Prefab);
		}
	}

	public void Cancel()
	{
	}

	public AdviceType AdviceType
	{
		get
		{
			return this._advice.type;
		}
	}

	public void UpdateAdvise()
	{
		this.RetrieveComponents();
		if (this._advice == null)
		{
			this._advice = new CIGCityAdvisor.AdviceProperties();
		}
		this.DetermineAdviceType();
	}

	private static int GetHappiness(CIGBuilding x)
	{
		return x.baseHappinessValue;
	}

	private static int GetJobs(CIGBuilding x)
	{
		return x.GetComponent<CIGCommercialBuilding>().maxEmployeesBaseValue;
	}

	private static int GetHousing(CIGBuilding x)
	{
		return x.GetComponent<CIGResidentialBuilding>().maxPeopleBaseValue;
	}

	private bool RetrieveComponents()
	{
		this._island = CityIsland.Current;
		if (this._island == null)
		{
			UnityEngine.Debug.LogError("Cannot find CityIsland component");
			return false;
		}
		this._grid = this._island.isometricIsland.grid;
		this._land = this._island.expansions;
		if (this._gameState == null)
		{
			this._gameState = SingletonMonobehaviour<CIGGameState>.Instance;
			if (this._gameState == null)
			{
				UnityEngine.Debug.LogError("Cannot find CIGGameState component");
				return false;
			}
		}
		return true;
	}

	private void ConstructAdvice()
	{
		this._advice = new CIGCityAdvisor.AdviceProperties();
		this.DetermineAdviceType();
		this.DetermineAdviceText();
		this.DetermineParameters();
		this.ChooseBuilding();
		this.LocalizeAdviceText();
		this._advice.title = Localization.Key("city_advisor");
		if (this._advice.advicedBuilding != null)
		{
			this._advice.okButtonText = Localization.Key("build");
			this._advice.cancelButtonText = Localization.Key("perhaps_later");
		}
		else
		{
			this._advice.okButtonText = Localization.Key("thank_you");
		}
		SingletonMonobehaviour<PopupManager>.Instance.RequestFirstAdvicePopup(this._advice.image, this._advice.title, this._advice.text, this._advice.okButtonText, this._advice.cancelButtonText, new Action(this.Build), new Action(this.Cancel), null, this._advice.advicedBuilding, true);
	}

	private void LocalizeAdviceText()
	{
		ILocalizedString localizedString = (!(this._advice.advicedBuilding != null)) ? Localization.EmptyLocalizedString : this._advice.advicedBuilding.LocalName;
		ILocalizedString localizedString2 = this._advice.localizedString;
		string text = localizedString2.Translate();
		if (text.Contains("{1}"))
		{
			this._advice.text = Localization.Format(localizedString2, new ILocalizedString[]
			{
				Localization.Integer(this._advice.deficiency),
				localizedString
			});
		}
		else if (text.Contains("{0}"))
		{
			this._advice.text = Localization.Format(localizedString2, new ILocalizedString[]
			{
				localizedString
			});
		}
		else
		{
			this._advice.text = localizedString2;
		}
	}

	private void ChooseBuilding()
	{
		List<CIGBuilding> list = new List<CIGBuilding>();
		bool[] availableSurfaceTypes = this._grid.AvailableSurfaceTypes;
		foreach (CIGBuilding cigbuilding in this._advice.buildings)
		{
			if (!cigbuilding.island.IsValid() || cigbuilding.island == this._island.island)
			{
				if (!cigbuilding.activatable && cigbuilding.IsUnlocked)
				{
					int requiredGridType = cigbuilding.tile.requiredGridType;
					if (requiredGridType < availableSurfaceTypes.Length && availableSurfaceTypes[requiredGridType])
					{
						list.Add(cigbuilding);
					}
				}
			}
		}
		list.Sort((CIGBuilding x, CIGBuilding y) => this._advice.getter(x) - this._advice.getter(y));
		foreach (CIGBuilding cigbuilding2 in list)
		{
			if (this._advice.getter(cigbuilding2) >= this._advice.deficiency)
			{
				this._advice.advicedBuilding = cigbuilding2;
				break;
			}
		}
		if (this._advice.advicedBuilding == null && list.Count > 0)
		{
			this._advice.advicedBuilding = list[list.Count - 1];
		}
		if (this._advice.advicedBuilding != null)
		{
			this._advice.image = this._advice.advicedBuilding.GetComponent<SpriteRenderer>().sprite;
		}
	}

	private void DetermineParameters()
	{
		switch (this._advice.type)
		{
		case AdviceType.BuildDecorations:
			this._advice.buildings.AddRange(SingletonMonobehaviour<GameObjectManager>.Instance.Decoration);
			this._advice.buildings.AddRange(SingletonMonobehaviour<GameObjectManager>.Instance.Community);
			this._advice.getter = new CIGCityAdvisor.GetProperty(CIGCityAdvisor.GetHappiness);
			break;
		case AdviceType.BuyLand:
			this._advice.image = this.ExpandSprite;
			break;
		case AdviceType.CreateJobs:
			this._advice.buildings.AddRange(SingletonMonobehaviour<GameObjectManager>.Instance.Commercial);
			this._advice.getter = new CIGCityAdvisor.GetProperty(CIGCityAdvisor.GetJobs);
			break;
		case AdviceType.BuildHouses:
		case AdviceType.AttractPeople:
			this._advice.buildings.AddRange(SingletonMonobehaviour<GameObjectManager>.Instance.Residential);
			this._advice.getter = new CIGCityAdvisor.GetProperty(CIGCityAdvisor.GetHousing);
			break;
		case AdviceType.ContinueBuilding:
			this._advice.image = this.ThumbsUpSprite;
			break;
		default:
			UnityEngine.Debug.LogError("Unknown advice type encountered");
			break;
		}
	}

	private void DetermineAdviceText()
	{
		CIGIslandState cigislandState = UnityEngine.Object.FindObjectOfType<CIGIslandState>();
		switch (this._advice.type)
		{
		case AdviceType.BuildDecorations:
			if (cigislandState.Population == 0)
			{
				this._advice.localizedString = Localization.Key("city_advisor_build_decorations");
			}
			else
			{
				this._advice.localizedString = Localization.Key("city_advisor_not_happy");
			}
			break;
		case AdviceType.BuyLand:
			this._advice.localizedString = Localization.Key("city_advisor_expand");
			break;
		case AdviceType.CreateJobs:
			if (cigislandState.Jobs == 0)
			{
				this._advice.localizedString = Localization.Key("city_advisor_make_money");
			}
			else
			{
				this._advice.localizedString = Localization.PluralKey("city_advisor_jobs_needed", (long)this._advice.deficiency);
			}
			break;
		case AdviceType.BuildHouses:
			if (cigislandState.Housing == 0)
			{
				this._advice.localizedString = Localization.Key("city_advisor_people_needed");
			}
			else
			{
				this._advice.localizedString = Localization.PluralKey("city_advisor_more_people_needed", (long)this._advice.deficiency);
			}
			break;
		case AdviceType.AttractPeople:
			if (cigislandState.Housing == 0)
			{
				this._advice.localizedString = Localization.Key("city_advisor_atttract_people");
			}
			else
			{
				this._advice.localizedString = Localization.Key("city_advisor_atttract_more_people");
			}
			break;
		case AdviceType.ContinueBuilding:
			this._advice.localizedString = Localization.Key("city_advisor_balanced");
			break;
		default:
			UnityEngine.Debug.LogError("Unknown advice type encountered");
			break;
		}
	}

	private void DetermineAdviceType()
	{
		CIGGameState instance = SingletonMonobehaviour<CIGGameState>.Instance;
		float num = (1f - (float)SingletonMonobehaviour<CIGGameStats>.Instance.NumberOfUsedElements / (float)SingletonMonobehaviour<CIGGameStats>.Instance.NumberOfUnlockedElements) * 100f;
		if ((double)instance.GlobalHappiness <= 0.95 * (double)instance.GlobalHousing)
		{
			this._advice.type = AdviceType.BuildDecorations;
			this._advice.deficiency = instance.GlobalHousing - instance.GlobalHappiness;
		}
		else if (this._land.HaveExpansionsLeft && num <= 5f)
		{
			this._advice.type = AdviceType.BuyLand;
		}
		else if (instance.GlobalJobs < instance.GlobalHousing)
		{
			this._advice.type = AdviceType.CreateJobs;
			this._advice.deficiency = instance.GlobalHousing - instance.GlobalJobs;
		}
		else if (instance.GlobalJobs > instance.GlobalHousing)
		{
			this._advice.type = AdviceType.BuildHouses;
			this._advice.deficiency = instance.GlobalJobs - instance.GlobalHousing;
		}
		else if (instance.GlobalHousing == 0 || instance.GlobalHappiness > instance.GlobalHousing)
		{
			this._advice.type = AdviceType.AttractPeople;
			this._advice.deficiency = instance.GlobalHappiness - instance.GlobalHousing;
		}
		else if (this._land.HaveExpansionsLeft && num <= 15f)
		{
			this._advice.type = AdviceType.BuyLand;
		}
		else
		{
			this._advice.type = AdviceType.ContinueBuilding;
		}
	}

	public Sprite ExpandSprite;

	public Sprite ThumbsUpSprite;

	private CIGGameState _gameState;

	private CIGCityAdvisor.AdviceProperties _advice;

	private CityIsland _island;

	private IsometricGrid _grid;

	private CIGExpansions _land;

	public delegate int GetProperty(CIGBuilding building);

	public class AdviceProperties
	{
		public AdviceType type;

		public int deficiency;

		public CIGCityAdvisor.GetProperty getter;

		public ILocalizedString localizedString;

		public List<CIGBuilding> buildings = new List<CIGBuilding>();

		public CIGBuilding advicedBuilding;

		public ILocalizedString text = Localization.EmptyLocalizedString;

		public Sprite image;

		public ILocalizedString title = Localization.EmptyLocalizedString;

		public ILocalizedString okButtonText = Localization.EmptyLocalizedString;

		public ILocalizedString cancelButtonText = Localization.EmptyLocalizedString;
	}
}