using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Text.RegularExpressions;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("ParkStats.Core")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+afeb85d5923f3daee29c3dc1ca473ef5d09b3a69")]
[assembly: AssemblyProduct("ParkStats.Core")]
[assembly: AssemblyTitle("ParkStats.Core")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ParkStats.Core
{
	public enum Severity
	{
		Low,
		Medium,
		High
	}
	public sealed record Advice(Severity Severity, string Title, string Detail);
	public static class Advisor
	{
		private const double ConditionThreshold = 0.5;

		private const double NeedMediumBelow = 0.6;

		private const double NeedHighBelow = 0.4;

		private const double NearFull = 0.9;

		private const double TicketTolerance = 0.1;

		private const double RidePriceTolerance = 0.2;

		private const double DecorationLowBelow = 0.5;

		private const double StaffCostShare = 0.5;

		private const int NamesShown = 3;

		private const int BusyParkUses = 50;

		private const int ShortestQueueWorthBuildingFor = 2;

		private static readonly Dictionary<string, string> NeedHints = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
		{
			["Fun"] = "Add more attractions or reopen closed ones.",
			["Energy"] = "Add places to rest.",
			["Hygiene"] = "Add showers and keep pools clean.",
			["Thirst"] = "Add or restock drink stands.",
			["Hunger"] = "Add or restock food stands.",
			["Toilet"] = "Build more toilets.",
			["Trash"] = "Add trash bins or cleaning staff."
		};

		public static IReadOnlyList<Advice> Evaluate(ParkSnapshot park)
		{
			List<Advice> list = new List<Advice>();
			AddRideCondition(park, list);
			AddOpenRequests(park, list);
			AddEmptyStands(park, list);
			AddQueues(park, list);
			AddWeakestNeed(park, list);
			AddCapacity(park, list);
			AddTicketPrice(park, list);
			AddRidePricing(park, list);
			AddUnused(park, list);
			AddSatisfactionMultiplier(park, list);
			AddNextStar(park, list);
			AddVisitorRoom(park, list);
			AddBuildMore(park, list);
			AddNeedDemand(park, list);
			AddUpgrades(park, list);
			AddDecoration(park, list);
			AddStaff(park, list);
			AddTopComplaint(park, list);
			return list.OrderByDescending((Advice a) => a.Severity).ToList();
		}

		private static void AddRideCondition(ParkSnapshot park, List<Advice> advice)
		{
			List<RideRow> list = park.Rides.Where((RideRow r) => r.IsBroken).ToList();
			if (list.Count > 0)
			{
				advice.Add(new Advice(Severity.High, "Repair broken rides", Names(list) + ": malfunctioning, so no guests can use them."));
			}
			List<RideRow> list2 = park.Rides.Where((RideRow r) => !r.IsOpen && !r.IsBroken).ToList();
			if (list2.Count > 0)
			{
				advice.Add(new Advice(Severity.Medium, "Reopen closed rides", Names(list2) + ": closed, earning nothing and serving no needs."));
			}
			double cleanLimit = Math.Min(park.CleanlinessThreshold ?? 0.5, 0.5);
			List<RideRow> list3 = park.Rides.Where((RideRow r) => r.Cleanliness < cleanLimit).ToList();
			if (list3.Count > 0)
			{
				advice.Add(new Advice(Severity.Medium, "Clean dirty rides", Names(list3) + ": cleanliness below " + Format.Percent(cleanLimit) + "."));
			}
			double wearLimit = Math.Min(park.DurabilityThreshold ?? 0.5, 0.5);
			List<RideRow> list4 = park.Rides.Where((RideRow r) => r.Durability < wearLimit).ToList();
			if (list4.Count > 0)
			{
				advice.Add(new Advice(Severity.Medium, "Maintain worn rides", Names(list4) + ": durability below " + Format.Percent(wearLimit) + ", breakdowns are likely."));
			}
		}

		private static void AddOpenRequests(ParkSnapshot park, List<Advice> advice)
		{
			List<List<RideRow>> list = Kinds(park.Rides.Where((RideRow r) => r.HasOpenRequest));
			if (list.Count != 0)
			{
				advice.Add(new Advice(Severity.High, "Guests have a request open", KindNames(list) + ": a guest inside has asked for different settings. Set them on the control panel; a guest who leaves without them complains of bad service."));
			}
		}

		private static void AddEmptyStands(ParkSnapshot park, List<Advice> advice)
		{
			List<List<RideRow>> list = Kinds(park.Rides.Where((RideRow r) => r.IsOpen && !r.IsBroken && r.StockCapacity > 0 && r.StockLeft == 0));
			if (list.Count != 0)
			{
				advice.Add(new Advice(Severity.High, "Restock empty stands", KindNames(list) + ": sold out. Every guest who walks up leaves without buying."));
			}
		}

		private static void AddQueues(ParkSnapshot park, List<Advice> advice)
		{
			List<(List<RideRow>, int)> list = (from kind in Kinds(park.Rides)
				select (Kind: kind, Waiting: kind.Sum((RideRow r) => r.QueueLength.GetValueOrDefault())) into k
				where k.Waiting >= Math.Max(2, k.Kind.Count)
				orderby k.Waiting descending
				select k).Take(3).ToList();
			if (list.Count == 0)
			{
				return;
			}
			IEnumerable<string> values = list.Select<(List<RideRow>, int), string>(delegate((List<RideRow> Kind, int Waiting) k)
			{
				string text = $"{KindName(k.Kind)}: {k.Waiting} waiting";
				double num = k.Kind.Sum((RideRow r) => r.Earned) / (double)k.Kind.Count;
				return (!(num > 0.0)) ? text : (text + ", about " + Format.Money(num) + " earned each today");
			});
			advice.Add(new Advice(Severity.Medium, "Guests are queuing", string.Join("; ", values) + ". Another of these would serve them sooner."));
		}

		private static void AddUnused(ParkSnapshot park, List<Advice> advice)
		{
			if (park.Rides.Sum((RideRow r) => r.UsesToday) < 50)
			{
				return;
			}
			List<List<RideRow>> list = (from kind in Kinds(park.Rides.Where((RideRow r) => r.Price > 0.0 && r.IsOpen && !r.IsBroken))
				where kind.All((RideRow r) => r.UsesToday == 0)
				select kind).ToList();
			if (list.Count != 0)
			{
				advice.Add(new Advice(Severity.Low, "Unused paid attractions", KindNames(list) + ": no guest has used them today. Check that guests can reach them, or try a lower price."));
			}
		}

		private static List<List<RideRow>> Kinds(IEnumerable<RideRow> rides)
		{
			return (from r in rides
				group r by r.Name into g
				select g.ToList()).ToList();
		}

		private static string KindName(IReadOnlyList<RideRow> kind)
		{
			if (kind.Count <= 1)
			{
				return kind[0].Name;
			}
			return $"{kind[0].Name} x{kind.Count}";
		}

		private static string KindNames(IReadOnlyList<List<RideRow>> kinds)
		{
			string text = string.Join(", ", kinds.Take(3).Select(KindName));
			if (kinds.Count <= 3)
			{
				return text;
			}
			return $"{text} and {kinds.Count - 3} more";
		}

		private static void AddWeakestNeed(ParkSnapshot park, List<Advice> advice)
		{
			NeedStat needStat = park.Needs.Where((NeedStat n) => n.Average.HasValue).MinBy((NeedStat n) => n.Average);
			double? num = needStat?.Average;
			if (!num.HasValue)
			{
				return;
			}
			double valueOrDefault = num.GetValueOrDefault();
			if (!(valueOrDefault >= 0.6))
			{
				Severity severity = ((!(valueOrDefault < 0.4)) ? Severity.Medium : Severity.High);
				string text = needStat.Name + " satisfaction is " + Format.Percent(valueOrDefault);
				if (needStat.GuestsCounted > 0)
				{
					text += $"; {needStat.GuestsLow} of {needStat.GuestsCounted} guests are under half";
				}
				text += ".";
				if (needStat.Sources.Count > 0)
				{
					text = text + " In the park it is raised by: " + string.Join(", ", needStat.Sources) + ".";
				}
				if (NeedHints.TryGetValue(needStat.Name, out string value))
				{
					text = text + " " + value;
				}
				advice.Add(new Advice(severity, "Weakest need: " + needStat.Name, text));
			}
		}

		private static void AddCapacity(ParkSnapshot park, List<Advice> advice)
		{
			foreach (CapacityLine item in park.Capacity)
			{
				if (item.Max > 0 && !((double)item.Current < (double)item.Max * 0.9))
				{
					advice.Add(new Advice(Severity.Medium, item.Name + " at capacity", $"{item.Current}/{item.Max} in use. Build more so guests are not turned away."));
				}
			}
		}

		private static void AddTicketPrice(ParkSnapshot park, List<Advice> advice)
		{
			double? ticketPrice = park.TicketPrice;
			if (!ticketPrice.HasValue)
			{
				return;
			}
			double valueOrDefault = ticketPrice.GetValueOrDefault();
			ticketPrice = park.TargetTicketPrice;
			if (!ticketPrice.HasValue)
			{
				return;
			}
			double valueOrDefault2 = ticketPrice.GetValueOrDefault();
			if (!(valueOrDefault2 <= 0.0))
			{
				if (valueOrDefault < valueOrDefault2 * 0.9)
				{
					advice.Add(new Advice(Severity.Medium, "Raise ticket price", $"Ticket price is {Format.Money(valueOrDefault)}, the park supports {Format.Money(valueOrDefault2)}."));
				}
				else if (valueOrDefault > valueOrDefault2 * 1.1)
				{
					advice.Add(new Advice(Severity.Medium, "Lower ticket price", $"Ticket price is {Format.Money(valueOrDefault)}, above the {Format.Money(valueOrDefault2)} the park supports. Guests may complain or leave."));
				}
			}
		}

		private static void AddRidePricing(ParkSnapshot park, List<Advice> advice)
		{
			List<RideRow> source = park.Rides.Where((RideRow r) => r.Price.HasValue && r.IdealPrice > 0.0).ToList();
			List<RideRow> list = source.Where((RideRow r) => r.Price < r.IdealPrice * 0.8).ToList();
			if (list.Count > 0)
			{
				advice.Add(new Advice(Severity.Low, "Underpriced rides", Names(list, PriceLabel) + ": raising prices adds income."));
			}
			List<RideRow> list2 = source.Where((RideRow r) => r.Price > r.IdealPrice * 1.2).ToList();
			if (list2.Count > 0)
			{
				advice.Add(new Advice(Severity.Low, "Overpriced rides", Names(list2, PriceLabel) + ": guests may skip them."));
			}
		}

		private static void AddSatisfactionMultiplier(ParkSnapshot park, List<Advice> advice)
		{
			double? visitorMultiplier = park.VisitorMultiplier;
			if (!visitorMultiplier.HasValue)
			{
				return;
			}
			double valueOrDefault = visitorMultiplier.GetValueOrDefault();
			visitorMultiplier = park.BestVisitorMultiplier;
			if (!visitorMultiplier.HasValue)
			{
				return;
			}
			double valueOrDefault2 = visitorMultiplier.GetValueOrDefault();
			if (!(valueOrDefault >= valueOrDefault2 - 0.005))
			{
				visitorMultiplier = park.RecentSatisfaction;
				object obj;
				if (visitorMultiplier.HasValue)
				{
					double valueOrDefault3 = visitorMultiplier.GetValueOrDefault();
					obj = "Recent satisfaction of " + Format.Percent(valueOrDefault3);
				}
				else
				{
					obj = "Recent satisfaction";
				}
				string value = (string)obj;
				string detail = $"{value} puts the game's visitor multiplier at {Format.Multiplier(valueOrDefault)}. The best is {Format.Multiplier(valueOrDefault2)}. Raising the weakest needs lifts it.";
				advice.Add((valueOrDefault < 1.0) ? new Advice(Severity.Medium, "Low satisfaction is costing visitors", detail) : new Advice(Severity.Low, "Higher satisfaction brings more visitors", detail));
			}
		}

		private static void AddVisitorRoom(ParkSnapshot park, List<Advice> advice)
		{
			int? attractionCapacity = park.AttractionCapacity;
			if (!attractionCapacity.HasValue)
			{
				return;
			}
			int valueOrDefault = attractionCapacity.GetValueOrDefault();
			PrestigeInfo prestige = park.Prestige;
			if ((object)prestige == null)
			{
				return;
			}
			attractionCapacity = prestige.MaxVisitors;
			if (!attractionCapacity.HasValue)
			{
				return;
			}
			int valueOrDefault2 = attractionCapacity.GetValueOrDefault();
			if (valueOrDefault < valueOrDefault2)
			{
				advice.Add(new Advice(Severity.Medium, "Attractions limit your visitors", $"Your open attractions hold {valueOrDefault} visitors; prestige {prestige.Level} allows {valueOrDefault2}. {valueOrDefault2 - valueOrDefault} more places would fill it.{MostRoom(park.BuildOptions)}"));
				return;
			}
			attractionCapacity = prestige.NextLevelMaxVisitors;
			if (attractionCapacity.HasValue)
			{
				int valueOrDefault3 = attractionCapacity.GetValueOrDefault();
				if (valueOrDefault < valueOrDefault3)
				{
					advice.Add(new Advice(Severity.Low, $"Build room for prestige {prestige.Level + 1}", $"Prestige {prestige.Level + 1} allows {valueOrDefault3} visitors; your attractions hold {valueOrDefault}. {valueOrDefault3 - valueOrDefault} more places are needed to use it.{MostRoom(park.BuildOptions)}"));
				}
			}
		}

		private static void AddBuildMore(ParkSnapshot park, List<Advice> advice)
		{
			IReadOnlyList<KindEconomics> source = AttractionEconomics.For(park);
			List<KindEconomics> list = (from k in source
				where k.Busy && k.PaybackDays.HasValue
				orderby k.PaybackDays
				select k).Take(3).ToList();
			if (list.Count > 0)
			{
				IEnumerable<string> values = list.Select(delegate(KindEconomics k)
				{
					int num = (int)Math.Ceiling(k.PaybackDays.Value);
					return $"{k.Name}: nets about {Format.Money(k.NetEach)} a day each and guests are waiting for it. {Format.Money(k.BuildPrice)} to build, paid back in about {num} day{((num == 1) ? "" : "s")}";
				});
				advice.Add(new Advice(Severity.Medium, "Worth building another", string.Join(". ", values) + "."));
			}
			List<KindEconomics> list2 = (from k in source
				where k.NetEach < 0.0
				orderby k.NetEach
				select k).Take(3).ToList();
			if (list2.Count > 0)
			{
				IEnumerable<string> values2 = list2.Select((KindEconomics k) => $"{k.Name}: earned {Format.Money(k.EarnedEach)} a day each against {Format.Money(k.UpkeepEach)} upkeep");
				advice.Add(new Advice(Severity.Low, "Earning less than their upkeep", string.Join("; ", values2) + ". They may still be worth keeping for the needs they serve."));
			}
		}

		private static string MostRoom(IReadOnlyList<BuildOption> options)
		{
			List<BuildOption> list = options.Where((BuildOption o) => o.LockedBy == null && o.Capacity > 0).ToList();
			if (list.Count == 0)
			{
				return "";
			}
			int largest = list.Max((BuildOption o) => o.Capacity);
			IEnumerable<string> values = from o in (from o in list
					where o.Capacity * 2 >= largest
					orderby o.Capacity descending, o.Tier descending
					select o).Take(3)
				select $"{o.Name} (+{o.Capacity})";
			return " Most room per build: " + string.Join(", ", values) + ".";
		}

		private static void AddNeedDemand(ParkSnapshot park, List<Advice> advice)
		{
			foreach (NeedDemand item in Demand.ByNeed(park))
			{
				DemandVerdict verdict = item.Verdict;
				if ((uint)(verdict - 3) > 1u)
				{
					continue;
				}
				string need = item.Need;
				string text = $"{item.UsersNow}/{item.Capacity} places in use";
				if (item.Waiting > 0)
				{
					text += $", {item.Waiting} waiting";
				}
				text += ".";
				IGrouping<string, RideRow> grouping = (from r in park.Rides
					where r.Raises.Contains(need) && r.IsOpen && !r.IsBroken
					group r by r.Name into g
					orderby g.Sum((RideRow r) => r.QueueLength.GetValueOrDefault()) descending, (double)g.Sum((RideRow r) => r.UsersNow.GetValueOrDefault()) / (double)Math.Max(1, g.Sum((RideRow r) => r.Capacity.GetValueOrDefault())) descending
					select g).FirstOrDefault();
				if (grouping != null)
				{
					RideRow rideRow = grouping.First();
					int num = grouping.Sum((RideRow r) => r.QueueLength.GetValueOrDefault());
					text = text + $" Busiest: {grouping.Key}{Demand.Service(rideRow.Staffed)} ({grouping.Sum((RideRow r) => r.UsersNow.GetValueOrDefault())}/{grouping.Sum((RideRow r) => r.Capacity.GetValueOrDefault())} in use" + ((num > 0) ? $", {num} waiting)." : ").");
				}
				BuildOption buildOption = Demand.BestUnlocked(park.BuildOptions, (BuildOption o) => o.Raises.Contains(need) && o.Category != "Food and drink");
				if ((object)buildOption != null)
				{
					text += $" Best unlocked for it: {buildOption.Name} ({buildOption.Capacity} at once).";
				}
				List<string> list = (from o in (from o in park.BuildOptions
						where o.Raises.Contains(need) && o.Category == "Food and drink" && o.LockedBy == null && Demand.NotOwned(park, o)
						orderby o.Tier descending
						select o).Take(2)
					select o.Name + Demand.Service(o.Staffed)).ToList();
				if (list.Count > 0)
				{
					text = text + " Not built yet for it: " + string.Join(", ", list) + ".";
				}
				advice.Add(new Advice(Severity.Medium, "Build more for " + need, text));
			}
		}

		private static void AddUpgrades(ParkSnapshot park, List<Advice> advice)
		{
			IReadOnlyList<(string, int, BuildOption)> readOnlyList = Demand.Upgrades(park);
			if (readOnlyList.Count == 0)
			{
				return;
			}
			IEnumerable<string> values = readOnlyList.Take(3).Select<(string, int, BuildOption), string>(delegate((string Owned, int Count, BuildOption Better) u)
			{
				object obj;
				if (u.Count <= 1)
				{
					(obj, _, _) = u;
				}
				else
				{
					obj = $"{u.Owned} x{u.Count}";
				}
				return (string?)obj + ": " + u.Better.Name + " is unlocked";
			});
			advice.Add(new Advice(Severity.Low, "Better versions unlocked", string.Join("; ", values) + ". Replacing old ones as they wear out raises what each place earns."));
		}

		private static void AddNextStar(ParkSnapshot park, List<Advice> advice)
		{
			if (string.IsNullOrWhiteSpace(park.NextStarTask))
			{
				return;
			}
			string text = "";
			PrestigeInfo prestige = park.Prestige;
			int? nextLevelMaxVisitors;
			if ((object)prestige != null)
			{
				int? maxVisitors = prestige.MaxVisitors;
				if (maxVisitors.HasValue)
				{
					int valueOrDefault = maxVisitors.GetValueOrDefault();
					nextLevelMaxVisitors = prestige.NextLevelMaxVisitors;
					if (nextLevelMaxVisitors.HasValue)
					{
						int valueOrDefault2 = nextLevelMaxVisitors.GetValueOrDefault();
						text = $"Prestige {prestige.Level + 1} raises the visitor base from {valueOrDefault} to {valueOrDefault2}. ";
					}
				}
			}
			text = text + "Still to do: " + park.NextStarTask;
			nextLevelMaxVisitors = park.Visitors;
			int num;
			if (nextLevelMaxVisitors.HasValue)
			{
				int valueOrDefault3 = nextLevelMaxVisitors.GetValueOrDefault();
				nextLevelMaxVisitors = park.MaxVisitors;
				if (nextLevelMaxVisitors.HasValue)
				{
					int valueOrDefault4 = nextLevelMaxVisitors.GetValueOrDefault();
					if (valueOrDefault4 > 0)
					{
						num = (((double)valueOrDefault3 >= (double)valueOrDefault4 * 0.9) ? 1 : 0);
						goto IL_011a;
					}
				}
			}
			num = 0;
			goto IL_011a;
			IL_011a:
			bool flag = (byte)num != 0;
			advice.Add(new Advice(flag ? Severity.Medium : Severity.Low, "Next star", text));
		}

		private static void AddDecoration(ParkSnapshot park, List<Advice> advice)
		{
			double? num = park.Prestige?.DecorationLevel;
			if (num.HasValue)
			{
				double valueOrDefault = num.GetValueOrDefault();
				if (!(valueOrDefault >= 0.5))
				{
					advice.Add(new Advice(Severity.Low, "Decorate the park", "Decoration is at " + Format.Percent(valueOrDefault) + ". Guests notice decoration, and it raises tips."));
				}
			}
		}

		private static void AddStaff(ParkSnapshot park, List<Advice> advice)
		{
			int? staffCount = park.StaffCount;
			if (staffCount.HasValue)
			{
				int valueOrDefault = staffCount.GetValueOrDefault();
				staffCount = park.StaffCapacity;
				if (staffCount.HasValue)
				{
					int valueOrDefault2 = staffCount.GetValueOrDefault();
					if (valueOrDefault > valueOrDefault2)
					{
						int value = valueOrDefault - valueOrDefault2;
						string text = $"{valueOrDefault} staff for a capacity of {valueOrDefault2}.";
						if (park.StaffTax > 0.0)
						{
							text += $" The {value} extra cost {Format.Money(park.StaffTax)} a day in staff tax";
							if (park.StaffTaxPerExtra > 0.0)
							{
								text = text + " (" + Format.Money(park.StaffTaxPerExtra) + " each)";
							}
							text += ".";
						}
						text += $" Expand staff capacity or let {value} go.";
						advice.Add(new Advice(Severity.Medium, "Staff over capacity", text));
					}
				}
			}
			double? staffSalary = park.StaffSalary;
			if (!staffSalary.HasValue)
			{
				return;
			}
			double valueOrDefault3 = staffSalary.GetValueOrDefault();
			staffSalary = park.TypicalDayIncome;
			if (!staffSalary.HasValue)
			{
				return;
			}
			double valueOrDefault4 = staffSalary.GetValueOrDefault();
			if (!(valueOrDefault4 <= 0.0))
			{
				double num = valueOrDefault3 + park.StaffTax.GetValueOrDefault();
				if (!(num <= valueOrDefault4 * 0.5))
				{
					advice.Add(new Advice(Severity.Medium, "Staff cost is high", $"Staff cost {Format.Money(num)} a day is {Format.Percent(num / valueOrDefault4)} of a typical day's income ({Format.Money(valueOrDefault4)})."));
				}
			}
		}

		private static void AddTopComplaint(ParkSnapshot park, List<Advice> advice)
		{
			CountLine countLine = park.Complaints.Where((CountLine c) => c.Count > 0).MaxBy((CountLine c) => c.Count);
			if ((object)countLine != null)
			{
				string text = $"\"{countLine.Label}\" ({countLine.Count} times).";
				if (!string.IsNullOrWhiteSpace(countLine.Note))
				{
					text = text + " " + countLine.Note;
				}
				advice.Add(new Advice(Severity.Low, "Top complaint", text));
			}
		}

		private static string PriceLabel(RideRow ride)
		{
			return $"{ride.Name} ({Format.Money(ride.Price)}, ideal {Format.Money(ride.IdealPrice)})";
		}

		private static string Names(IReadOnlyList<RideRow> rides, Func<RideRow, string>? label = null)
		{
			if (label == null)
			{
				label = (RideRow r) => r.Name;
			}
			string text = string.Join(", ", rides.Take(3).Select(label));
			if (rides.Count <= 3)
			{
				return text;
			}
			return $"{text} and {rides.Count - 3} more";
		}
	}
	public sealed record KindEconomics
	{
		public string Name { get; init; } = "";

		public int Count { get; init; }

		public double EarnedEach { get; init; }

		public double UpkeepEach { get; init; }

		public bool FullDay { get; init; }

		public double? NetEach { get; init; }

		public int? UsersNow { get; init; }

		public int? Capacity { get; init; }

		public int Waiting { get; init; }

		public bool Busy { get; init; }

		public double? BuildPrice { get; init; }

		public double? PaybackDays { get; init; }
	}
	public static class AttractionEconomics
	{
		private const double NearlyFull = 0.8;

		public static IReadOnlyList<KindEconomics> For(ParkSnapshot park)
		{
			List<KindEconomics> list = new List<KindEconomics>();
			foreach (IGrouping<string, RideRow> item in from r in park.Rides
				group r by r.Name)
			{
				List<RideRow> list2 = item.ToList();
				double num = list2.Average((RideRow r) => r.MaintenancePerDay.GetValueOrDefault());
				if (list2.Any((RideRow r) => r.Price > 0.0) || !(num <= 0.0))
				{
					AttractionDay value = null;
					park.YesterdayAttractions?.TryGetValue(item.Key, out value);
					bool flag = (object)value != null && value.Count > 0;
					double num2 = (flag ? (value.Earned / (double)value.Count) : (list2.Sum((RideRow r) => r.Earned) / (double)list2.Count));
					double? num3 = (flag ? new double?(num2 - num) : ((double?)null));
					double? num4 = list2.Select((RideRow r) => r.BuildPrice).FirstOrDefault((double? p) => p.HasValue);
					int? num5 = (list2.Any((RideRow r) => r.UsersNow.HasValue) ? new int?(list2.Sum((RideRow r) => r.UsersNow.GetValueOrDefault())) : ((int?)null));
					int? num6 = (list2.Any((RideRow r) => r.Capacity.HasValue) ? new int?(list2.Sum((RideRow r) => r.Capacity.GetValueOrDefault())) : ((int?)null));
					int num7 = list2.Sum((RideRow r) => r.QueueLength.GetValueOrDefault());
					list.Add(new KindEconomics
					{
						Name = item.Key,
						Count = list2.Count,
						EarnedEach = num2,
						UpkeepEach = num,
						FullDay = flag,
						NetEach = num3,
						UsersNow = num5,
						Capacity = num6,
						Waiting = num7,
						Busy = (num7 >= list2.Count || (num6 > 0 && (double?)num5 >= (double?)num6 * 0.8)),
						BuildPrice = num4,
						PaybackDays = ((!(num3 > 0.0) || !(num4 > 0.0)) ? ((double?)null) : (num4 / num3))
					});
				}
			}
			return (from k in list
				orderby k.NetEach ?? double.MinValue descending, k.EarnedEach descending
				select k).ToList();
		}
	}
	public static class ComplaintHints
	{
		private const int PlacesShown = 3;

		private static readonly Dictionary<string, string> Hints = new Dictionary<string, string>
		{
			["PoorService"] = "A guest in a sauna or hot tub asked for different settings and did not get them. Set what they ask for on its control panel.",
			["WaitedTooLong"] = "They gave up waiting to be served. The stand or desk needs more or faster staff.",
			["Waiting"] = "They are waiting to be served.",
			["Tired"] = "No free lounger when they needed rest.",
			["SleptOnFloor"] = "They slept on the floor for lack of a free lounger.",
			["LowTrash"] = "They could not find a trash bin in time.",
			["LowToilet"] = "They could not reach a toilet in time.",
			["LowHygeine"] = "They could not get to a shower.",
			["Hungry"] = "They found nothing to eat.",
			["Thirsty"] = "They found nothing to drink.",
			["Bored"] = "Not enough fun attractions for them.",
			["UsedDirtyAttraction"] = "An attraction they used was dirty. It needs cleaning.",
			["UsedWornAttraction"] = "An attraction they used was worn. It needs a repair.",
			["WaterWasDirty"] = "The pool water was dirty.",
			["PoolWasDrained"] = "A pool was drained while they wanted to swim.",
			["BadDecorationLevel"] = "The park has too little decoration.",
			["Drowning"] = "A guest was drowning. Lifeguards prevent this.",
			["Slipped"] = "They slipped on a wet floor.",
			["Injured"] = "They were injured on an attraction.",
			["Panic"] = "They panicked on an attraction.",
			["PhotographedByPervert"] = "A visitor is taking unwanted photos. Catch them.",
			["SawVomit"] = "Someone was sick nearby.",
			["Disgust"] = "They saw something disgusting nearby."
		};

		private static readonly HashSet<string> AboutAnAttraction = new HashSet<string> { "PoorService", "WaitedTooLong", "Waiting", "UsedDirtyAttraction", "UsedWornAttraction", "WaterWasDirty", "PoolWasDrained", "Drowning", "Injured" };

		public static string? For(string thought)
		{
			if (!Hints.TryGetValue(thought, out string value))
			{
				return null;
			}
			return value;
		}

		public static string? Note(string thought, IReadOnlyList<CountLine> places)
		{
			List<string> list = new List<string>();
			string text = For(thought);
			if (text != null)
			{
				list.Add(text);
			}
			List<CountLine> list2 = (AboutAnAttraction.Contains(thought) ? (from p in places
				where p.Count > 0
				orderby p.Count descending
				select p).Take(3).ToList() : new List<CountLine>());
			if (list2.Count > 0)
			{
				list.Add("Mostly at: " + string.Join(", ", list2.Select((CountLine p) => $"{p.Label} ({p.Count})")) + ".");
			}
			if (list.Count != 0)
			{
				return string.Join(" ", list);
			}
			return null;
		}
	}
	public enum DemandVerdict
	{
		NoneBuilt,
		Plenty,
		Fine,
		NearlyFull,
		Short
	}
	public sealed record NeedDemand
	{
		public string Need { get; init; } = "";

		public int Units { get; init; }

		public int UsersNow { get; init; }

		public int Capacity { get; init; }

		public int Waiting { get; init; }

		public DemandVerdict Verdict { get; init; }
	}
	public static class Demand
	{
		public static readonly string[] Needs = new string[7] { "Fun", "Energy", "Hygiene", "Thirst", "Hunger", "Toilet", "Trash" };

		public const string FoodAndDrink = "Food and drink";

		private const double NearlyFullFrom = 0.8;

		private const double PlentyBelow = 0.3;

		public static IReadOnlyList<NeedDemand> ByNeed(ParkSnapshot park)
		{
			List<NeedDemand> list = new List<NeedDemand>();
			string[] needs = Needs;
			foreach (string need in needs)
			{
				List<RideRow> list2 = park.Rides.Where((RideRow r) => r.Raises.Contains(need) && r.IsOpen && !r.IsBroken).ToList();
				if (list2.Count == 0)
				{
					list.Add(new NeedDemand
					{
						Need = need,
						Verdict = DemandVerdict.NoneBuilt
					});
					continue;
				}
				int num = list2.Sum((RideRow r) => r.UsersNow.GetValueOrDefault());
				int num2 = list2.Sum((RideRow r) => r.Capacity.GetValueOrDefault());
				int num3 = list2.Sum((RideRow r) => r.QueueLength.GetValueOrDefault());
				DemandVerdict verdict = ((num3 >= list2.Count) ? DemandVerdict.Short : ((num2 > 0 && (double)num >= (double)num2 * 0.8) ? DemandVerdict.NearlyFull : ((num2 > 0 && (double)num < (double)num2 * 0.3 && num3 == 0) ? DemandVerdict.Plenty : DemandVerdict.Fine)));
				list.Add(new NeedDemand
				{
					Need = need,
					Units = list2.Count,
					UsersNow = num,
					Capacity = num2,
					Waiting = num3,
					Verdict = verdict
				});
			}
			return list;
		}

		public static string Service(bool? staffed)
		{
			if (staffed.HasValue)
			{
				if (staffed == true)
				{
					return " (staffed)";
				}
				return " (automated)";
			}
			return "";
		}

		public static bool? StaffedFromNames(string internalName, string displayName)
		{
			string names = internalName + " " + displayName;
			if (Says("Machine"))
			{
				return false;
			}
			if (Says("Stand") || Says("Stall") || Says("Cart") || Says("Kiosk"))
			{
				return true;
			}
			return null;
			bool Says(string word)
			{
				return names.Contains(word, StringComparison.OrdinalIgnoreCase);
			}
		}

		public static bool NotOwned(ParkSnapshot park, BuildOption option)
		{
			if (option.Owned == 0)
			{
				return !park.Rides.Any((RideRow r) => r.Name == option.Name);
			}
			return false;
		}

		public static string Describe(DemandVerdict verdict)
		{
			return verdict switch
			{
				DemandVerdict.NoneBuilt => "None built", 
				DemandVerdict.Plenty => "Plenty", 
				DemandVerdict.Fine => "Fine", 
				DemandVerdict.NearlyFull => "Nearly full", 
				_ => "Short", 
			};
		}

		public static BuildOption? BestUnlocked(IEnumerable<BuildOption> options, Func<BuildOption, bool> match)
		{
			return (from o in options
				where o.LockedBy == null && match(o)
				orderby o.Tier descending, o.Capacity descending, o.IdealPrice.GetValueOrDefault() descending
				select o).FirstOrDefault();
		}

		public static IReadOnlyList<(string Owned, int Count, BuildOption Better)> Upgrades(ParkSnapshot park)
		{
			List<(string, int, BuildOption)> list = new List<(string, int, BuildOption)>();
			foreach (IGrouping<string, RideRow> item in from r in park.Rides
				where r.Category != null && r.Category != "Food and drink" && r.Tier.HasValue
				group r by r.Name)
			{
				RideRow sample = item.First();
				BuildOption buildOption = BestUnlocked(park.BuildOptions, (BuildOption o) => o.Category == sample.Category);
				if ((object)buildOption != null && buildOption.Tier > sample.Tier && buildOption.Name != item.Key)
				{
					list.Add((item.Key, item.Count(), buildOption));
				}
			}
			return list.OrderByDescending(((string, int, BuildOption) u) => u.Item2).ToList();
		}
	}
	public static class Format
	{
		public const string Unknown = "n/a";

		public static string Money(double? amount)
		{
			if (!amount.HasValue)
			{
				return "n/a";
			}
			double num = Math.Round(amount.Value, MidpointRounding.AwayFromZero);
			if (num == 0.0)
			{
				return "0";
			}
			return num.ToString("#,0", CultureInfo.InvariantCulture);
		}

		public static string Signed(double? amount)
		{
			string text = Money(amount);
			if (!(amount > 0.0) || !(text != "0"))
			{
				return text;
			}
			return "+" + text;
		}

		public static string Percent(double? fraction)
		{
			if (!fraction.HasValue)
			{
				return "n/a";
			}
			return Math.Round(fraction.Value * 100.0, MidpointRounding.AwayFromZero).ToString("0", CultureInfo.InvariantCulture) + "%";
		}

		public static string Multiplier(double? value)
		{
			if (value.HasValue)
			{
				return "x" + value.Value.ToString("0.00", CultureInfo.InvariantCulture);
			}
			return "n/a";
		}

		public static string Ratio(int? current, int? max)
		{
			return Count(current) + "/" + Count(max);
		}

		public static string Count(int? value)
		{
			return value?.ToString(CultureInfo.InvariantCulture) ?? "n/a";
		}

		public static string Reason(string reason)
		{
			if (reason == "Maintance")
			{
				return "Maintenance";
			}
			StringBuilder stringBuilder = new StringBuilder(reason.Length + 4);
			for (int i = 0; i < reason.Length; i++)
			{
				char c = reason[i];
				if (i > 0 && char.IsUpper(c))
				{
					stringBuilder.Append(' ').Append(char.ToLowerInvariant(c));
				}
				else
				{
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.ToString();
		}
	}
	public sealed record DayRecord
	{
		public int Day { get; init; }

		public int? Visitors { get; init; }

		public double Income { get; init; }

		public double Expenses { get; init; }

		public double? Satisfaction { get; init; }

		public Dictionary<string, double> Needs { get; init; } = new Dictionary<string, double>();

		public Dictionary<string, AttractionDay> Attractions { get; init; } = new Dictionary<string, AttractionDay>();

		[JsonIgnore]
		public double Net => Income + Expenses;

		public static DayRecord From(ParkSnapshot park)
		{
			MoneyBreakdown moneyBreakdown = MoneyBreakdown.From(park.MoneyToday);
			return new DayRecord
			{
				Day = park.Day.GetValueOrDefault(),
				Visitors = park.VisitorsToday,
				Income = moneyBreakdown.TotalIncome,
				Expenses = moneyBreakdown.TotalExpenses,
				Satisfaction = (park.DaySatisfaction ?? park.Satisfaction),
				Needs = park.Needs.Where((NeedStat n) => n.Average.HasValue).ToDictionary((NeedStat n) => n.Name, (NeedStat n) => n.Average.Value),
				Attractions = (from r in park.Rides
					group r by r.Name).ToDictionary((IGrouping<string, RideRow> g) => g.Key, (IGrouping<string, RideRow> g) => new AttractionDay
				{
					Count = g.Count(),
					Uses = g.Sum((RideRow r) => r.UsesToday),
					Earned = g.Sum((RideRow r) => r.Earned)
				})
			};
		}
	}
	public sealed class HistoryStore
	{
		private static readonly JsonSerializerOptions JsonOptions = new JsonSerializerOptions
		{
			WriteIndented = true
		};

		private readonly string _path;

		private readonly int _maxDays;

		private List<DayRecord> _records;

		public IReadOnlyList<DayRecord> Records => _records;

		public HistoryStore(string path, int maxDays = 60)
		{
			_path = path;
			_maxDays = maxDays;
			_records = Load(path);
		}

		public void Add(DayRecord record)
		{
			_records.RemoveAll((DayRecord r) => r.Day >= record.Day);
			_records.Add(record);
			if (_records.Count > _maxDays)
			{
				_records.RemoveRange(0, _records.Count - _maxDays);
			}
			Save();
		}

		public void FillSatisfaction(int day, double satisfaction)
		{
			int num = _records.FindIndex((DayRecord r) => r.Day == day);
			if (num >= 0)
			{
				double? satisfaction2 = _records[num].Satisfaction;
				if (!satisfaction2.HasValue || !(satisfaction2.GetValueOrDefault() > 0.0))
				{
					_records[num] = _records[num]with
					{
						Satisfaction = satisfaction
					};
					Save();
				}
			}
		}

		public double? TypicalIncome(int days = 3)
		{
			List<DayRecord> list = _records.TakeLast(days).ToList();
			if (list.Count != 0)
			{
				return list.Average((DayRecord r) => r.Income);
			}
			return null;
		}

		private void Save()
		{
			string directoryName = Path.GetDirectoryName(_path);
			if (!string.IsNullOrEmpty(directoryName))
			{
				Directory.CreateDirectory(directoryName);
			}
			File.WriteAllText(_path, JsonSerializer.Serialize(_records, JsonOptions));
		}

		private static List<DayRecord> Load(string path)
		{
			if (!File.Exists(path))
			{
				return new List<DayRecord>();
			}
			try
			{
				return JsonSerializer.Deserialize<List<DayRecord>>(File.ReadAllText(path), JsonOptions)?.OrderBy((DayRecord r) => r.Day).ToList() ?? new List<DayRecord>();
			}
			catch (JsonException)
			{
				return new List<DayRecord>();
			}
		}
	}
	public sealed record MoneyLine(string Reason, double Amount);
	public sealed record LoanLine(string Label, double Remaining);
	public sealed record CountLine(string Label, int Count)
	{
		public string? Note { get; init; }
	}
	public sealed record CapacityLine(string Name, int Current, int Max);
	public sealed record NeedStat(string Name, double? Average, int GuestsLow, int GuestsCounted)
	{
		public IReadOnlyList<string> Sources { get; init; } = Array.Empty<string>();
	}
	public sealed record RideRow
	{
		public string Name { get; init; } = "";

		public bool IsOpen { get; init; } = true;

		public bool IsBroken { get; init; }

		public int UsesToday { get; init; }

		public double? Price { get; init; }

		public double? IdealPrice { get; init; }

		public double? Cleanliness { get; init; }

		public double? Durability { get; init; }

		public int? QueueLength { get; init; }

		public double? MaintenancePerDay { get; init; }

		public int? StockLeft { get; init; }

		public int? StockCapacity { get; init; }

		public string? Category { get; init; }

		public int? Tier { get; init; }

		public IReadOnlyList<string> Raises { get; init; } = Array.Empty<string>();

		public bool? Staffed { get; init; }

		public int? UsersNow { get; init; }

		public int? Capacity { get; init; }

		public double? BuildPrice { get; init; }

		public bool HasOpenRequest { get; init; }

		public double Earned => (double)UsesToday * Price.GetValueOrDefault();
	}
	public sealed record AttractionDay
	{
		public int Count { get; init; }

		public int Uses { get; init; }

		public double Earned { get; init; }
	}
	public sealed record BuildOption
	{
		public string Name { get; init; } = "";

		public double Price { get; init; }

		public string? Category { get; init; }

		public int Tier { get; init; }

		public bool? Staffed { get; init; }

		public int Capacity { get; init; }

		public double? IdealPrice { get; init; }

		public double? MaintenancePerDay { get; init; }

		public IReadOnlyList<string> Raises { get; init; } = Array.Empty<string>();

		public int Owned { get; init; }

		public string? LockedBy { get; init; }
	}
	public sealed record PrestigeInfo
	{
		public int Level { get; init; }

		public int? MaxVisitors { get; init; }

		public int? NextLevelMaxVisitors { get; init; }

		public double? DecorationLevel { get; init; }
	}
	public sealed record ParkSnapshot
	{
		public int? Day { get; init; }

		public double? Money { get; init; }

		public double? TotalEarned { get; init; }

		public double? TotalSpent { get; init; }

		public double? TicketPrice { get; init; }

		public double? TargetTicketPrice { get; init; }

		public IReadOnlyList<MoneyLine> MoneyToday { get; init; } = Array.Empty<MoneyLine>();

		public IReadOnlyList<LoanLine> Loans { get; init; } = Array.Empty<LoanLine>();

		public int? Visitors { get; init; }

		public int? ExpectedVisitors { get; init; }

		public int? MaxVisitors { get; init; }

		public int? VisitorsToday { get; init; }

		public int? RefundedVisitors { get; init; }

		public int? InjuredVisitors { get; init; }

		public double? Satisfaction { get; init; }

		public double? DaySatisfaction { get; init; }

		public double? RecentSatisfaction { get; init; }

		public double? AverageGuestCash { get; init; }

		public IReadOnlyList<NeedStat> Needs { get; init; } = Array.Empty<NeedStat>();

		public IReadOnlyList<CountLine> Complaints { get; init; } = Array.Empty<CountLine>();

		public IReadOnlyList<CountLine> LeavingReasons { get; init; } = Array.Empty<CountLine>();

		public PrestigeInfo? Prestige { get; init; }

		public int? AttractionCapacity { get; init; }

		public IReadOnlyList<BuildOption> BuildOptions { get; init; } = Array.Empty<BuildOption>();

		public IReadOnlyDictionary<string, AttractionDay>? YesterdayAttractions { get; init; }

		public string? NextStarTask { get; init; }

		public double? VisitorMultiplier { get; init; }

		public double? BestVisitorMultiplier { get; init; }

		public double? TypicalDayIncome { get; init; }

		public IReadOnlyList<RideRow> Rides { get; init; } = Array.Empty<RideRow>();

		public IReadOnlyList<CapacityLine> Capacity { get; init; } = Array.Empty<CapacityLine>();

		public double? CleanlinessThreshold { get; init; }

		public double? DurabilityThreshold { get; init; }

		public int? StaffCount { get; init; }

		public int? StaffCapacity { get; init; }

		public double? StaffSalary { get; init; }

		public double? StaffTax { get; init; }

		public double? StaffTaxPerExtra { get; init; }
	}
	public sealed class MoneyBreakdown
	{
		public IReadOnlyList<MoneyLine> Income { get; private init; } = Array.Empty<MoneyLine>();

		public IReadOnlyList<MoneyLine> Expenses { get; private init; } = Array.Empty<MoneyLine>();

		public double TotalIncome { get; private init; }

		public double TotalExpenses { get; private init; }

		public double Net => TotalIncome + TotalExpenses;

		public static MoneyBreakdown From(IEnumerable<MoneyLine> lines)
		{
			List<MoneyLine> source = (from l in lines
				group l by l.Reason into g
				select new MoneyLine(g.Key, g.Sum((MoneyLine l) => l.Amount))).ToList();
			List<MoneyLine> list = (from l in source
				where l.Amount > 0.0
				orderby l.Amount descending
				select l).ToList();
			List<MoneyLine> list2 = (from l in source
				where l.Amount < 0.0
				orderby l.Amount
				select l).ToList();
			return new MoneyBreakdown
			{
				Income = list,
				Expenses = list2,
				TotalIncome = list.Sum((MoneyLine l) => l.Amount),
				TotalExpenses = list2.Sum((MoneyLine l) => l.Amount)
			};
		}
	}
	public static class Normalize
	{
		private const double LargestFraction = 1.5;

		private static readonly HashSet<string> CostReasons = new HashSet<string> { "Building", "LoanPayment", "StaffSalary", "Maintance", "Fine", "Research", "StaffTax", "TicketRefund" };

		public static double? Fraction(double? raw)
		{
			if (raw.HasValue)
			{
				double num = raw.GetValueOrDefault();
				if (num > 1.5)
				{
					num /= 100.0;
				}
				return Math.Clamp(num, 0.0, 1.0);
			}
			return null;
		}

		public static IReadOnlyList<MoneyLine> Signs(IReadOnlyList<MoneyLine> lines)
		{
			if (lines.Any((MoneyLine l) => l.Amount < 0.0))
			{
				return lines;
			}
			return lines.Select((MoneyLine l) => (!CostReasons.Contains(l.Reason)) ? l : l with
			{
				Amount = 0.0 - l.Amount
			}).ToList();
		}

		public static IReadOnlyList<CountLine> Since(IReadOnlyDictionary<string, int> baseline, IReadOnlyDictionary<string, int> current)
		{
			List<CountLine> list = new List<CountLine>();
			foreach (KeyValuePair<string, int> item in current)
			{
				item.Deconstruct(out var key, out var value);
				string text = key;
				int num = value;
				int value2;
				int num2 = (baseline.TryGetValue(text, out value2) ? value2 : 0);
				int num3 = ((num >= num2) ? (num - num2) : num);
				if (num3 > 0)
				{
					list.Add(new CountLine(text, num3));
				}
			}
			return list;
		}
	}
	public enum RowKind
	{
		Header,
		Normal,
		Good,
		Bad,
		Muted
	}
	public sealed record Row(RowKind Kind, IReadOnlyList<string> Cells)
	{
		public string Text => string.Join(" | ", Cells);

		public static Row Of(RowKind kind, params string[] cells)
		{
			return new Row(kind, cells);
		}
	}
	public static class Pages
	{
		private const string NothingToFix = "Nothing needs fixing right now";

		private const string Blank = "-";

		private const double NeedGoodFrom = 0.7;

		private const double NeedBadBelow = 0.4;

		private const int ComplaintsShown = 5;

		private const int OverviewAdviceShown = 3;

		private const int LongestRideName = 20;

		private const int EarnersShown = 8;

		private const int BuildOptionsShown = 6;

		private const int EconomicsShown = 12;

		private const double UnlimitedCashFrom = 500000.0;

		public static IReadOnlyList<Row> Overview(ParkSnapshot park, IReadOnlyList<Advice> advice)
		{
			List<Row> list = new List<Row>();
			list.Add(Row.Of(RowKind.Header, "Today"));
			List<Row> list2 = list;
			double net = MoneyBreakdown.From(park.MoneyToday).Net;
			list2.Add(Row.Of(SignKind(net), "Net today", Format.Signed(net)));
			AddIfKnown(list2, "Balance", park.Money);
			if (park.Visitors.HasValue)
			{
				string text = ((!park.MaxVisitors.HasValue) ? Format.Count(park.Visitors) : Format.Ratio(park.Visitors, park.MaxVisitors));
				int? expectedVisitors = park.ExpectedVisitors;
				if (expectedVisitors.HasValue)
				{
					int valueOrDefault = expectedVisitors.GetValueOrDefault();
					if (valueOrDefault != park.MaxVisitors)
					{
						text += $" (expected {valueOrDefault})";
					}
				}
				list2.Add(Row.Of(RowKind.Normal, "Visitors", text));
			}
			if (park.Satisfaction.HasValue)
			{
				list2.Add(Row.Of(RowKind.Normal, "Satisfaction", Format.Percent(park.Satisfaction)));
			}
			PrestigeInfo prestige = park.Prestige;
			if ((object)prestige != null)
			{
				string text2 = Format.Count(prestige.Level);
				int? expectedVisitors = prestige.MaxVisitors;
				if (expectedVisitors.HasValue)
				{
					int valueOrDefault2 = expectedVisitors.GetValueOrDefault();
					text2 += $" (allows {valueOrDefault2} visitors)";
				}
				list2.Add(Row.Of(RowKind.Normal, "Prestige", text2));
				if (prestige.DecorationLevel.HasValue)
				{
					list2.Add(Row.Of(RowKind.Normal, "Decoration", Format.Percent(prestige.DecorationLevel)));
				}
			}
			list2.Add(Row.Of(RowKind.Header, "Do next"));
			list2.AddRange(Advisor(advice.Take(3).ToList()));
			return list2;
		}

		public static IReadOnlyList<Row> Money(ParkSnapshot park)
		{
			MoneyBreakdown moneyBreakdown = MoneyBreakdown.From(park.MoneyToday);
			List<Row> list = new List<Row>();
			list.Add(Row.Of(RowKind.Header, "Today", Format.Signed(moneyBreakdown.Net)));
			List<Row> list2 = list;
			if (moneyBreakdown.Income.Count == 0 && moneyBreakdown.Expenses.Count == 0)
			{
				list2.Add(Row.Of(RowKind.Muted, "No money movements today yet"));
			}
			else
			{
				foreach (MoneyLine item in moneyBreakdown.Income)
				{
					list2.Add(Row.Of(RowKind.Good, Format.Reason(item.Reason), Format.Signed(item.Amount)));
				}
				foreach (MoneyLine expense in moneyBreakdown.Expenses)
				{
					list2.Add(Row.Of(RowKind.Bad, Format.Reason(expense.Reason), Format.Signed(expense.Amount)));
				}
				list2.Add(Row.Of(RowKind.Normal, "Income", Format.Signed(moneyBreakdown.TotalIncome)));
				list2.Add(Row.Of(RowKind.Normal, "Expenses", Format.Signed(moneyBreakdown.TotalExpenses)));
			}
			if (park.VisitorsToday > 0)
			{
				list2.Add(Row.Of(RowKind.Normal, "Visitors today", Format.Count(park.VisitorsToday)));
				list2.Add(Row.Of(RowKind.Normal, "Income per visitor", Format.Money(moneyBreakdown.TotalIncome / (double)park.VisitorsToday.Value)));
			}
			List<(string, int, double)> list3 = (from r in park.Rides
				group r by r.Name into g
				select (Name: g.Key, Count: g.Count(), Earned: g.Sum((RideRow r) => r.Earned)) into k
				where k.Earned > 0.0
				orderby k.Earned descending
				select k).Take(8).ToList();
			if (list3.Count > 0)
			{
				list2.Add(Row.Of(RowKind.Header, "Earned by attraction (uses x price)"));
				foreach (var item2 in list3)
				{
					list2.Add(Row.Of(RowKind.Normal, KindLabel(item2.Item1, item2.Item2), Format.Money(item2.Item3)));
				}
			}
			list2.Add(Row.Of(RowKind.Header, "Park"));
			AddIfKnown(list2, "Balance", park.Money);
			if (park.TicketPrice.HasValue)
			{
				string text = Format.Money(park.TicketPrice);
				if (park.TargetTicketPrice.HasValue)
				{
					text = text + " (target " + Format.Money(park.TargetTicketPrice) + ")";
				}
				list2.Add(Row.Of(RowKind.Normal, "Ticket price", text));
			}
			AddIfKnown(list2, "Lifetime earned", park.TotalEarned);
			AddIfKnown(list2, "Lifetime spent", park.TotalSpent);
			if (park.StaffSalary > 0.0)
			{
				AddIfKnown(list2, "Staff salaries per day", park.StaffSalary);
			}
			if (park.StaffTax > 0.0)
			{
				AddIfKnown(list2, "Staff tax", park.StaffTax);
			}
			if (park.Loans.Count > 0)
			{
				list2.Add(Row.Of(RowKind.Header, "Loans"));
				foreach (LoanLine loan in park.Loans)
				{
					list2.Add(Row.Of(RowKind.Normal, loan.Label, Format.Money(loan.Remaining)));
				}
			}
			return list2;
		}

		public static IReadOnlyList<Row> Rides(ParkSnapshot park)
		{
			List<Row> list = new List<Row>();
			if (park.Rides.Count == 0)
			{
				list.Add(Row.Of(RowKind.Muted, "No attractions built yet"));
			}
			else
			{
				list.Add(Row.Of(RowKind.Header, "Attraction", "State", "Uses", "Price", "Clean", "Durab.", "Wait"));
				foreach (List<RideRow> item in (from r in park.Rides
					group r by r.Name into g
					select g.ToList() into g
					orderby g.Sum((RideRow r) => r.UsesToday) descending
					select g).ThenBy<List<RideRow>, string>((List<RideRow> g) => g[0].Name, StringComparer.Ordinal))
				{
					list.Add(RideLine(item));
				}
				List<RideRow> list2 = park.Rides.Where((RideRow r) => r.MaintenancePerDay.HasValue).ToList();
				if (list2.Count > 0)
				{
					list.Add(Row.Of(RowKind.Normal, "Maintenance per day", Format.Money(list2.Sum((RideRow r) => r.MaintenancePerDay.Value))));
				}
			}
			if (park.Capacity.Count > 0)
			{
				list.Add(Row.Of(RowKind.Header, "Capacity in use"));
				foreach (CapacityLine item2 in park.Capacity)
				{
					list.Add(Row.Of(RowKind.Normal, item2.Name, Format.Ratio(item2.Current, item2.Max)));
				}
			}
			return list;
		}

		public static IReadOnlyList<Row> Build(ParkSnapshot park)
		{
			List<Row> list = new List<Row>();
			if (park.Rides.Any((RideRow r) => r.Raises.Count > 0))
			{
				list.Add(Row.Of(RowKind.Header, "Demand now", "In use", "Waiting", "Verdict"));
				foreach (NeedDemand item in Demand.ByNeed(park))
				{
					if (item.Verdict == DemandVerdict.NoneBuilt)
					{
						list.Add(Row.Of(RowKind.Muted, item.Need, "-", "-", Demand.Describe(item.Verdict)));
						continue;
					}
					DemandVerdict verdict = item.Verdict;
					bool flag = (uint)(verdict - 3) <= 1u;
					RowKind kind = ((!flag) ? RowKind.Normal : RowKind.Bad);
					list.Add(Row.Of(kind, item.Need, $"{item.UsersNow}/{item.Capacity}", Format.Count(item.Waiting), Demand.Describe(item.Verdict)));
				}
			}
			IReadOnlyList<KindEconomics> readOnlyList = AttractionEconomics.For(park);
			if (readOnlyList.Count > 0)
			{
				string text = (readOnlyList.Any((KindEconomics k) => k.FullDay) ? "yesterday" : "today so far");
				list.Add(Row.Of(RowKind.Header, "Each one, " + text, "Earned", "Upkeep", "Net", "Busy"));
				foreach (KindEconomics item2 in readOnlyList.Take(12))
				{
					RowKind kind2 = ((item2.NetEach < 0.0) ? RowKind.Bad : ((!item2.Busy || !(item2.NetEach > 0.0)) ? RowKind.Normal : RowKind.Good));
					list.Add(Row.Of(kind2, KindLabel(item2.Name, item2.Count), Format.Money(item2.EarnedEach), Format.Money(item2.UpkeepEach), (!item2.NetEach.HasValue) ? "-" : Format.Signed(item2.NetEach), BusyCell(item2)));
				}
			}
			IOrderedEnumerable<string> orderedEnumerable = (from c in park.BuildOptions.Select((BuildOption o) => o.Category).OfType<string>()
				where c != "Food and drink"
				select c).Distinct().OrderBy<string, string>((string c) => c, StringComparer.Ordinal);
			List<Row> list2 = new List<Row>();
			foreach (string category in orderedEnumerable)
			{
				BuildOption buildOption = Demand.BestUnlocked(park.BuildOptions, (BuildOption o) => o.Category == category);
				if ((object)buildOption != null)
				{
					bool flag2 = park.Rides.Any((RideRow r) => r.Category == category);
					list2.Add(Row.Of(RowKind.Normal, category + ": " + buildOption.Name + (flag2 ? "" : " (none built)")));
				}
			}
			if (list2.Count > 0)
			{
				list.Add(Row.Of(RowKind.Header, "Best you can build"));
				list.AddRange(list2);
			}
			List<BuildOption> list3 = (from o in park.BuildOptions
				where o.Category == "Food and drink" && o.LockedBy == null && Demand.NotOwned(park, o)
				where o.Capacity > 0 && o.Raises.Count > 0
				orderby o.Tier descending
				select o).Take(6).ToList();
			if (list3.Count > 0)
			{
				list.Add(Row.Of(RowKind.Header, "Food and drink not built yet"));
				foreach (BuildOption item3 in list3)
				{
					string text2 = ((item3.Raises.Count > 0) ? (", " + string.Join(", ", item3.Raises)) : "");
					list.Add(Row.Of(RowKind.Normal, item3.Name + Demand.Service(item3.Staffed) + text2));
				}
			}
			IReadOnlyList<(string, int, BuildOption)> readOnlyList2 = Demand.Upgrades(park);
			if (readOnlyList2.Count > 0)
			{
				list.Add(Row.Of(RowKind.Header, "Better versions unlocked"));
				foreach (var (text3, num, buildOption2) in readOnlyList2)
				{
					list.Add(Row.Of(RowKind.Normal, ((num > 1) ? $"{text3} x{num}" : text3) + ": " + buildOption2.Name));
				}
			}
			if (park.AttractionCapacity.HasValue || (park.Prestige?.MaxVisitors).HasValue)
			{
				list.Add(Row.Of(RowKind.Header, "Visitor limit"));
				AddIfKnown(list, "Your attractions allow", park.AttractionCapacity);
				PrestigeInfo prestige = park.Prestige;
				if ((object)prestige != null)
				{
					AddIfKnown(list, $"Prestige {prestige.Level} caps it at", prestige.MaxVisitors);
					AddIfKnown(list, $"Prestige {prestige.Level + 1} caps it at", prestige.NextLevelMaxVisitors);
				}
			}
			List<BuildOption> list4 = (from o in park.BuildOptions
				where o.LockedBy != null && o.Capacity > 0
				group o by o.Name into g
				select (from o in g
					orderby o.Tier, o.Price
					select o).First() into o
				orderby o.Tier, o.Price
				select o).Take(6).ToList();
			if (list4.Count > 0)
			{
				list.Add(Row.Of(RowKind.Header, "Locked"));
				foreach (BuildOption item4 in list4)
				{
					list.Add(Row.Of(RowKind.Normal, ShortName(item4.Name), item4.LockedBy));
				}
			}
			if (list.Count == 0)
			{
				list.Add(Row.Of(RowKind.Muted, "No building data available"));
			}
			return list;
		}

		public static IReadOnlyList<Row> Guests(ParkSnapshot park)
		{
			List<Row> list = new List<Row>();
			if (park.Needs.Count > 0)
			{
				list.Add(Row.Of(RowKind.Header, "Need", "Average", "Under 50%"));
				foreach (NeedStat need in park.Needs)
				{
					string text = ((need.GuestsCounted > 0) ? $"{need.GuestsLow}/{need.GuestsCounted}" : "-");
					list.Add(Row.Of(NeedKind(need.Average), need.Name, Format.Percent(need.Average), text));
				}
			}
			List<Row> list2 = new List<Row>();
			if (park.Visitors.HasValue)
			{
				list2.Add(Row.Of(RowKind.Normal, "In park", (!park.MaxVisitors.HasValue) ? Format.Count(park.Visitors) : Format.Ratio(park.Visitors, park.MaxVisitors)));
			}
			if (park.ExpectedVisitors != park.MaxVisitors)
			{
				AddIfKnown(list2, "Expected", park.ExpectedVisitors);
			}
			if (park.AverageGuestCash < 500000.0)
			{
				AddIfKnown(list2, "Average cash", park.AverageGuestCash);
			}
			AddIfKnown(list2, "Refunded", park.RefundedVisitors);
			AddIfKnown(list2, "Injured", park.InjuredVisitors);
			if (list2.Count > 0)
			{
				list.Add(Row.Of(RowKind.Header, "Guests"));
				list.AddRange(list2);
			}
			List<NeedStat> list3 = park.Needs.Where((NeedStat n) => n.Sources.Count > 0).ToList();
			if (list3.Count > 0)
			{
				list.Add(Row.Of(RowKind.Header, "Raised by"));
				foreach (NeedStat item in list3)
				{
					list.Add(Row.Of(RowKind.Normal, item.Name + ": " + string.Join(", ", item.Sources)));
				}
			}
			if (park.VisitorMultiplier.HasValue)
			{
				list.Add(Row.Of(RowKind.Header, "What satisfaction buys"));
				if (park.RecentSatisfaction.HasValue)
				{
					list.Add(Row.Of(RowKind.Normal, "Recent satisfaction", Format.Percent(park.RecentSatisfaction)));
				}
				double? visitorMultiplier = park.VisitorMultiplier;
				if (visitorMultiplier.HasValue)
				{
					double valueOrDefault = visitorMultiplier.GetValueOrDefault();
					string text2 = Format.Multiplier(valueOrDefault);
					visitorMultiplier = park.BestVisitorMultiplier;
					if (visitorMultiplier.HasValue)
					{
						double valueOrDefault2 = visitorMultiplier.GetValueOrDefault();
						if (valueOrDefault2 > valueOrDefault)
						{
							text2 = text2 + " (" + Format.Multiplier(valueOrDefault2) + " at best)";
						}
					}
					list.Add(Row.Of(RowKind.Normal, "Visitor multiplier", text2));
				}
			}
			AddCounts(list, "Top complaints", park.Complaints, 5);
			AddCounts(list, "Leaving because", park.LeavingReasons, int.MaxValue);
			if (list.Count == 0)
			{
				list.Add(Row.Of(RowKind.Muted, "No guest data available"));
			}
			return list;
		}

		public static IReadOnlyList<Row> History(IReadOnlyList<DayRecord> days)
		{
			if (days.Count == 0)
			{
				return new Row[1] { Row.Of(RowKind.Muted, "History starts after the first full day") };
			}
			List<Row> list = new List<Row>();
			list.Add(Row.Of(RowKind.Header, "Day", "Visitors", "Net", "Satisfaction"));
			List<Row> list2 = list;
			foreach (DayRecord item in days.OrderByDescending((DayRecord d) => d.Day))
			{
				double? fraction = ((item.Satisfaction > 0.0) ? item.Satisfaction : ((double?)null));
				list2.Add(Row.Of(SignKind(item.Net), Format.Count(item.Day), Format.Count(item.Visitors), Format.Signed(item.Net), Format.Percent(fraction)));
			}
			return list2;
		}

		public static IReadOnlyList<Row> Advisor(IReadOnlyList<Advice> advice)
		{
			if (advice.Count == 0)
			{
				return new Row[1] { Row.Of(RowKind.Good, "Nothing needs fixing right now") };
			}
			List<Row> list = new List<Row>();
			foreach (Advice item in advice)
			{
				if (list.Count > 0)
				{
					list.Add(Row.Of(RowKind.Normal, ""));
				}
				list.Add(Row.Of(TitleKind(item), item.Title));
				list.Add(Row.Of(RowKind.Normal, item.Detail));
			}
			return list;
		}

		private static Row RideLine(IReadOnlyList<RideRow> rides)
		{
			int count = rides.Count;
			int num = rides.Count((RideRow r) => r.IsBroken);
			int num2 = rides.Count((RideRow r) => r.IsOpen);
			int num3 = rides.Count((RideRow r) => r.HasOpenRequest);
			RowKind kind;
			string text;
			if (num <= 0)
			{
				if (num3 <= 0)
				{
					if (num2 != 0)
					{
						(kind, text) = ((num2 == count) ? (RowKind.Normal, "Open") : (RowKind.Normal, $"{num2}/{count} open"));
					}
					else
					{
						kind = RowKind.Muted;
						text = "Closed";
					}
				}
				else
				{
					string text2 = ((count == 1) ? "Request" : ((num3 == 1) ? "1 request" : $"{num3} requests"));
					text = text2;
					kind = RowKind.Bad;
				}
			}
			else
			{
				string text2 = ((count == 1) ? "Broken" : $"{num} broken");
				text = text2;
				kind = RowKind.Bad;
			}
			string text3 = KindLabel(rides[0].Name, count);
			List<RideRow> list = rides.Where((RideRow r) => r.QueueLength.HasValue).ToList();
			return Row.Of(kind, text3, text, Format.Count(rides.Sum((RideRow r) => r.UsesToday)), PriceCell(rides), Format.Percent(rides.Min((RideRow r) => r.Cleanliness)), Format.Percent(rides.Min((RideRow r) => r.Durability)), (list.Count == 0) ? "-" : Format.Count(list.Sum((RideRow r) => r.QueueLength.Value)));
		}

		private static string BusyCell(KindEconomics kind)
		{
			string text = ((kind.Waiting > 0) ? $"+{kind.Waiting}" : "");
			if (!kind.UsersNow.HasValue || !kind.Capacity.HasValue)
			{
				if (text.Length <= 0)
				{
					return "-";
				}
				return text;
			}
			if (text.Length > 0)
			{
				return $"{kind.UsersNow}/{kind.Capacity} {text}";
			}
			return $"{kind.UsersNow}/{kind.Capacity}";
		}

		private static string KindLabel(string name, int count)
		{
			name = ShortName(name);
			if (count <= 1)
			{
				return name;
			}
			return $"{name} x{count}";
		}

		private static string ShortName(string name)
		{
			if (name.Length <= 20)
			{
				return name;
			}
			return name.Substring(0, 18) + "..";
		}

		private static string PriceCell(IReadOnlyList<RideRow> rides)
		{
			List<RideRow> list = rides.Where((RideRow r) => r.Price.HasValue).ToList();
			if (list.Count == 0)
			{
				return "-";
			}
			double? num = list.Min((RideRow r) => r.Price);
			double? num2 = list.Max((RideRow r) => r.Price);
			if (num != num2)
			{
				return Format.Money(num) + "-" + Format.Money(num2);
			}
			return Format.Money(num);
		}

		private static void AddCounts(List<Row> rows, string header, IEnumerable<CountLine> lines, int limit)
		{
			List<CountLine> list = (from l in lines
				where l.Count > 0
				orderby l.Count descending
				select l).Take(limit).ToList();
			if (list.Count == 0)
			{
				return;
			}
			rows.Add(Row.Of(RowKind.Header, header));
			foreach (CountLine item in list)
			{
				rows.Add(Row.Of(RowKind.Normal, item.Label, Format.Count(item.Count)));
				if (!string.IsNullOrWhiteSpace(item.Note))
				{
					rows.Add(Row.Of(RowKind.Normal, item.Note));
				}
			}
		}

		private static void AddIfKnown(List<Row> rows, string label, double? amount)
		{
			if (amount.HasValue)
			{
				rows.Add(Row.Of(RowKind.Normal, label, Format.Money(amount)));
			}
		}

		private static void AddIfKnown(List<Row> rows, string label, int? count)
		{
			if (count.HasValue)
			{
				rows.Add(Row.Of(RowKind.Normal, label, Format.Count(count)));
			}
		}

		private static RowKind SignKind(double amount)
		{
			if (!(amount > 0.0))
			{
				if (!(amount < 0.0))
				{
					return RowKind.Normal;
				}
				return RowKind.Bad;
			}
			return RowKind.Good;
		}

		private static RowKind NeedKind(double? average)
		{
			if (average.HasValue)
			{
				double valueOrDefault = average.GetValueOrDefault();
				if (!(valueOrDefault < 0.4))
				{
					if (valueOrDefault >= 0.7)
					{
						return RowKind.Good;
					}
					return RowKind.Normal;
				}
				return RowKind.Bad;
			}
			return RowKind.Muted;
		}

		private static RowKind TitleKind(Advice advice)
		{
			if (advice.Severity != Severity.High)
			{
				return RowKind.Header;
			}
			return RowKind.Bad;
		}
	}
	public static class TmpMarkup
	{
		private static readonly Dictionary<int, int[]> Columns = new Dictionary<int, int[]>
		{
			[2] = new int[1] { 62 },
			[3] = new int[2] { 50, 75 },
			[4] = new int[3] { 30, 52, 72 },
			[5] = new int[4] { 40, 55, 69, 83 },
			[7] = new int[6] { 34, 48, 57, 68, 79, 91 }
		};

		private const int WideTable = 7;

		private const string SmallOpen = "<size=80%>";

		private const string SmallClose = "</size>";

		private static readonly Regex Tag = new Regex("<[^<>]*>", RegexOptions.Compiled);

		public static string Render(IReadOnlyList<Row> rows)
		{
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < rows.Count; i++)
			{
				Row row = rows[i];
				if (i > 0)
				{
					stringBuilder.Append('\n');
					Row row2 = rows[i - 1];
					if (row.Kind == RowKind.Header && !IsBlank(row2) && row2.Kind != RowKind.Header)
					{
						stringBuilder.Append('\n');
					}
				}
				(string Open, string Close) tuple = Wrap(row.Kind);
				string item = tuple.Open;
				string item2 = tuple.Close;
				bool flag = row.Cells.Count >= 7;
				if (flag)
				{
					stringBuilder.Append("<size=80%>");
				}
				stringBuilder.Append(item);
				for (int j = 0; j < row.Cells.Count; j++)
				{
					if (j > 0)
					{
						stringBuilder.Append("<pos=").Append(ColumnStart(row.Cells.Count, j)).Append("%>");
					}
					stringBuilder.Append(Plain(row.Cells[j]));
				}
				stringBuilder.Append(item2);
				if (flag)
				{
					stringBuilder.Append("</size>");
				}
			}
			return stringBuilder.ToString();
		}

		private static bool IsBlank(Row row)
		{
			return row.Cells.All(string.IsNullOrEmpty);
		}

		private static int ColumnStart(int cellCount, int cell)
		{
			if (!Columns.TryGetValue(cellCount, out int[] value))
			{
				return cell * 100 / cellCount;
			}
			return value[cell - 1];
		}

		private static (string Open, string Close) Wrap(RowKind kind)
		{
			return kind switch
			{
				RowKind.Header => (Open: "<color=#F2A900><b>", Close: "</b></color>"), 
				RowKind.Good => (Open: "<color=#1FAF5A>", Close: "</color>"), 
				RowKind.Bad => (Open: "<color=#E0433F>", Close: "</color>"), 
				_ => (Open: "", Close: ""), 
			};
		}

		private static string Plain(string cell)
		{
			return Tag.Replace(cell, "").Replace("<", "").Replace(">", "");
		}
	}
}