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.Json;
using System.Text.Json.Serialization;
using System.Text.RegularExpressions;
using AssetBundleLoader;
using BepInEx;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using Bogus;
using HarmonyLib;
using Il2CppInterop.Runtime.Injection;
using Il2CppSystem.Collections.Generic;
using Microsoft.CodeAnalysis;
using SOD.Common;
using SOD.Common.BepInEx;
using SOD.Common.BepInEx.Configuration;
using SOD.Common.Custom;
using SOD.Common.Extensions;
using SOD.Common.Helpers;
using SOD.StockMarket.Implementation;
using SOD.StockMarket.Implementation.Cruncher;
using SOD.StockMarket.Implementation.Cruncher.Content;
using SOD.StockMarket.Implementation.Cruncher.News;
using SOD.StockMarket.Implementation.DataConversion;
using SOD.StockMarket.Implementation.DataConversion.Converters;
using SOD.StockMarket.Implementation.Stocks;
using SOD.StockMarket.Implementation.Trade;
using SOD.StockMarket.Patches;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;
using UniverseLib;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("SOD.StockMarket")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+419fa897ea2962db3054776201f942af074b9596")]
[assembly: AssemblyProduct("SOD.StockMarket")]
[assembly: AssemblyTitle("SOD.StockMarket")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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;
		}
	}
}
namespace SOD.StockMarket
{
	internal class Constants
	{
		internal const bool IsDebugEnabled = false;

		internal const string StockDataSaveFormat = "bin";

		internal const int OpeningHour = 9;

		internal const int ClosingHour = 16;

		internal const string DaysClosed = "Saturday,Sunday";

		internal const double StockTrendChancePercentage = 3.0;

		internal const int MaxTrends = 10;

		internal const int MaxHoursTrendsCanPersist = 12;

		internal const int MinHoursTrendsMustPersist = 1;

		internal const double PriceFluctuationPercentage = 0.35;

		internal const int DaysToKeepStockHistoricalData = 31;

		internal const double PastHistoricalDataVolatility = 15.0;

		internal const bool RunSimulation = false;

		internal const int SimulationDays = 365;

		internal const int MinimumStocksInMarket = 50;
	}
	public interface IPluginBindings : IDebugBindings, IMarketBindings, IEconomyBindings
	{
	}
	public interface IDebugBindings
	{
		[Binding(false, "Enables debug mode which prints several useful information into the console.", "Debugging.EnableDebugMode")]
		bool IsDebugEnabled { get; set; }

		[Binding("bin", "The save format for the stock data. Options: \"csv\", \"bin\")", "Debugging.StockDataSaveFormat")]
		string StockDataSaveFormat { get; set; }

		[Binding(false, "If this option is enabled, it will run a simulation after initial economy load and export it as a csv.", "Debugging.RunSimulation")]
		bool RunSimulation { get; set; }

		[Binding(365, "The total amount of days to simulate for (only if RunSimulation is enabled).", "Debugging.SimulationDays")]
		int SimulationDays { get; set; }
	}
	public interface IMarketBindings
	{
		[Binding(9, "The hour the stock market opens everyday. (24h clock)", "StockMarket.OpeningHour")]
		int OpeningHour { get; set; }

		[Binding(16, "The hour the stock market closes everyday. (24h clock)", "StockMarket.ClosingHour")]
		int ClosingHour { get; set; }

		[Binding("Saturday,Sunday", "The days the stock market is closed.", "StockMarket.DaysClosed")]
		string DaysClosed { get; set; }
	}
	public interface IEconomyBindings
	{
		[Binding(3.0, "The percentage change a stock has to start a trend. (0-100)", "StockMarket.Economy.StockTrendChancePercentage")]
		double StockTrendChancePercentage { get; set; }

		[Binding(10, "The maximum amount of trends that can be ongoing at once. (-1 for unlimited)", "StockMarket.Economy.MaxTrends")]
		int MaxTrends { get; set; }

		[Binding(12, "The maximum amount of hours a trend can persist until its completed. (MIN 1)", "StockMarket.Economy.MaxHoursTrendsCanPersist")]
		int MaxHoursTrendsCanPersist { get; set; }

		[Binding(1, "The minimum amount of hours a trend must persist until its completed. (MIN 1)", "StockMarket.Economy.MinHoursTrendsMustPersist")]
		int MinHoursTrendsMustPersist { get; set; }

		[Binding(0.35, "The base price fluctuation percentage of stocks. (based on stock volatility)", "StockMarket.Economy.PriceFluctuationPercentage")]
		double PriceFluctuationPercentage { get; set; }

		[Binding(31, "The amount of days the historical data should be kept per stock.", "StockMarket.Economy.DaysToKeepStockHistoricalData")]
		int DaysToKeepStockHistoricalData { get; set; }

		[Binding(15.0, "The base percentage of volatility the market has been for the past [DaysToKeepStockHistoricalData] on market initialization. (MIN 1.0)", "Stockmarket.Economy.PastHistoricalDataVolatility")]
		double PastHistoricalDataVolatility { get; set; }

		[Binding(50, "The minimum amount of stocks that should be in the market on generation.", "StockMarket.Economy.MinimumStocksInMarket")]
		int MinimumStocksInMarket { get; set; }
	}
	[BepInPlugin("Venomaus.SOD.StockMarket", "StockMarket", "2.0.6")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : PluginController<Plugin, IPluginBindings>
	{
		public const string PLUGIN_GUID = "Venomaus.SOD.StockMarket";

		public const string PLUGIN_NAME = "StockMarket";

		public const string PLUGIN_VERSION = "2.0.6";

		internal Market Market { get; private set; }

		public override void Load()
		{
			ClassInjector.RegisterTypeInIl2Cpp<StockMarketAppContent>();
			PluginController<Plugin, IPluginBindings>.Log.LogInfo((object)"Plugin registered custom types into IL2CPP domain.");
			Market = new Market();
			PluginController<Plugin, IPluginBindings>.Log.LogInfo((object)"Plugin initialized stock market hooks.");
			base.Harmony.PatchAll(Assembly.GetExecutingAssembly());
			PluginController<Plugin, IPluginBindings>.Log.LogInfo((object)"Plugin is patched.");
		}

		public override void OnConfigureBindings()
		{
			base.OnConfigureBindings();
			ValidateBindingValues();
		}

		private void ValidateBindingValues()
		{
			if (base.Config.MaxHoursTrendsCanPersist < 1)
			{
				base.Config.MaxHoursTrendsCanPersist = 12;
			}
			if (base.Config.MinHoursTrendsMustPersist < 1)
			{
				base.Config.MinHoursTrendsMustPersist = 1;
			}
			double stockTrendChancePercentage = base.Config.StockTrendChancePercentage;
			if (stockTrendChancePercentage < 0.0 || stockTrendChancePercentage > 100.0)
			{
				base.Config.StockTrendChancePercentage = 3.0;
			}
			if (base.Config.MaxTrends < -1)
			{
				base.Config.MaxTrends = 10;
			}
			if (base.Config.PastHistoricalDataVolatility < 1.0)
			{
				base.Config.PastHistoricalDataVolatility = 15.0;
			}
			if (!Enum.TryParse<DataSaveFormat>(base.Config.StockDataSaveFormat.Trim(), ignoreCase: true, out var _))
			{
				base.Config.StockDataSaveFormat = "bin";
			}
		}
	}
}
namespace SOD.StockMarket.Patches
{
	internal class CitizenCreatorPatches
	{
		[HarmonyPatch(typeof(CitizenCreator), "Populate")]
		internal class CitizenCreator_Populate
		{
			internal static bool Init;

			[HarmonyPostfix]
			internal static void Postfix()
			{
				if (!Init)
				{
					Init = true;
					PluginController<Plugin, IPluginBindings>.Instance.Market.PostStocksInitialization(typeof(CitizenCreator));
				}
			}
		}
	}
	internal class CityConstructorPatches
	{
		[HarmonyPatch(typeof(CityConstructor), "Finalized")]
		internal class CityConstructor_Finalized
		{
			internal static bool Init;

			[HarmonyPostfix]
			internal static void Postfix()
			{
				if (!Init)
				{
					Init = true;
					PluginController<Plugin, IPluginBindings>.Instance.Market.PostStocksInitialization(typeof(CityConstructor));
				}
			}
		}
	}
	internal class CompanyPatches
	{
		[HarmonyPatch(typeof(Company), "Setup")]
		internal class Company_Setup
		{
			internal static bool ShownInitializingMessage;

			[HarmonyPostfix]
			internal static void Postfix(Company __instance)
			{
				if (!PluginController<Plugin, IPluginBindings>.Instance.Market.Initialized && (!((SoCustomComparison)(object)__instance.preset != (SoCustomComparison)null) || !__instance.preset.isSelfEmployed) && !__instance.preset.isIllegal && __instance.preset.publicFacing)
				{
					if (!ShownInitializingMessage)
					{
						PluginController<Plugin, IPluginBindings>.Log.LogInfo((object)"Initializing stock market data.");
						ShownInitializingMessage = true;
					}
					PluginController<Plugin, IPluginBindings>.Instance.Market.InitStock(new Stock(__instance));
				}
			}
		}
	}
	internal class InteriorCreatorPatches
	{
		[HarmonyPatch(typeof(InteriorCreator), "GenChunk")]
		internal class InteriorCreator_GenChunk
		{
			internal static bool Init;

			[HarmonyPostfix]
			internal static void Postfix()
			{
				if (!Init)
				{
					Init = true;
					PluginController<Plugin, IPluginBindings>.Instance.Market.PostStocksInitialization(typeof(InteriorCreator));
				}
			}
		}
	}
	internal class MainMenuControllerPatches
	{
		[HarmonyPatch(typeof(MainMenuController), "Start")]
		internal class MainMenuController_Start
		{
			private static bool _init;

			[HarmonyPostfix]
			internal static void Postfix()
			{
				if (!_init)
				{
					_init = true;
					LoadStockMarketBundle();
				}
			}

			private static void LoadStockMarketBundle()
			{
				string path = "stockmarketbundle";
				CruncherAppPreset obj = BundleLoader.LoadBundle(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), path), false, true).LoadAsset<CruncherAppPreset>("StockMarketPreset");
				obj.appContent[0].AddComponent<StockMarketAppContent>();
				InsertAppToCrunchers(obj);
			}

			private static void InsertAppToCrunchers(CruncherAppPreset preset)
			{
				foreach (InteractablePreset item in ((IEnumerable<InteractablePreset>)Resources.FindObjectsOfTypeAll<InteractablePreset>()).Where((InteractablePreset preset) => ((Object)preset).name.Contains("Cruncher")))
				{
					item.additionalApps.Insert(item.additionalApps.Count - 2, preset);
				}
			}
		}
	}
}
namespace SOD.StockMarket.Implementation
{
	internal class Market : IStocksContainer
	{
		private readonly List<Stock> _stocks;

		private bool _interiorCreatorFinished;

		private bool _citizenCreatorFinished;

		private bool _cityConstructorFinalized;

		private readonly bool _simulation;

		internal TimeData? SimulationTime;

		private bool _isLoading;

		private string _afterPreModPath;

		public IReadOnlyList<Stock> Stocks => _stocks;

		internal bool Initialized { get; private set; }

		private static int OpeningHour => ((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.OpeningHour;

		private static int ClosingHour => ((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.ClosingHour;

		internal TradeController TradeController { get; private set; }

		internal event EventHandler<EventArgs> OnCalculate;

		internal event EventHandler<EventArgs> OnInitialized;

		internal Market()
		{
			_stocks = new List<Stock>();
			TradeController = new TradeController(this);
			Lib.SaveGame.OnBeforeNewGame += OnBeforeNewGame;
			Lib.SaveGame.OnBeforeLoad += OnFileLoad;
			Lib.SaveGame.OnBeforeSave += OnFileSave;
			Lib.SaveGame.OnBeforeDelete += OnFileDelete;
			Lib.Time.OnTimeInitialized += InitDdsRecords;
			Lib.Time.OnMinuteChanged += OnMinuteChanged;
			Lib.Time.OnHourChanged += OnHourChanged;
			if (!((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.RunSimulation)
			{
				return;
			}
			OnInitialized += delegate
			{
				if (!Lib.Time.IsInitialized)
				{
					Lib.Time.OnTimeInitialized += OnTimeInit;
				}
				else
				{
					Simulate(((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.SimulationDays);
				}
			};
		}

		private void InitDdsRecords(object sender, TimeChangedArgs e)
		{
			Lib.DdsStrings["computer", "stockmarketpreset"] = "Stock Market";
			Lib.Time.OnTimeInitialized -= InitDdsRecords;
		}

		private void OnTimeInit(object sender, TimeChangedArgs args)
		{
			if (((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.RunSimulation)
			{
				Simulate(((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.SimulationDays);
			}
			Lib.Time.OnTimeInitialized -= OnTimeInit;
		}

		private Market(Market market)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			_stocks = new List<Stock>();
			foreach (Stock stock in market.Stocks)
			{
				_stocks.Add(new Stock(stock));
			}
			TradeController = new TradeController(this);
			_simulation = true;
			SimulationTime = new TimeData(1979, 1, 1, ((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.OpeningHour, 0);
			Initialized = true;
		}

		internal void Simulate(int days)
		{
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			Market market = new Market(this);
			TradeController tradeController = market.TradeController;
			int num = ((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.ClosingHour - ((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.OpeningHour;
			int openingHour = ((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.OpeningHour;
			for (int i = 0; i < days; i++)
			{
				TimeData value;
				for (int j = 0; j < num; j++)
				{
					for (int k = 0; k < 59; k++)
					{
						value = market.SimulationTime.Value;
						int year = ((TimeData)(ref value)).Year;
						value = market.SimulationTime.Value;
						int month = ((TimeData)(ref value)).Month;
						value = market.SimulationTime.Value;
						int day = ((TimeData)(ref value)).Day;
						value = market.SimulationTime.Value;
						market.SimulationTime = new TimeData(year, month, day, ((TimeData)(ref value)).Hour, k);
						market.OnMinuteChanged(this, null);
					}
					value = market.SimulationTime.Value;
					int year2 = ((TimeData)(ref value)).Year;
					value = market.SimulationTime.Value;
					int month2 = ((TimeData)(ref value)).Month;
					value = market.SimulationTime.Value;
					int day2 = ((TimeData)(ref value)).Day;
					value = market.SimulationTime.Value;
					market.SimulationTime = new TimeData(year2, month2, day2, ((TimeData)(ref value)).Hour + 1, 0);
					market.OnHourChanged(this, null);
				}
				value = market.SimulationTime.Value;
				int year3 = ((TimeData)(ref value)).Year;
				value = market.SimulationTime.Value;
				int month3 = ((TimeData)(ref value)).Month;
				value = market.SimulationTime.Value;
				market.SimulationTime = new TimeData(year3, month3, ((TimeData)(ref value)).Day, openingHour, 0);
				value = market.SimulationTime.Value;
				market.SimulationTime = ((TimeData)(ref value)).AddDays(1);
			}
			StockDataIO.Export(market, tradeController, Lib.SaveGame.GetSavestoreDirectoryPath(Assembly.GetExecutingAssembly(), "Simulation.csv"), this);
		}

		private void OnBeforeNewGame(object sender, EventArgs e)
		{
			_stocks.Clear();
			TradeController.Reset();
			NewsGenerator.Clear();
			CitizenCreatorPatches.CitizenCreator_Populate.Init = false;
			CityConstructorPatches.CityConstructor_Finalized.Init = false;
			CompanyPatches.Company_Setup.ShownInitializingMessage = false;
			InteriorCreatorPatches.InteriorCreator_GenChunk.Init = false;
			_interiorCreatorFinished = false;
			_cityConstructorFinalized = false;
			_citizenCreatorFinished = false;
			Initialized = false;
			Lib.Time.OnTimeInitialized -= InitializeMarket;
			Lib.Time.OnTimeInitialized += InitializeMarket;
		}

		internal void PostStocksInitialization(Type type)
		{
			if (type == typeof(CitizenCreator))
			{
				_citizenCreatorFinished = true;
			}
			else if (type == typeof(InteriorCreator))
			{
				_interiorCreatorFinished = true;
			}
			else if (type == typeof(CityConstructor))
			{
				_cityConstructorFinalized = true;
			}
			else if (type == typeof(StockDataIO))
			{
				_citizenCreatorFinished = true;
				_interiorCreatorFinished = true;
				_cityConstructorFinalized = true;
				Initialized = true;
				_isLoading = false;
				this.OnInitialized?.Invoke(this, EventArgs.Empty);
				return;
			}
			if (_isLoading || Initialized || !_citizenCreatorFinished || !_interiorCreatorFinished || !_cityConstructorFinalized)
			{
				return;
			}
			MathHelper.Init(TypeExtensions.GetFnvHashCode(CityData.Instance.seed));
			(CompanyStockData, decimal?)[] stocks = CustomStocks.Stocks;
			for (int i = 0; i < stocks.Length; i++)
			{
				var (companyData, basePrice) = stocks[i];
				InitStock(new Stock(companyData, basePrice));
			}
			if (_stocks.Count < ((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.MinimumStocksInMarket)
			{
				int num = ((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.MinimumStocksInMarket - _stocks.Count;
				for (int j = 0; j < num; j++)
				{
					Stock stock = new Stock(new CompanyStockData(StockNameGenerator.GenerateStockName(), Math.Round(MathHelper.Random.NextDouble(0.15, 0.85), 2)));
					InitStock(stock);
				}
			}
			foreach (Stock stock2 in _stocks)
			{
				stock2.Initialize();
			}
			StockSymbolGenerator.Clear();
			if (((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.IsDebugEnabled)
			{
				PluginController<Plugin, IPluginBindings>.Log.LogInfo((object)("Stocks created: " + _stocks.Count));
			}
			PluginController<Plugin, IPluginBindings>.Log.LogInfo((object)"Stock market initialized.");
			Initialized = true;
		}

		internal void InitStock(Stock stock)
		{
			if (!Initialized)
			{
				_stocks.Add(stock);
			}
		}

		private void InitializeMarket(object sender, TimeChangedArgs e)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c1: Expected O, but got Unknown
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Expected O, but got Unknown
			Lib.Time.OnTimeInitialized -= InitializeMarket;
			if (!_simulation)
			{
				TradeController.CreatePortfolioHistoricalDataEntry();
			}
			int num = 0;
			TimeData currentDate = Lib.Time.CurrentDate;
			int daysToKeepStockHistoricalData = ((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.DaysToKeepStockHistoricalData;
			float num2 = (float)((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.PastHistoricalDataVolatility;
			bool flag = default(bool);
			foreach (Stock stock in _stocks)
			{
				StockData stockData = null;
				for (int num3 = daysToKeepStockHistoricalData + 1; num3 > 0; num3--)
				{
					TimeData date = ((TimeData)(ref currentDate)).AddDays(-num3);
					StockData stockData2 = new StockData
					{
						Date = date,
						Open = (stockData?.Close ?? stock.Price)
					};
					float num4 = (0f - num2) * (float)stock.Volatility;
					float num5 = num2 * (float)stock.Volatility;
					_ = stock.Volatility;
					stockData2.Close = Math.Round(stockData2.Open + stockData2.Open / 100m * (decimal)MathHelper.Random.NextDouble((double)num4, (double)num5), 2);
					decimal? close = stockData2.Close;
					if ((close.GetValueOrDefault() <= default(decimal)) & close.HasValue)
					{
						stockData2.Close = 0.01m;
					}
					stockData2.Low = Math.Round(stockData2.Close.Value + stockData2.Close.Value / 100m * (decimal)MathHelper.Random.NextDouble((double)num4, 0.0), 2);
					if (stockData2.Low <= 0m)
					{
						stockData2.Low = 0.01m;
					}
					stockData2.High = Math.Round(stockData2.Close.Value + stockData2.Close.Value / 100m * (decimal)MathHelper.Random.NextDouble(0.0, (double)num5), 2);
					if (stockData2.High <= 0m)
					{
						stockData2.High = 0.01m;
					}
					stock.CreateHistoricalData(stockData2);
					stockData = stockData2;
					num++;
				}
				if (!((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.IsDebugEnabled)
				{
					continue;
				}
				ManualLogSource log = PluginController<Plugin, IPluginBindings>.Log;
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(65, 7, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Stock(");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(stock.Symbol);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(") ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(stock.Name);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" | ");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Volatility (");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<double>(stock.Volatility);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(") | ");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Close (");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<decimal>(Math.Round(stock.HistoricalData.Average((StockData a) => a.Close.Value), 2));
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(") | ");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Open (");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<decimal>(Math.Round(stock.HistoricalData.Average((StockData a) => a.Open), 2));
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(") | ");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("High (");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<decimal>(Math.Round(stock.HistoricalData.Average((StockData a) => a.High), 2));
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(") | ");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Low (");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<decimal>(Math.Round(stock.HistoricalData.Average((StockData a) => a.Low), 2));
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(").");
				}
				log.LogInfo(val);
			}
			if (((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.IsDebugEnabled)
			{
				ManualLogSource log2 = PluginController<Plugin, IPluginBindings>.Log;
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(37, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Initialized ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(num);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" historical data entries.");
				}
				log2.LogInfo(val);
			}
			GenerateTrends();
			this.OnInitialized?.Invoke(this, EventArgs.Empty);
		}

		private void OnMinuteChanged(object sender, TimeChangedArgs args)
		{
			if (IsOpen())
			{
				NewsGenerator.TickToBeReleased();
				if (args == null || !args.IsHourChanged)
				{
					Calculate();
				}
			}
		}

		private void OnHourChanged(object sender, TimeChangedArgs args)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Expected O, but got Unknown
			TimeData val = (TimeData)(((??)SimulationTime) ?? Lib.Time.CurrentDateTime);
			if (((TimeData)(ref val)).Hour == OpeningHour)
			{
				OnOpen();
			}
			else if (((TimeData)(ref val)).Hour == ClosingHour)
			{
				OnClose();
			}
			if (!IsOpen())
			{
				return;
			}
			Calculate();
			GenerateTrends();
			NewsGenerator.RemoveOutdatedArticles();
			if (!((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.IsDebugEnabled || _simulation)
			{
				return;
			}
			ManualLogSource log = PluginController<Plugin, IPluginBindings>.Log;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(21, 0, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("- New stock updates -");
			}
			log.LogInfo(val2);
			foreach (Stock item in _stocks.OrderBy((Stock a) => a.Id))
			{
				ManualLogSource log2 = PluginController<Plugin, IPluginBindings>.Log;
				val2 = new BepInExInfoLogInterpolatedStringHandler(23, 3, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Stock: \"(");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(item.Symbol);
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(") ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(item.Name);
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("\" | Price: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<decimal>(item.Price);
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(".");
				}
				log2.LogInfo(val2);
			}
			ManualLogSource log3 = PluginController<Plugin, IPluginBindings>.Log;
			val2 = new BepInExInfoLogInterpolatedStringHandler(17, 0, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("- End of Stocks -");
			}
			log3.LogInfo(val2);
		}

		internal bool IsOpen()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			if (!_simulation && !Lib.Time.IsInitialized)
			{
				return false;
			}
			TimeData val = (TimeData)(((??)SimulationTime) ?? Lib.Time.CurrentDateTime);
			int hour = ((TimeData)(ref val)).Hour;
			if (hour < OpeningHour || hour >= ClosingHour)
			{
				return false;
			}
			HashSet<WeekDay> hashSet = (from a in ((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.DaysClosed.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
				select Enum.Parse<WeekDay>(a.ToLower())).ToHashSet();
			ref TimeData? simulationTime = ref SimulationTime;
			WeekDay val2;
			if (!simulationTime.HasValue)
			{
				val2 = Lib.Time.CurrentDayEnum;
			}
			else
			{
				TimeData valueOrDefault = simulationTime.GetValueOrDefault();
				val2 = ((TimeData)(ref valueOrDefault)).DayEnum;
			}
			WeekDay item = val2;
			if (hashSet.Contains(item))
			{
				return false;
			}
			return true;
		}

		private void OnClose()
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			int historicalDataDeleted = 0;
			_stocks.ForEach(delegate(Stock a)
			{
				a.ClosingPrice = a.Price;
				a.CreateHistoricalData(null, SimulationTime);
				historicalDataDeleted += a.CleanUpHistoricalData(SimulationTime);
			});
			if (historicalDataDeleted > 0 && ((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.IsDebugEnabled && !_simulation)
			{
				ManualLogSource log = PluginController<Plugin, IPluginBindings>.Log;
				bool flag = default(bool);
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(29, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Deleted ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(historicalDataDeleted);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" old historical data.");
				}
				log.LogInfo(val);
			}
			if (((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.IsDebugEnabled && !_simulation)
			{
				PluginController<Plugin, IPluginBindings>.Log.LogInfo((object)"Stock market is closing.");
			}
		}

		private void OnOpen()
		{
			_stocks.ForEach(delegate(Stock a)
			{
				a.OpeningPrice = a.ClosingPrice.Value;
				a.ClosingPrice = null;
			});
			if (!_simulation)
			{
				TradeController.CreatePortfolioHistoricalDataEntry();
			}
			if (((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.IsDebugEnabled && !_simulation)
			{
				PluginController<Plugin, IPluginBindings>.Log.LogInfo((object)"Stock market is opening.");
			}
		}

		private void Calculate()
		{
			foreach (Stock stock in _stocks)
			{
				stock.DeterminePrice();
			}
			this.OnCalculate?.Invoke(this, EventArgs.Empty);
		}

		private void GenerateTrends()
		{
			//IL_038c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0393: Expected O, but got Unknown
			//IL_03aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Expected O, but got Unknown
			int num = 0;
			int maxHoursTrendsCanPersist = ((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.MaxHoursTrendsCanPersist;
			int minHoursTrendsMustPersist = ((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.MinHoursTrendsMustPersist;
			double stockTrendChancePercentage = ((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.StockTrendChancePercentage;
			int maxTrends = ((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.MaxTrends;
			bool isDebugEnabled = ((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.IsDebugEnabled;
			if (maxTrends > -1 && Stocks.Count((Stock a) => a.Trend.HasValue) >= maxTrends)
			{
				return;
			}
			List<double> list = new List<double>();
			bool flag = default(bool);
			foreach (Stock item2 in Stocks.Where((Stock a) => !a.Trend.HasValue))
			{
				if (!(MathHelper.Random.NextDouble() * 100.0 < stockTrendChancePercentage))
				{
					continue;
				}
				double mean;
				double stdDev;
				if (item2.HistoricalData.Count >= 2)
				{
					for (int i = 1; i < item2.HistoricalData.Count; i++)
					{
						decimal value = item2.HistoricalData[i - 1].Close.Value;
						double item = (double)((item2.HistoricalData[i].Close.Value - value) / value * 100m);
						list.Add(item);
					}
					mean = list.Average();
					stdDev = MathHelper.CalculateStandardDeviation(list);
					list.Clear();
				}
				else
				{
					mean = 0.0;
					stdDev = 0.3;
				}
				double num2 = Math.Round(MathHelper.NextGaussian(mean, stdDev));
				int num3 = (int)num2;
				if (num3 == 0)
				{
					continue;
				}
				if (Math.Abs(num3) < 2)
				{
					num2 = ((num2 < 0.0) ? (num2 - 3.0) : (num2 + 3.0));
				}
				if (MathHelper.Random.NextDouble() * 100.0 < 7.0)
				{
					num2 *= (double)MathHelper.Random.Next(2, 5);
				}
				int steps = MathHelper.Random.Next(60 * minHoursTrendsMustPersist, 60 * maxHoursTrendsCanPersist);
				StockTrend stockTrend = new StockTrend(num2, item2.Price, steps);
				item2.SetTrend(stockTrend);
				num++;
				if (!_simulation)
				{
					NewsGenerator.GenerateArticle(item2, stockTrend);
				}
				if (isDebugEnabled && !_simulation)
				{
					ManualLogSource log = PluginController<Plugin, IPluginBindings>.Log;
					BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(69, 6, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[NEW TREND]: \"(");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(item2.Symbol);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(") ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(item2.Name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\" | Price: ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<decimal>(stockTrend.StartPrice);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" | Target ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<decimal>(stockTrend.EndPrice);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" | Percentage: ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<double>(Math.Round(stockTrend.Percentage, 2));
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" | MinutesLeft: ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(stockTrend.Steps);
					}
					log.LogInfo(val);
				}
			}
			if (num > 0 && isDebugEnabled && !_simulation && Lib.Time.IsInitialized)
			{
				ManualLogSource log2 = PluginController<Plugin, IPluginBindings>.Log;
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(33, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[GameTime(");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<TimeData>(Lib.Time.CurrentDateTime);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(")] Created ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(num);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" new trends.");
				}
				log2.LogInfo(val);
			}
		}

		private void OnFileSave(object sender, SaveGameArgs e)
		{
			string saveFilePath = GetSaveFilePath(e.FilePath);
			StockDataIO.Export(this, TradeController, saveFilePath);
		}

		private void OnFileLoad(object sender, SaveGameArgs e)
		{
			string saveFilePath = GetSaveFilePath(e.FilePath);
			if (!File.Exists(saveFilePath))
			{
				PluginController<Plugin, IPluginBindings>.Log.LogInfo((object)"Attempting to load a premod install savegame, a new market economy will be generated for this savegame.");
				InitPreModInstallEconomyExistingSavegame(saveFilePath, saveImmediately: true);
			}
			else if (!_isLoading)
			{
				_isLoading = true;
				_stocks.Clear();
				TradeController.Reset();
				NewsGenerator.Clear();
				_interiorCreatorFinished = true;
				_cityConstructorFinalized = true;
				_citizenCreatorFinished = true;
				Initialized = false;
				if (!StockDataIO.Import(this, TradeController, saveFilePath))
				{
					_isLoading = false;
					InitPreModInstallEconomyExistingSavegame(saveFilePath, saveImmediately: false);
				}
			}
		}

		private void OnFileDelete(object sender, SaveGameArgs e)
		{
			string saveFilePath = GetSaveFilePath(e.FilePath);
			if (File.Exists(saveFilePath))
			{
				File.Delete(saveFilePath);
			}
		}

		private void InitPreModInstallEconomyExistingSavegame(string filePath, bool saveImmediately)
		{
			_stocks.Clear();
			TradeController.Reset();
			NewsGenerator.Clear();
			CitizenCreatorPatches.CitizenCreator_Populate.Init = false;
			CityConstructorPatches.CityConstructor_Finalized.Init = false;
			CompanyPatches.Company_Setup.ShownInitializingMessage = false;
			InteriorCreatorPatches.InteriorCreator_GenChunk.Init = false;
			_interiorCreatorFinished = false;
			_cityConstructorFinalized = false;
			_citizenCreatorFinished = false;
			Initialized = false;
			PostStocksInitialization(typeof(CitizenCreator));
			PostStocksInitialization(typeof(InteriorCreator));
			PostStocksInitialization(typeof(CityConstructor));
			_afterPreModPath = filePath;
			if (!Lib.Time.IsInitialized)
			{
				Lib.Time.OnTimeInitialized += InitializeMarket;
				if (saveImmediately)
				{
					Lib.Time.OnTimeInitialized += AfterPreModInit;
				}
				else
				{
					_afterPreModPath = null;
				}
			}
			else
			{
				InitializeMarket(this, null);
				if (saveImmediately)
				{
					AfterPreModInit(this, null);
				}
				else
				{
					_afterPreModPath = null;
				}
			}
		}

		private void AfterPreModInit(object sender, TimeChangedArgs e)
		{
			Lib.Time.OnTimeInitialized -= AfterPreModInit;
			StockDataIO.Export(this, TradeController, _afterPreModPath);
			_afterPreModPath = null;
		}

		private static string GetSaveFilePath(string filePath)
		{
			string uniqueString = Lib.SaveGame.GetUniqueString(filePath);
			if (!Enum.TryParse<DataSaveFormat>(((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.StockDataSaveFormat.Trim(), ignoreCase: true, out var result))
			{
				throw new Exception("Invalid save format \"" + ((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.StockDataSaveFormat + "\".");
			}
			string text = "." + result.ToString().ToLower();
			string text2 = "stocks_" + uniqueString + text;
			return Lib.SaveGame.GetSavestoreDirectoryPath(Assembly.GetExecutingAssembly(), text2);
		}
	}
	internal interface IStocksContainer
	{
		IReadOnlyList<Stock> Stocks { get; }
	}
	internal static class MathHelper
	{
		internal static MersenneTwister Random { get; private set; }

		internal static void Init(int seed)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			Random = new MersenneTwister(seed);
		}

		internal static void Init(MersenneTwister random)
		{
			Random = random;
		}

		private static double NextGaussian()
		{
			double num;
			double num3;
			do
			{
				num = 2.0 * Random.NextDouble() - 1.0;
				double num2 = 2.0 * Random.NextDouble() - 1.0;
				num3 = num * num + num2 * num2;
			}
			while (num3 >= 1.0 || num3 == 0.0);
			num3 = Math.Sqrt(-2.0 * Math.Log(num3) / num3);
			return num * num3;
		}

		public static double NextGaussian(double mean, double stdDev)
		{
			return mean + stdDev * NextGaussian();
		}

		public static double CalculateStandardDeviation(List<double> values)
		{
			double mean = values.Average();
			return Math.Sqrt(values.Sum((double value) => Math.Pow(value - mean, 2.0)) / (double)values.Count);
		}
	}
}
namespace SOD.StockMarket.Implementation.Trade
{
	internal static class Extensions
	{
		internal static string ToLimitedString(this decimal value, int max, CultureInfo culture = null)
		{
			return value.ToString(culture ?? CultureInfo.InvariantCulture).Substring(0, Math.Min(max, value.ToString(culture ?? CultureInfo.InvariantCulture).Length));
		}
	}
	internal class HistoricalPortfolio
	{
		[JsonIgnore]
		private TimeData? _timeData;

		[JsonIgnore]
		internal TimeData Date
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				TimeData valueOrDefault = _timeData.GetValueOrDefault();
				if (!_timeData.HasValue)
				{
					((TimeData)(ref valueOrDefault))..ctor(Year, Month, Day, 0, 0);
					_timeData = valueOrDefault;
					return valueOrDefault;
				}
				return valueOrDefault;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				_timeData = value;
			}
		}

		public decimal Worth { get; set; }

		public int Year { get; set; }

		public int Month { get; set; }

		public int Day { get; set; }

		public HistoricalPortfolio()
		{
		}

		internal HistoricalPortfolio(TimeData date, decimal worth)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			Date = date;
			Worth = worth;
			Year = ((TimeData)(ref date)).Year;
			Month = ((TimeData)(ref date)).Month;
			Day = ((TimeData)(ref date)).Day;
		}
	}
	internal class TradeController : IStocksContainer
	{
		internal readonly Market Market;

		private Dictionary<int, decimal> _playerStocks;

		private List<TradeOrder> _playerTradeOrders;

		private List<HistoricalPortfolio> _historicalPortfolio;

		private List<TradeHistory> _tradeHistory;

		internal bool NotificationsEnabled { get; set; } = true;


		internal decimal AvailableFunds { get; private set; }

		internal static int Money
		{
			get
			{
				return GameplayController.Instance.money;
			}
			set
			{
				GameplayController.Instance.money = value;
				FirstPersonItemController.Instance.PlayerMoneyCheck();
				if ((Object)(object)InterfaceControls.Instance.cashText != (Object)null)
				{
					((TMP_Text)InterfaceControls.Instance.cashText).text = CityControls.Instance.cityCurrency + Money;
					if ((Object)(object)BioScreenController.Instance.cashText != (Object)null)
					{
						((TMP_Text)BioScreenController.Instance.cashText).text = ((TMP_Text)InterfaceControls.Instance.cashText).text;
					}
				}
			}
		}

		public IReadOnlyList<Stock> Stocks => (from playerStock in _playerStocks
			join marketStock in Market.Stocks on playerStock.Key equals marketStock.Id
			select marketStock).ToList();

		public IReadOnlyList<TradeOrder> TradeOrders => _playerTradeOrders;

		public IReadOnlyList<HistoricalPortfolio> HistoricalPortfolioData => _historicalPortfolio;

		public IReadOnlyList<TradeHistory> TradeHistory => _tradeHistory;

		internal decimal TotalInvestedInStocks
		{
			get
			{
				decimal d = default(decimal);
				foreach (Stock stock in Stocks)
				{
					decimal num = _playerStocks[stock.Id];
					d += num * stock.Price;
				}
				Dictionary<int, Stock> stocks = Market.Stocks.ToDictionary((Stock a) => a.Id, (Stock a) => a);
				d += (from a in TradeOrders
					where a.OrderType == OrderType.Sell
					select stocks[a.StockId].Price * a.Amount).Sum();
				return Math.Round(d, 2);
			}
		}

		internal decimal PortfolioWorth
		{
			get
			{
				decimal num = (from a in TradeOrders
					where a.OrderType == OrderType.Buy
					select a.Price * a.Amount).Sum();
				return Math.Round(TotalInvestedInStocks + AvailableFunds + num, 2);
			}
		}

		internal decimal GetInvestedVolume(Stock stock)
		{
			if (!_playerStocks.TryGetValue(stock.Id, out var value))
			{
				return 0m;
			}
			return value;
		}

		internal TradeController(Market market)
		{
			Market = market;
			Market.OnCalculate += Market_OnCalculate;
			Import(null);
		}

		internal void CreatePortfolioHistoricalDataEntry()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			TimeData currentDate = Lib.Time.CurrentDate;
			if (!_historicalPortfolio.Any((HistoricalPortfolio a) => a.Date == currentDate))
			{
				_historicalPortfolio.Add(new HistoricalPortfolio(currentDate, PortfolioWorth));
			}
		}

		internal decimal? GetPortfolioPercentageChange(int days)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			TimeData currentDate = Lib.Time.CurrentDate;
			decimal? num = HistoricalPortfolioData.OrderByDescending((HistoricalPortfolio a) => a.Date).ToArray().FirstOrDefault((HistoricalPortfolio a) => (currentDate - a.Date).TotalDays >= (double)days)?.Worth;
			if (num.HasValue)
			{
				decimal? num2 = num;
				if (!((num2.GetValueOrDefault() == default(decimal)) & num2.HasValue))
				{
					decimal portfolioWorth = PortfolioWorth;
					decimal? num3 = num;
					return ((decimal?)portfolioWorth - num3) / num * (decimal?)100;
				}
			}
			return null;
		}

		internal void Reset()
		{
			_playerStocks.Clear();
			_playerTradeOrders.Clear();
			_historicalPortfolio.Clear();
			_tradeHistory.Clear();
			AvailableFunds = 0m;
		}

		internal void DepositFunds(int money)
		{
			if (money > 0 && Money >= money)
			{
				AvailableFunds += (decimal)money;
				Money -= money;
			}
		}

		internal void WithdrawFunds(int money)
		{
			if (money > 0 && AvailableFunds >= (decimal)money)
			{
				AvailableFunds -= (decimal)money;
				Money += money;
			}
		}

		internal void Import(TradeSaveData saveData)
		{
			_playerStocks = saveData?.PlayerStocks ?? new Dictionary<int, decimal>();
			_playerTradeOrders = saveData?.PlayerTradeOrders ?? new List<TradeOrder>();
			_historicalPortfolio = saveData?.HistoricalPortfolio ?? new List<HistoricalPortfolio>();
			_tradeHistory = saveData?.TradeHistory ?? new List<TradeHistory>();
			AvailableFunds = saveData?.AvailableFunds ?? 0m;
		}

		internal TradeSaveData Export()
		{
			return new TradeSaveData
			{
				PlayerStocks = _playerStocks.ToDictionary((KeyValuePair<int, decimal> a) => a.Key, (KeyValuePair<int, decimal> a) => a.Value),
				PlayerTradeOrders = _playerTradeOrders.ToList(),
				HistoricalPortfolio = _historicalPortfolio.ToList(),
				TradeHistory = _tradeHistory.ToList(),
				AvailableFunds = AvailableFunds
			};
		}

		internal bool InstantBuy(Stock stock, decimal amount, bool deductMoney = true)
		{
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			if (deductMoney && !IsValidOrder(OrderType.Buy, stock, amount))
			{
				return false;
			}
			if (deductMoney)
			{
				decimal num = Math.Round(stock.Price * amount, 2);
				AvailableFunds -= num;
			}
			if (_playerStocks.TryGetValue(stock.Id, out var value))
			{
				_playerStocks[stock.Id] = value + amount;
			}
			else
			{
				_playerStocks[stock.Id] = amount;
			}
			_tradeHistory.Add(new TradeHistory(Lib.Time.CurrentDateTime, stock.Symbol, OrderType.Buy, amount, stock.Price));
			return true;
		}

		internal bool InstantSell(Stock stock, decimal amount, bool removeStock = true)
		{
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			if (removeStock && !IsValidOrder(OrderType.Sell, stock, amount))
			{
				return false;
			}
			if (removeStock)
			{
				_playerStocks[stock.Id] -= amount;
				if (_playerStocks[stock.Id] <= 0m)
				{
					_playerStocks.Remove(stock.Id);
				}
			}
			decimal num = Math.Round(stock.Price * amount, 2);
			AvailableFunds += num;
			_tradeHistory.Add(new TradeHistory(Lib.Time.CurrentDateTime, stock.Symbol, OrderType.Sell, amount, stock.Price));
			return true;
		}

		internal bool BuyLimitOrder(Stock stock, decimal price, decimal amount)
		{
			if (!IsValidOrder(OrderType.Buy, stock, amount))
			{
				return false;
			}
			decimal num = Math.Round(stock.Price * amount, 2);
			AvailableFunds -= num;
			_playerTradeOrders.Add(new TradeOrder(OrderType.Buy, stock.Id, price, amount));
			return true;
		}

		internal bool SellLimitOrder(Stock stock, decimal price, decimal amount)
		{
			if (!IsValidOrder(OrderType.Sell, stock, amount))
			{
				return false;
			}
			_playerTradeOrders.Add(new TradeOrder(OrderType.Sell, stock.Id, price, amount));
			_playerStocks[stock.Id] -= amount;
			if (_playerStocks[stock.Id] <= 0m)
			{
				_playerStocks.Remove(stock.Id);
			}
			return true;
		}

		internal void CancelOrder(TradeOrder order)
		{
			if (order.Completed)
			{
				return;
			}
			if (order.OrderType == OrderType.Buy)
			{
				AvailableFunds += Math.Round(order.Price * order.Amount, 2);
			}
			else if (order.OrderType == OrderType.Sell)
			{
				if (_playerStocks.TryGetValue(order.StockId, out var value))
				{
					_playerStocks[order.StockId] = value + order.Amount;
				}
				else
				{
					_playerStocks[order.StockId] = order.Amount;
				}
			}
			order.Completed = true;
			_playerTradeOrders.Remove(order);
		}

		private void Market_OnCalculate(object sender, EventArgs e)
		{
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Expected O, but got Unknown
			foreach (TradeOrder order in _playerTradeOrders)
			{
				if (order.Completed)
				{
					continue;
				}
				Stock stock = Market.Stocks.FirstOrDefault((Stock a) => a.Id == order.StockId);
				if (stock == null)
				{
					order.Completed = true;
					continue;
				}
				decimal price = stock.Price;
				if ((order.OrderType == OrderType.Buy && price <= order.Price) || (order.OrderType == OrderType.Sell && price >= order.Price))
				{
					bool flag = false;
					flag = order.OrderType switch
					{
						OrderType.Buy => InstantBuy(stock, order.Amount, deductMoney: false), 
						OrderType.Sell => InstantSell(stock, order.Amount, removeStock: false), 
						_ => throw new NotImplementedException($"OrderType \"{order.OrderType}\" doesn't have an implementation."), 
					};
					order.Completed = flag;
					if (order.Completed && NotificationsEnabled)
					{
						Lib.GameMessage.Broadcast($"{order.OrderType} order \"({stock.Symbol}) '{order.Amount}' for target price € {order.Price}\" completed.", (GameMessageType)0, (Icon)17, (Color?)null, 0f);
					}
				}
			}
			_playerTradeOrders.RemoveAll((TradeOrder a) => a.Completed);
			TimeData currentDateTime = Lib.Time.CurrentDateTime;
			int num = 0;
			num += _tradeHistory.RemoveAll((TradeHistory a) => (currentDateTime - a.DateTime).TotalDays >= 7.0);
			num += _historicalPortfolio.RemoveAll((HistoricalPortfolio a) => (currentDateTime - a.Date).TotalDays >= 32.0);
			if (((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.IsDebugEnabled && num > 0)
			{
				ManualLogSource log = PluginController<Plugin, IPluginBindings>.Log;
				bool flag2 = default(bool);
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(31, 1, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Deleted ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(num);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" trade history entries.");
				}
				log.LogInfo(val);
			}
		}

		private bool IsValidOrder(OrderType orderType, Stock stock, decimal amount)
		{
			decimal value;
			return orderType switch
			{
				OrderType.Buy => AvailableFunds >= Math.Round(stock.Price * amount, 2), 
				OrderType.Sell => _playerStocks.TryGetValue(stock.Id, out value) && value >= amount, 
				_ => false, 
			};
		}
	}
	internal class TradeHistory
	{
		[JsonIgnore]
		private TimeData? _dateTime;

		[JsonIgnore]
		public TimeData DateTime
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				TimeData valueOrDefault = _dateTime.GetValueOrDefault();
				if (!_dateTime.HasValue)
				{
					((TimeData)(ref valueOrDefault))..ctor(Year, Month, Day, Hour, Minute);
					_dateTime = valueOrDefault;
					return valueOrDefault;
				}
				return valueOrDefault;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				_dateTime = value;
			}
		}

		public int Year { get; set; }

		public int Month { get; set; }

		public int Day { get; set; }

		public int Hour { get; set; }

		public int Minute { get; set; }

		public string StockSymbol { get; set; }

		public OrderType OrderType { get; set; }

		public decimal Amount { get; set; }

		public decimal Price { get; set; }

		[JsonIgnore]
		public decimal Total => Math.Round(Price * Amount, 2);

		public TradeHistory()
		{
		}

		internal TradeHistory(TimeData dateTime, string symbol, OrderType orderType, decimal amount, decimal price)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			DateTime = dateTime;
			StockSymbol = symbol;
			OrderType = orderType;
			Amount = amount;
			Price = price;
			Year = ((TimeData)(ref dateTime)).Year;
			Month = ((TimeData)(ref dateTime)).Month;
			Day = ((TimeData)(ref dateTime)).Day;
			Hour = ((TimeData)(ref dateTime)).Hour;
			Minute = ((TimeData)(ref dateTime)).Minute;
		}
	}
	internal sealed class TradeHistoryPagination
	{
		private readonly int _maxTradeHistoryPerPage;

		private readonly TradeController _tradeController;

		private Func<TradeHistory, object> _currentSortingProperty;

		private bool _sortAscending = true;

		internal int CurrentPage { get; private set; }

		internal TradeHistory[] Current
		{
			get
			{
				TradeHistory[] array = new TradeHistory[_maxTradeHistoryPerPage];
				SetHistories(array);
				return array;
			}
		}

		internal TradeHistoryPagination(TradeController tradeController, int maxTradeHistoryPerPage)
		{
			_tradeController = tradeController;
			_maxTradeHistoryPerPage = maxTradeHistoryPerPage;
		}

		internal TradeHistory[] Next()
		{
			TradeHistory[] array = new TradeHistory[_maxTradeHistoryPerPage];
			int num = (int)Math.Ceiling((double)_tradeController.TradeHistory.Count / (double)_maxTradeHistoryPerPage);
			if (CurrentPage < num - 1)
			{
				CurrentPage++;
				SetHistories(array);
			}
			else if (CurrentPage == num - 1)
			{
				CurrentPage = 0;
				SetHistories(array);
			}
			return array;
		}

		internal TradeHistory[] Previous()
		{
			TradeHistory[] array = new TradeHistory[_maxTradeHistoryPerPage];
			if (CurrentPage > 0)
			{
				CurrentPage--;
				SetHistories(array);
			}
			else if (CurrentPage == 0)
			{
				int num = (int)Math.Ceiling((double)_tradeController.TradeHistory.Count / (double)_maxTradeHistoryPerPage);
				CurrentPage = Math.Max(0, num - 1);
				SetHistories(array);
			}
			return array;
		}

		internal TradeHistory[] Reset()
		{
			TradeHistory[] array = new TradeHistory[_maxTradeHistoryPerPage];
			CurrentPage = 0;
			SetHistories(array);
			return array;
		}

		internal void SortBy(Func<TradeHistory, object> selector, bool? ascending = null)
		{
			if (_currentSortingProperty == selector)
			{
				_sortAscending = !_sortAscending;
			}
			else
			{
				_sortAscending = true;
			}
			_currentSortingProperty = selector;
			if (ascending.HasValue)
			{
				_sortAscending = ascending.Value;
			}
		}

		private void SetHistories(TradeHistory[] slots)
		{
			if (_tradeController.TradeHistory.Count != 0)
			{
				IReadOnlyList<TradeHistory> readOnlyList = _tradeController.TradeHistory;
				if (_currentSortingProperty != null)
				{
					readOnlyList = (_sortAscending ? readOnlyList.OrderBy(_currentSortingProperty).ToList() : readOnlyList.OrderByDescending(_currentSortingProperty).ToList());
				}
				int num = CurrentPage * _maxTradeHistoryPerPage;
				for (int i = 0; i < _maxTradeHistoryPerPage; i++)
				{
					slots[i] = ((readOnlyList.Count > num + i) ? readOnlyList[num + i] : null);
				}
			}
		}
	}
	internal class TradeOrder
	{
		public int StockId { get; set; }

		public decimal Price { get; set; }

		public decimal Amount { get; set; }

		public OrderType OrderType { get; set; }

		public bool Completed { get; set; }

		public TradeOrder()
		{
		}

		internal TradeOrder(OrderType orderType, int stockId, decimal price, decimal amount)
		{
			StockId = stockId;
			Price = price;
			Amount = amount;
			OrderType = orderType;
			Completed = false;
		}
	}
	internal enum OrderType
	{
		Buy,
		Sell
	}
	internal sealed class TradeOrderPagination
	{
		private readonly int _maxTradeOrdersPerPage;

		private readonly TradeController _tradeController;

		private Stock _forStockOnly;

		internal int CurrentPage { get; private set; }

		internal StockOrder[] Current
		{
			get
			{
				StockOrder[] array = new StockOrder[_maxTradeOrdersPerPage];
				SetStocks(array);
				return array;
			}
		}

		internal TradeOrderPagination(TradeController tradeController, int maxTradeOrdersPerPage)
		{
			_tradeController = tradeController;
			_maxTradeOrdersPerPage = maxTradeOrdersPerPage;
		}

		internal void SetForStockOnly(Stock stock)
		{
			_forStockOnly = stock;
		}

		internal StockOrder[] Next()
		{
			StockOrder[] array = new StockOrder[_maxTradeOrdersPerPage];
			int num = (int)Math.Ceiling((double)_tradeController.TradeOrders.Count / (double)_maxTradeOrdersPerPage);
			if (CurrentPage < num - 1)
			{
				CurrentPage++;
				SetStocks(array);
			}
			else if (CurrentPage == num - 1)
			{
				CurrentPage = 0;
				SetStocks(array);
			}
			return array;
		}

		internal StockOrder[] Previous()
		{
			StockOrder[] array = new StockOrder[_maxTradeOrdersPerPage];
			if (CurrentPage > 0)
			{
				CurrentPage--;
				SetStocks(array);
			}
			else if (CurrentPage == 0)
			{
				int num = (int)Math.Ceiling((double)_tradeController.TradeOrders.Count / (double)_maxTradeOrdersPerPage);
				CurrentPage = num - 1;
				SetStocks(array);
			}
			return array;
		}

		internal StockOrder[] Reset()
		{
			StockOrder[] array = new StockOrder[_maxTradeOrdersPerPage];
			CurrentPage = 0;
			SetStocks(array);
			return array;
		}

		private void SetStocks(StockOrder[] stocks)
		{
			IReadOnlyList<TradeOrder> readOnlyList = _tradeController.TradeOrders;
			if (_forStockOnly != null)
			{
				readOnlyList = readOnlyList.Where((TradeOrder a) => a.StockId == _forStockOnly.Id).ToList();
			}
			if (readOnlyList.Count == 0)
			{
				return;
			}
			int num = CurrentPage * _maxTradeOrdersPerPage;
			for (int i = 0; i < _maxTradeOrdersPerPage; i++)
			{
				TradeOrder order = ((readOnlyList.Count > num + i) ? readOnlyList[num + i] : null);
				if (order == null)
				{
					stocks[i] = null;
					continue;
				}
				Stock stock = _tradeController.Market.Stocks.FirstOrDefault((Stock a) => a.Id == order.StockId);
				if (stock == null)
				{
					stocks[i] = null;
				}
				else
				{
					stocks[i] = new StockOrder(stock, order);
				}
			}
		}
	}
	internal sealed class StockOrder
	{
		internal Stock Stock { get; }

		internal TradeOrder TradeOrder { get; }

		internal StockOrder(Stock stock, TradeOrder tradeOrder)
		{
			Stock = stock;
			TradeOrder = tradeOrder;
		}
	}
	internal sealed class TradeSaveData
	{
		public Dictionary<int, decimal> PlayerStocks { get; set; }

		public List<TradeOrder> PlayerTradeOrders { get; set; }

		public List<HistoricalPortfolio> HistoricalPortfolio { get; set; }

		public List<TradeHistory> TradeHistory { get; set; }

		public decimal AvailableFunds { get; set; }

		internal string ToJson()
		{
			return JsonSerializer.Serialize(this, new JsonSerializerOptions
			{
				WriteIndented = false
			});
		}

		internal static TradeSaveData FromJson(string json)
		{
			return JsonSerializer.Deserialize<TradeSaveData>(json);
		}
	}
}
namespace SOD.StockMarket.Implementation.Stocks
{
	internal class CompanyStockData
	{
		private Company _company;

		private decimal? _averageSales;

		private decimal? _minSalary;

		private decimal? _topSalary;

		internal string Name { get; private set; }

		internal string Symbol { get; private set; }

		internal decimal AverageSales => GetAverageSales();

		internal decimal MinSalary => GetMinSalary();

		internal decimal TopSalary => GetTopSalary();

		internal double Volatility { get; private set; }

		internal CompanyStockData(string name, double volatility, string symbol = null)
		{
			Name = name;
			Symbol = symbol ?? StockSymbolGenerator.Generate(Name);
			Volatility = volatility;
		}

		internal CompanyStockData(Company company)
		{
			_company = company;
		}

		internal void Initialize()
		{
			if (_company != null)
			{
				Name = _company.name;
				Symbol = StockSymbolGenerator.Generate(Name);
				Volatility = Math.Round(MathHelper.Random.NextDouble(0.15, 0.85), 2);
			}
			_company = null;
		}

		private decimal GetAverageSales()
		{
			decimal valueOrDefault = _averageSales.GetValueOrDefault();
			if (!_averageSales.HasValue)
			{
				valueOrDefault = MathHelper.Random.Next(5, 1000);
				_averageSales = valueOrDefault;
				return valueOrDefault;
			}
			return valueOrDefault;
		}

		private decimal GetMinSalary()
		{
			if (_company != null && _company.minimumSalary > 0f)
			{
				return (decimal)_company.minimumSalary;
			}
			decimal valueOrDefault = _minSalary.GetValueOrDefault();
			if (!_minSalary.HasValue)
			{
				valueOrDefault = MathHelper.Random.Next(550, 1350);
				_minSalary = valueOrDefault;
				return valueOrDefault;
			}
			return valueOrDefault;
		}

		private decimal GetTopSalary()
		{
			if (_company != null && _company.topSalary > 0f)
			{
				return (decimal)_company.topSalary;
			}
			decimal valueOrDefault = _topSalary.GetValueOrDefault();
			if (!_topSalary.HasValue)
			{
				valueOrDefault = MathHelper.Random.Next((int)GetMinSalary() + 1, 2250);
				_topSalary = valueOrDefault;
				return valueOrDefault;
			}
			return valueOrDefault;
		}
	}
	internal static class CustomStocks
	{
		internal static readonly (CompanyStockData data, decimal? basePrice)[] Stocks = new(CompanyStockData, decimal?)[3]
		{
			(new CompanyStockData("Starch Kola", 0.5), (decimal)MathHelper.Random.NextDouble(5000.0, 10000.0)),
			(new CompanyStockData("Kaizen-7", 0.4), (decimal)MathHelper.Random.NextDouble(3500.0, 7500.0)),
			(new CompanyStockData("Crow Coin", 0.15), (decimal)MathHelper.Random.NextDouble(0.9750000238418579, 1.024999976158142))
		};
	}
	internal class Stock
	{
		private static int _id;

		private readonly List<StockData> _historicalData;

		private readonly CompanyStockData _companyData;

		private readonly decimal? _basePrice;

		private readonly bool _imported;

		private int _currentStep;

		internal int Id { get; }

		internal string Name => _companyData.Name;

		internal string Symbol => _companyData.Symbol;

		internal double Volatility => _companyData.Volatility;

		internal decimal Price { get; private set; }

		internal decimal OpeningPrice { get; set; }

		internal decimal? ClosingPrice { get; set; }

		internal decimal HighPrice { get; private set; }

		internal decimal LowPrice { get; private set; }

		internal StockTrend? Trend { get; private set; }

		[JsonIgnore]
		internal decimal TodayDiff => Math.Round(Price - OpeningPrice, 2);

		[JsonIgnore]
		internal decimal DailyPercentage => GetPercentage(Price, OpeningPrice);

		[JsonIgnore]
		internal decimal? WeeklyPercentage
		{
			get
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				TimeData currentDate = Lib.Time.CurrentDate;
				StockData stockData = HistoricalData.OrderByDescending((StockData a) => a.Date).FirstOrDefault((StockData a) => (currentDate - a.Date).TotalDays >= 7.0);
				if (stockData == null)
				{
					return null;
				}
				return GetPercentage(Price, stockData.Open);
			}
		}

		[JsonIgnore]
		internal decimal? MonthlyPercentage
		{
			get
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				TimeData currentDate = Lib.Time.CurrentDate;
				StockData stockData = HistoricalData.OrderByDescending((StockData a) => a.Date).FirstOrDefault((StockData a) => (currentDate - a.Date).TotalDays >= 30.0);
				if (stockData == null)
				{
					return null;
				}
				return GetPercentage(Price, stockData.Open);
			}
		}

		internal IReadOnlyList<StockData> HistoricalData => _historicalData;

		internal Stock(Company company)
			: this()
		{
			_companyData = new CompanyStockData(company);
		}

		internal Stock(CompanyStockData companyData, decimal? basePrice = null)
			: this((int?)null, basePrice)
		{
			_companyData = companyData;
		}

		internal Stock(StockDataIO.StockDataDTO dto, IEnumerable<StockData> historicalData)
			: this(dto.Id, dto.Price)
		{
			_companyData = new CompanyStockData(dto.Name, dto.Volatility.Value, dto.Symbol);
			Price = dto.Price.Value;
			OpeningPrice = dto.Open;
			ClosingPrice = dto.Close;
			LowPrice = dto.Low;
			HighPrice = dto.High;
			if (dto.TrendPercentage.HasValue && dto.TrendStartPrice.HasValue && dto.TrendEndPrice.HasValue && dto.TrendSteps.HasValue)
			{
				StockTrend value = new StockTrend
				{
					Percentage = dto.TrendPercentage.Value,
					StartPrice = dto.TrendStartPrice.Value,
					EndPrice = dto.TrendEndPrice.Value,
					Steps = dto.TrendSteps.Value
				};
				Trend = value;
			}
			foreach (StockData item in historicalData.OrderBy((StockData a) => a.Date))
			{
				CreateHistoricalData(item);
			}
			_imported = true;
		}

		internal Stock(Stock stock)
		{
			Id = stock.Id;
			_companyData = stock._companyData;
			Price = stock.Price;
			OpeningPrice = stock.OpeningPrice;
			ClosingPrice = stock.ClosingPrice;
			LowPrice = stock.LowPrice;
			HighPrice = stock.HighPrice;
			Trend = stock.Trend;
			_historicalData = new List<StockData>();
			foreach (StockData historicalDatum in stock._historicalData)
			{
				_historicalData.Add(new StockData(historicalDatum));
			}
			_basePrice = stock._basePrice;
			_imported = stock._imported;
		}

		private Stock(int? id = null, decimal? basePrice = null)
		{
			Id = id ?? _id++;
			_historicalData = new List<StockData>();
			_basePrice = basePrice;
			_imported = false;
		}

		private static decimal GetPercentage(decimal currentPrice, decimal openingPrice)
		{
			double num = ((openingPrice != 0m) ? ((double)((currentPrice - openingPrice) / openingPrice * 100m)) : ((currentPrice > 0m) ? double.PositiveInfinity : ((!(currentPrice < 0m)) ? 0.0 : double.NegativeInfinity)));
			return Math.Round((decimal)num, 2);
		}

		internal void DeterminePrice()
		{
			if ((!Trend.HasValue || _currentStep >= Trend.Value.Steps) && MathHelper.Random.Next(0, 99) < 10)
			{
				if (Trend.HasValue && _currentStep >= Trend.Value.Steps)
				{
					RemoveTrend();
				}
				return;
			}
			decimal? num = null;
			if (Trend.HasValue)
			{
				StockTrend value = Trend.Value;
				if (_currentStep >= value.Steps)
				{
					RemoveTrend();
				}
				else
				{
					decimal num2 = (decimal)_currentStep / (decimal)value.Steps;
					num = value.StartPrice + (value.EndPrice - value.StartPrice) * num2;
					_currentStep++;
					if (_currentStep >= value.Steps)
					{
						RemoveTrend();
					}
				}
			}
			if (!num.HasValue)
			{
				decimal num3 = (decimal)((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.PriceFluctuationPercentage * (decimal)Volatility;
				decimal num4 = Price * (num3 / 100m);
				num = Price + (decimal)(MathHelper.Random.NextDouble() * (double)num4 * 2.0) - num4;
			}
			if (num.HasValue)
			{
				decimal? num5 = num;
				if (!((num5.GetValueOrDefault() <= default(decimal)) & num5.HasValue))
				{
					goto IL_0222;
				}
			}
			num = 0.01m;
			if (Trend.HasValue && Trend.Value.EndPrice <= 0.01m)
			{
				RemoveTrend();
			}
			goto IL_0222;
			IL_0222:
			Price = Math.Round(num.Value, 2);
			UpdateHighestLowestPrices();
		}

		internal void SetTrend(StockTrend stockTrend)
		{
			if (!Trend.HasValue)
			{
				Trend = stockTrend;
			}
		}

		internal void RemoveTrend()
		{
			_currentStep = 0;
			Trend = null;
		}

		internal void CreateHistoricalData(StockData stockData = null, TimeData? date = null)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			if (stockData != null)
			{
				_historicalData.Add(stockData);
				return;
			}
			TimeData date2 = (TimeData)(((??)date) ?? Lib.Time.CurrentDate);
			_historicalData.Add(new StockData
			{
				Date = date2,
				Close = ClosingPrice,
				Open = OpeningPrice,
				Low = LowPrice,
				High = HighPrice,
				Trend = Trend
			});
			LowPrice = ClosingPrice.Value;
			HighPrice = ClosingPrice.Value;
		}

		internal int CleanUpHistoricalData(TimeData? date)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			TimeData currentDate = (TimeData)(((??)date) ?? Lib.Time.CurrentDate);
			int maxDays = ((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.DaysToKeepStockHistoricalData;
			return _historicalData.RemoveAll((StockData stockData) => ((currentDate - stockData.Date).Days > maxDays) ? true : false);
		}

		internal void Initialize()
		{
			if (_imported)
			{
				throw new Exception("An imported stock is already initialized, no need to call Initialize();");
			}
			_companyData.Initialize();
			Price = Math.Round(_basePrice ?? (_companyData.AverageSales / (_companyData.MinSalary + _companyData.TopSalary) * 1000m), 2);
			OpeningPrice = Price;
			LowPrice = Price;
			HighPrice = Price;
		}

		private void UpdateHighestLowestPrices()
		{
			if (LowPrice > Price)
			{
				LowPrice = Price;
			}
			else if (HighPrice < Price)
			{
				HighPrice = Price;
			}
		}
	}
	internal class StockData : IEquatable<StockData>
	{
		public TimeData Date { get; set; }

		public decimal Open { get; set; }

		public decimal? Close { get; set; }

		public decimal High { get; set; }

		public decimal Low { get; set; }

		public StockTrend? Trend { get; set; }

		internal StockData()
		{
		}

		internal StockData(StockData data)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			Date = data.Date;
			Open = data.Open;
			Close = data.Close;
			High = data.High;
			Low = data.Low;
			Trend = data.Trend;
		}

		public bool Equals(StockData other)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (other != null)
			{
				TimeData date = other.Date;
				return ((TimeData)(ref date)).Equals(Date);
			}
			return false;
		}

		public override bool Equals(object obj)
		{
			return Equals(obj as StockData);
		}

		public override int GetHashCode()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			TimeData date = Date;
			return ((object)(TimeData)(ref date)).GetHashCode();
		}
	}
	internal static class StockDataIO
	{
		internal sealed class StockDataDTO
		{
			public int Id { get; set; }

			public string Name { get; set; }

			public string Symbol { get; set; }

			public TimeData? Date { get; set; }

			public decimal Open { get; set; }

			public decimal? Close { get; set; }

			public decimal High { get; set; }

			public decimal Low { get; set; }

			public decimal Average { get; set; }

			public decimal? Price { get; set; }

			public double? Volatility { get; set; }

			public double? TrendPercentage { get; set; }

			public decimal? TrendStartPrice { get; set; }

			public decimal? TrendEndPrice { get; set; }

			public int? TrendSteps { get; set; }

			public TradeSaveData TradeSaveData { get; set; }

			public List<Article> Articles { get; set; }

			public decimal? OriginalPrice { get; set; }

			public decimal SimulationChange => Math.Round(Price.Value - OriginalPrice.Value, 2);
		}

		internal static void Export(Market market, TradeController tradeController, string path, Market simulation = null)
		{
			//IL_0536: Unknown result type (might be due to invalid IL or missing references)
			//IL_053d: Expected O, but got Unknown
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			if (!market.Initialized)
			{
				PluginController<Plugin, IPluginBindings>.Log.LogInfo((object)"Cannot export stock market data, market not yet initialized.");
				return;
			}
			List<StockDataDTO> list = new List<StockDataDTO>
			{
				new StockDataDTO
				{
					TradeSaveData = tradeController.Export()
				},
				new StockDataDTO
				{
					Articles = NewsGenerator.AllArticles.ToList()
				}
			};
			foreach (Stock stock in market.Stocks.OrderBy((Stock a) => a.Id))
			{
				StockDataDTO stockDataDTO = new StockDataDTO
				{
					Id = stock.Id,
					Name = stock.Name,
					Symbol = stock.Symbol,
					Date = null,
					Price = stock.Price,
					Open = stock.OpeningPrice,
					Close = stock.ClosingPrice,
					High = stock.HighPrice,
					Low = stock.LowPrice,
					Volatility = stock.Volatility,
					TrendPercentage = stock.Trend?.Percentage,
					TrendStartPrice = stock.Trend?.StartPrice,
					TrendEndPrice = stock.Trend?.EndPrice,
					TrendSteps = stock.Trend?.Steps,
					Average = Math.Round((stock.HighPrice + stock.LowPrice + stock.Price) / 3m, 2)
				};
				if (simulation != null)
				{
					Stock stock2 = simulation.Stocks.First((Stock a) => a.Id == stock.Id);
					stockDataDTO.OriginalPrice = stock2.Price;
				}
				list.Add(stockDataDTO);
				foreach (StockData item2 in stock.HistoricalData.OrderBy((StockData a) => a.Date))
				{
					StockDataDTO item = new StockDataDTO
					{
						Id = stock.Id,
						Name = stock.Name,
						Symbol = stock.Symbol,
						Date = item2.Date,
						Open = item2.Open,
						Close = item2.Close,
						High = item2.High,
						Low = item2.Low,
						Average = Math.Round((item2.Open + item2.Close.Value + item2.High + item2.Low) / 4m),
						Price = null,
						Volatility = null,
						TrendPercentage = item2.Trend?.Percentage,
						TrendStartPrice = item2.Trend?.StartPrice,
						TrendEndPrice = item2.Trend?.EndPrice,
						TrendSteps = item2.Trend?.Steps,
						OriginalPrice = null
					};
					list.Add(item);
				}
			}
			ConverterFactory.Get(path).Save(list, MathHelper.Random, path, simulation != null);
			ManualLogSource log = PluginController<Plugin, IPluginBindings>.Log;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(33, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Exported ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(list.Count);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" stock market data rows.");
			}
			log.LogInfo(val);
		}

		internal static bool Import(Market market, TradeController tradeController, string path)
		{
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0333: Expected O, but got Unknown
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Expected O, but got Unknown
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Expected O, but got Unknown
			//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Expected O, but got Unknown
			if (market.Initialized)
			{
				PluginController<Plugin, IPluginBindings>.Log.LogInfo((object)"Cannot import stock market data, market is already initialized.");
				return true;
			}
			bool flag = default(bool);
			try
			{
				PluginController<Plugin, IPluginBindings>.Log.LogInfo((object)"Loading stock data..");
				List<StockDataDTO> list = ConverterFactory.Get(path).Load(path);
				Dictionary<int, StockData[]> dictionary = (from a in list
					where a.TradeSaveData == null && a.Articles == null && !a.Price.HasValue
					group a by a.Id).Select(delegate(IGrouping<int, StockDataDTO> a)
				{
					IEnumerable<StockData> source = a.OrderBy((StockDataDTO a) => a.Date).Select(delegate(StockDataDTO a)
					{
						//IL_0033: Unknown result type (might be due to invalid IL or missing references)
						StockData stockData = new StockData
						{
							Close = a.Close,
							High = a.High,
							Low = a.Low,
							Date = a.Date.Value,
							Open = a.Open
						};
						if (a.TrendPercentage.HasValue && a.TrendStartPrice.HasValue && a.TrendEndPrice.HasValue && a.TrendSteps.HasValue)
						{
							StockTrend stockTrend = default(StockTrend);
							stockTrend.Percentage = a.TrendPercentage.Value;
							stockTrend.StartPrice = a.TrendStartPrice.Value;
							stockTrend.EndPrice = a.TrendEndPrice.Value;
							stockTrend.Steps = a.TrendSteps.Value;
							StockTrend value = stockTrend;
							stockData.Trend = value;
						}
						return stockData;
					});
					return new
					{
						Key = a.Key,
						Data = source.ToArray()
					};
				}).ToDictionary(a => a.Key, a => a.Data);
				foreach (StockDataDTO item in from a in list
					where a.TradeSaveData == null && a.Articles == null && a.Price.HasValue
					orderby a.Id
					select a)
				{
					Stock stock = new Stock(item, dictionary[item.Id]);
					market.InitStock(stock);
				}
				TradeSaveData tradeSaveData = list[0].TradeSaveData;
				if (tradeSaveData != null)
				{
					PluginController<Plugin, IPluginBindings>.Log.LogInfo((object)"Loading trade data..");
					tradeController.Import(tradeSaveData);
				}
				PluginController<Plugin, IPluginBindings>.Log.LogInfo((object)"Loading news data..");
				NewsGenerator.Import(list[1].Articles);
				if (((PluginController<Plugin, IPluginBindings>)PluginController<Plugin, IPluginBindings>.Instance).Config.IsDebugEnabled)
				{
					PluginController<Plugin, IPluginBindings>.Log.LogInfo((object)("Stocks data loaded: " + market.Stocks.Count));
					ManualLogSource log = PluginController<Plugin, IPluginBindings>.Log;
					BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(17, 0, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("- Loaded stocks -");
					}
					log.LogInfo(val);
					foreach (Stock item2 in market.Stocks.OrderBy((Stock a) => a.Id))
					{
						ManualLogSource log2 = PluginController<Plugin, IPluginBindings>.Log;
						val = new BepInExInfoLogInterpolatedStringHandler(23, 3, ref flag);
						if (flag)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Stock: \"(");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(item2.Symbol);
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral(") ");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(item2.Name);
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\" | Price: ");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<decimal>(item2.Price);
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral(".");
						}
						log2.LogInfo(val);
					}
					ManualLogSource log3 = PluginController<Plugin, IPluginBindings>.Log;
					val = new BepInExInfoLogInterpolatedStringHandler(17, 0, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("- End of Stocks -");
					}
					log3.LogInfo(val);
				}
				PluginController<Plugin, IPluginBindings>.Log.LogInfo((object)"Stock market loaded.");
			}
			catch (Exception)
			{
				ManualLogSource log4 = PluginController<Plugin, IPluginBindings>.Log;
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(86, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("The savefile is not compatible with \"Stockmarket v");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("2.0.6");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\", skipped loading stockmarket data.");
				}
				log4.LogInfo(val);
				return false;
			}
			market.PostStocksInitialization(typeof(StockDataIO));
			return true;
		}
	}
	internal static class StockNameGenerator
	{
		private static readonly Faker faker = new Faker("en");

		internal static string GenerateStockName()
		{
			return faker.Company.CompanyName((int?)null);
		}
	}
	internal sealed class StockPagination
	{
		private readonly IStocksContainer _stockContainer;

		private readonly Func<int> _maxStocksPerPageFunc;

		private Func<Stock, object> _currentSortingProperty;

		private bool _sortAscending = true;

		internal int CurrentPage { get; private set; }

		internal Stock[] Current
		{
			get
			{
				Stock[] array = new Stock[_maxStocksPerPageFunc()];
				SetStocks(array);
				return array;
			}
		}

		internal StockPagination(IStocksContainer stockContainer, int maxStocksPerPage)
		{
			_stockContainer = stockContainer;
			_maxStocksPerPageFunc = () => maxStocksPerPage;
		}

		internal StockPagination(IStocksContainer stockContainer, Func<int> maxStocksPerPage)
		{
			_stockContainer = stockContainer;
			_maxStocksPerPageFunc = maxStocksPerPage;
		}

		internal Stock[] Next()
		{
			int num = _maxStocksPerPageFunc();
			Stock[] array = new Stock[num];
			int num2 = (int)Math.Ceiling((double)_stockContainer.Stocks.Count / (double)num);
			if (CurrentPage < num2 - 1)
			{
				CurrentPage++;
				SetStocks(array);
			}
			else if (CurrentPage == num2 - 1)
			{
				CurrentPage = 0;
				SetStocks(array);
			}
			return array;
		}

		internal Stock[] Previous()
		{
			int num = _maxStocksPerPageFunc();
			Stock[] array = new Stock[num];
			if (CurrentPage > 0)
			{
				CurrentPage--;
				SetStocks(array);
			}
			else if (CurrentPage == 0)
			{
				int num2 = (int)Math.Ceiling((double)_stockContainer.Stocks.Count / (double)num);
				CurrentPage = num2 - 1;
				SetStocks(array);
			}
			return array;
		}

		internal Stock[] Reset()
		{
			Stock[] array = new Stock[_maxStocksPerPageFunc()];
			CurrentPage = 0;
			SetStocks(array);
			return array;
		}

		internal void SortBy(Func<Stock, object> selector, bool? ascending = null)
		{
			if (_currentSortingProperty == selector)
			{
				_sortAscending = !_sortAscending;
			}
			else
			{
				_sortAscending = true;
			}
			_currentSortingProperty = selector;
			if (ascending.HasValue)
			{
				_sortAscending = ascending.Value;
			}
		}

		private void SetStocks(Stock[] stocks)
		{
			if (_stockContainer.Stocks.Count != 0)
			{
				IReadOnlyList<Stock> readOnlyList = _stockContainer.Stocks;
				if (_currentSortingProperty != null)
				{
					readOnlyList = (_sortAscending ? readOnlyList.OrderBy(_currentSortingProperty).ToList() : readOnlyList.OrderByDescending(_currentSortingProperty).ToList());
				}
				int num = _maxStocksPerPageFunc();
				int num2 = CurrentPage * num;
				for (int i = 0; i < num; i++)
				{
					Stock stock = ((readOnlyList.Count > num2 + i) ? readOnlyList[num2 + i] : null);
					stocks[i] = stock;
				}
			}
		}
	}
	internal static class StockSymbolGenerator
	{
		private static Dictionary<string, int> _companySymbolCount;

		internal static string Generate(string companyName)
		{
			string text = GetSymbol(companyName);
			if (_companySymbolCount == null)
			{
				_companySymbolCount = new Dictionary<string, int>();
			}
			if (_companySymbolCount.TryGetValue(text, out var value))
			{
				value++;
				_companySymbolCount[text] = value;
			}
			else
			{
				_companySymbolCount[text] = 0;
			}
			if (text.Length == 4 && value > 0)
			{
				text = new string(text.Take(3).ToArray());
				if (_companySymbolCount.TryGetValue(text, out value))
				{
					value++;
					_companySymbolCount[text] = value;
				}
				else
				{
					_companySymbolCount[text] = 0;
				}
			}
			string text2 = text + value;
			if (text2.Length == 1)
			{
				text2 = text + value.ToString("D3");
			}
			else if (text2.Length == 2)
			{
				text2 = text + value.ToString("D2");
			}
			text2 = text2.Substring(0, Math.Min(text2.Length, 4));
			return text2.ToUpper();
		}

		internal static void Clear()
		{
			_companySymbolCount = null;
		}

		private static string GetSymbol(string companyName)
		{
			char[] blockedChars = new char[3] { '-', '_', '&' };
			string[] array = (from a in companyName.Split(' ', StringSplitOptions.RemoveEmptyEntries)
				where a.Length > 1
				select a).ToArray();
			if (array.Length == 0)
			{
				throw new Exception("Missing company name.");
			}
			if (array.Length == 1)
			{
				return new string(array[0].Where((char a) => !blockedChars.Contains(a)).Take(4).ToArray());
			}
			return new string(array[0].Where((char a) => !blockedChars.Contains(a)).Take(2).Concat(array[1].Where((char a) => !blockedChars.Contains(a)).Take(2))
				.ToArray());
		}
	}
	internal readonly struct StockTrend
	{
		internal double Percentage { get; init; }

		internal decimal StartPrice { get; init; }

		internal decimal EndPrice { get; init; }

		internal int Steps { get; init; }

		internal StockTrend(double percentage, decimal currentPrice, int steps)
		{
			Percentage = percentage;
			StartPrice = currentPrice;
			Steps = steps;
			EndPrice = Math.Round(StartPrice + StartPrice / 100m * (decimal)Percentage, 2);
		}
	}
}
namespace SOD.StockMarket.Implementation.DataConversion
{
	internal static class ConverterFactory
	{
		private static readonly Dictionary<string, Func<IDataConverter>> _converters = new Dictionary<string, Func<IDataConverter>>(StringComparer.OrdinalIgnoreCase)
		{
			{
				".csv",
				() => CsvConverter.Create()
			},
			{
				".bin",
				() => BinaryConverter.Create()
			}
		};

		public static IDataConverter Get(string filePath)
		{
			string extension = Path.GetExtension(filePath);
			if (_converters.TryGetValue(extension, out var value))
			{
				return value();
			}
			throw new NotSupportedException("Data type \"" + extension + "\" is not supported.");
		}
	}
	public enum DataSaveFormat
	{
		Csv,
		Bin
	}
	internal interface IDataConverter
	{
		void Save(List<StockDataIO.StockDataDTO> data, MersenneTwister random, string path, bool simulation = false);

		List<StockDataIO.StockDataDTO> Load(string path);
	}
}
namespace SOD.StockMarket.Implementation.DataConversion.Converters
{
	internal sealed class BinaryConverter : IDataConverter
	{
		private BinaryConverter()
		{
		}

		internal static BinaryConverter Create()
		{
			return new BinaryConverter();
		}

		public void Save(List<StockDataIO.StockDataDTO> data, MersenneTwister random, string path, bool simulation = false)
		{
			using BinaryWriter binaryWriter = new BinaryWriter(new FileStream(path, FileMode.Create, FileAccess.Write));
			binaryWriter.Write("BinaryStockData");
			var (value, array) = random.SaveState();
			binaryWriter.Write(value);
			uint[] array2 = array;
			foreach (uint value2 in array2)
			{
				binaryWriter.Write(value2);
			}
			string value3 = data[0].TradeSaveData.ToJson();
			binaryWriter.Write(value3);
			string value4 = JsonSerializer.Serialize(data[1].Articles, new JsonSerializerOptions
			{
				WriteIndented = false
			});
			binaryWriter.Write(value4);
			for (int j = 2; j < data.Count; j++)
			{
				StockDataIO.StockDataDTO stockDataDTO = data[j];
				binaryWriter.Write(stockDataDTO.Id);
				binaryWriter.Write(stockDataDTO.Name);
				binaryWriter.Write(stockDataDTO.Symbol);
				WriteNullableTimeData(binaryWriter, stockDataDTO.Date);
				WriteNullableDecimal(binaryWriter, stockDataDTO.Price);
				binaryWriter.Write(stockDataDTO.Open);
				WriteNullableDecimal(binaryWriter, stockDataDTO.Close);
				binaryWriter.Write(stockDataDTO.High);
				binaryWriter.Write(stockDataDTO.Low);
				WriteNullableDouble(binaryWriter, stockDataDTO.Volatility);
				WriteNullableDouble(binaryWriter, stockDataDTO.TrendPercentage);
				WriteNullableDecimal(binaryWriter, stockDataDTO.TrendStartPrice);
				WriteNullableDecimal(binaryWriter, stockDataDTO.TrendEndPrice);
				WriteNullableInt(binaryWriter, stockDataDTO.TrendSteps);
				binaryWriter.Write(stockDataDTO.Average);
			}
		}

		public List<StockDataIO.StockDataDTO> Load(string path)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			List<StockDataIO.StockDataDTO> list = new List<StockDataIO.StockDataDTO>();
			using BinaryReader binaryReader = new BinaryReader(new FileStream(path, FileMode.Open, FileAccess.Read));
			if (binaryReader.ReadString() != "BinaryStockData")
			{
				throw new InvalidDataException("Invalid binary file format.");
			}
			int item = binaryReader.ReadInt32();
			uint[] array = new uint[624];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = binaryReader.ReadUInt32();
			}
			MathHelper.Init(new MersenneTwister((item, array)));
			TradeSaveData tradeSaveData = TradeSaveData.FromJson(binaryReader.ReadString());
			list.Add(new StockDataIO.StockDataDTO
			{
				TradeSaveData = tradeSaveData
			});
			List<Article> articles = JsonSerializer.Deserialize<List<Article>>(binaryReader.ReadString());
			list.Add(new StockDataIO.StockDataDTO
			{
				Articles = articles
			});
			while (binaryReader.BaseStream.Position < binaryReader.BaseStream.Length)
			{
				StockDataIO.StockDataDTO item2 = new StockDataIO.StockDataDTO
				{
					Id = binaryReader.ReadInt32(),
					Name = binaryReader.ReadString(),
					Symbol = binaryReader.ReadString(),
					Date = ReadNullableTimeData(binaryReader),
					Price = ReadNullableDecimal(binaryReader),
					Open = binaryReader.ReadDecimal(),
					Close = ReadNullableDecimal(binaryReader),
					High = binaryReader.ReadDecimal(),
					Low = binaryReader.ReadDecimal(),
					Volatility = ReadNullableDouble(binaryReader),
					TrendPercentage = ReadNullableDouble(binaryReader),
					TrendStartPrice = ReadNullableDecimal(binaryReader),
					TrendEndPrice = ReadNullableDecimal(binaryReader),
					TrendSteps = ReadNullableInt(binaryReader),
					Average = binaryReader.ReadDecimal()
				};
				list.Add(item2);
			}
			return list;
		}

		private static void WriteNullableTimeData(BinaryWriter writer, TimeData? value)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			writer.Write(value.HasValue);
			if (value.HasValue)
			{
				TimeData value2 = value.Value;
				writer.Write(((TimeData)(ref value2)).Serialize());
			}
		}

		private static void WriteNullableDecimal(BinaryWriter writer, decimal? value)
		{
			writer.Write(value.HasValue);
			if (value.HasValue)
			{
				writer.Write(value.Value);
			}
		}

		private static void WriteNullableDouble(BinaryWriter writer, double? value)
		{
			writer.Write(value.HasValue);
			if (value.HasValue)
			{
				writer.Write(value.Value);
			}
		}

		private static void WriteNullableInt(BinaryWriter writer, int? value)
		{
			writer.Write(value.HasValue);
			if (value.HasValue)
			{
				writer.Write(value.Value);
			}
		}

		private static TimeData? ReadNullableTimeData(BinaryReader reader)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (reader.ReadBoolean())
			{
				return TimeData.Deserialize(reader.ReadString());
			}
			return null;
		}

		private static decimal? ReadNullableDecimal(BinaryReader reader)
		{
			if (reader.ReadBoolean())
			{
				return reader.ReadDecimal();
			}
			return null;
		}

		private static double? ReadNullableDouble(BinaryReader reader)
		{
			if (reader.ReadBoolean())
			{
				return reader.ReadDouble();
			}
			return null;
		}

		private static int? ReadNullableInt(BinaryReader reader)
		{
			if (reader.ReadBoolean())
			{
				return reader.ReadInt32();
			}
			return null;
		}
	}
	internal sealed class CsvConverter : IDataConverter
	{
		private CsvConverter()
		{
		}

		internal static CsvConverter Create()
		{
			return new CsvConverter();
		}

		public void Save(List<StockDataIO.StockDataDTO> data, MersenneTwister random, string path, bool simulation = false)
		{
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			using StreamWriter streamWriter = new StreamWriter(path, new FileStreamOptions
			{
				Mode = FileMode.Create,
				Access = FileAccess.Write,
				Share = FileShare.Write
			});
			var (value, uintArray) = random.SaveState();
			streamWriter.WriteLine($"{value}|{Convert.ToBase64String(ConvertUIntArrayToBytes(uintArray))}");
			streamWriter.WriteLine(data[0].TradeSaveData.ToJson());
			streamWriter.WriteLine(JsonSerializer.Serialize(data[1].Articles, new JsonSerializerOptions
			{
				WriteIndented = false
			}));
			string text = "Id,Name,Symbol,Date,Price,Open,Close,High,Low,Volatility,TrendPercentage,TrendStartPrice,TrendEndPrice,TrendSteps,Average";
			if (simulation)
			{
				text += ",OriginalPrice,SimulationChange";
			}
			streamWriter.WriteLine(text);
			for (int i = 2; i < data.Count; i++)
			{
				StockDataIO.StockDataDTO stockDataDTO = data[i];
				DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(14, 15);
				defaultInterpolatedStringHandler.AppendFormatted(stockDataDTO.Id);
				defaultInterpolatedStringHandler.AppendLiteral(",");
				defaultInterpolatedStringHandler.AppendFormatted(EscapeCsvField(stockDataDTO.Name));
				defaultInterpolatedStringHandler.AppendLiteral(",");
				defaultInterpolatedStringHandler.AppendFormatted(EscapeCsvField(stockDataDTO.Symbol));
				defaultInterpolatedStringHandler.AppendLiteral(",");
				string value2;
				if (!stockDataDTO.Date.HasValue)
				{
					value2 = string.Empty;
				}
				else
				{
					TimeData value3 = stockDataDTO.Date.Value;
					value2 = EscapeCsvField(((TimeData)(ref value3)).Serialize());
				}
				defaultInterpolatedStringHandler.AppendFormatted(value2);
				defaultInterpolatedStringHandler.AppendLiteral(",");
				defaultInterpolatedStringHandler.AppendFormatted(stockDataDTO.Price?.ToString(CultureInfo.InvariantCulture) ?? string.Empty);
				defaultInterpolatedStringHandler.AppendLiteral(",");
				defaultInterpolatedStringHandler.AppendFormatted(stockDataDTO.Open.ToString(CultureInfo.InvariantCulture));
				defaultInterpolatedStringHandler.AppendLiteral(",");
				defaultInterpolatedStringHandler.AppendFormatted(stockDataDTO.Close.HasValue ? stockDataDTO.Close.Value.ToString(CultureInfo.InvariantCulture) : string.Empty);
				defaultInterpolatedStringHandler.AppendLiteral(",");
				defaultInterpolatedStringHandler.AppendFormatted(stockDataDTO.High.ToString(CultureInfo.InvariantCulture));
				defaultInterpolatedStringHandler.AppendLiteral(",");
				defaultInterpolatedStringHandler.AppendFormatted(stockDataDTO.Low.ToString(CultureInfo.InvariantCulture));
				defaultInterpolatedStringHandler.AppendLiteral(",");
				defaultInterpolatedStringHandler.AppendFormatted(stockDataDTO.Volatility.HasValue ? stockDataDTO.Volatility.Value.ToString(CultureInfo.InvariantCulture) : string.Empty);
				defaultInterpolatedStringHandler.AppendLiteral(",");
				defaultInterpolatedStringHandler.AppendFormatted(stockDataDTO.TrendPercentage.HasValue ? stockDataDTO.TrendPercentage.Value.ToString(CultureInfo.InvariantCulture) : string.Empty);
				defaultInterpolatedStringHandler.AppendLiteral(",");
				defaultInterpolatedStringHandler.AppendFormatted(stockDataDTO.TrendStartPrice.HasValue ? stockDataDTO.TrendStartPrice.Value.ToString(CultureInfo.InvariantCulture) : string.Empty);
				defaultInterpolatedStringHandler.AppendLiteral(",");
				defaultInterpolatedStringHandler.AppendFormatted(stockDataDTO.TrendEndPrice.HasValue ? stockDataDTO.TrendEndPrice.Value.ToString(CultureInfo.InvariantCulture) : string.Empty);
				defaultInterpolatedStringHandler.AppendLiteral(",");
				defaultInterpolatedStringHandler.AppendFormatted(stockDataDTO.TrendSteps.HasValue ? stockDataDTO.TrendSteps.Value.ToString(CultureInfo.InvariantCulture) : string.Empty);
				defaultInterpolatedStringHandler.AppendLiteral(",");
				defaultInterpolatedStringHandler.AppendFormatted(stockDataDTO.Average.ToString(CultureInfo.InvariantCulture));
				string text2 = defaultInterpolatedStringHandler.ToStringAndClear();
				if (simulation && stockDataDTO.OriginalPrice.HasValue && stockDataDTO.Price.HasValue)
				{
					text2 = text2 + "," + stockDataDTO.OriginalPrice.Value.ToString(CultureInfo.InvariantCulture);
					text2 = text2 + "," + stockDataDTO.SimulationChange.ToString(CultureInfo.InvariantCulture);
				}
				streamWriter.WriteLine(text2);
			}
		}

		public List<StockDataIO.StockDataDTO> Load(string path)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			List<StockDataIO.StockDataDTO> list = new List<StockDataIO.StockDataDTO>();
			using StreamReader streamReader = new StreamReader(path, new FileStreamOptions
			{
				Mode = FileMode.Open,
				Access = FileAccess.Read,
				Share = FileShare.Read
			});
			string[] array = streamReader.ReadLine().Split('|');
			int item = int.Parse(array[0]);
			uint[] item2 = ConvertByteArrayToUIntArray(Convert.FromBase64String(array[1]));
			MathHelper.Init(new MersenneTwister((item, item2)));
			TradeSaveData tradeSaveData = TradeSaveData.FromJson(streamReader.ReadLine());
			list.Add(new StockDataIO.StockDataDTO
			{
				TradeSaveData = tradeSaveData
			});
			List<Article> articles = JsonSerializer.Deserialize<List<Article>>(streamReader.ReadLine());
			list.Add(new StockDataIO.StockDataDTO
			{