using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.6", FrameworkDisplayName = ".NET Framework 4.6")]
[assembly: AssemblyCompany("DSPNestedMoons")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.2.0")]
[assembly: AssemblyInformationalVersion("1.0.2+b0b99c7e92e155b9e8c3ceb71cd5ca2263c6c778")]
[assembly: AssemblyProduct("DSPNestedMoons")]
[assembly: AssemblyTitle("DSPNestedMoons")]
[assembly: AssemblyVersion("1.0.2.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
}
namespace DSPNestedMoons
{
	internal sealed class BodyLayout
	{
		internal int BodyIndex { get; }

		internal bool IsGas { get; }

		internal int ParentIndex { get; set; }

		internal int Depth { get; set; }

		internal int OrbitIndex { get; set; }

		internal int SiblingNumber { get; set; }

		internal List<int> Children { get; }

		internal BodyLayout(int bodyIndex, bool isGas)
		{
			BodyIndex = bodyIndex;
			IsGas = isGas;
			ParentIndex = -1;
			Children = new List<int>();
		}
	}
	internal static class NestedMoonLayoutGenerator
	{
		private sealed class LayoutRandom
		{
			private uint state;

			internal LayoutRandom(int seed)
			{
				state = (uint)(seed ^ -1640531527);
				if (state == 0)
				{
					state = 1831565813u;
				}
			}

			internal double NextDouble()
			{
				uint num = state;
				num ^= num << 13;
				num ^= num >> 17;
				return (double)(state = num ^ (num << 5)) / 4294967296.0;
			}
		}

		internal const double BaseMoonChance = 0.6;

		internal static BodyLayout[] Generate(IReadOnlyList<bool> gasFlags, int seed)
		{
			LayoutRandom layoutRandom = new LayoutRandom(seed);
			return Generate(gasFlags, layoutRandom.NextDouble);
		}

		internal static BodyLayout[] Generate(IReadOnlyList<bool> gasFlags, Func<double> nextDouble)
		{
			if (gasFlags == null)
			{
				throw new ArgumentNullException("gasFlags");
			}
			if (nextDouble == null)
			{
				throw new ArgumentNullException("nextDouble");
			}
			BodyLayout[] array = new BodyLayout[gasFlags.Count];
			int cursor = 0;
			while (cursor < array.Length)
			{
				AddChildrenDepthFirst(CreateBody(array, gasFlags, cursor++, -1, 0), array, gasFlags, ref cursor, nextDouble);
			}
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i].ParentIndex < 0)
				{
					AssignSatelliteOrbits(array[i], array);
				}
			}
			return array;
		}

		internal static double GetHostChance(int hostDepth)
		{
			if (hostDepth < 0)
			{
				throw new ArgumentOutOfRangeException("hostDepth");
			}
			return Math.Pow(0.6, hostDepth + 1);
		}

		internal static float GetRadiusForDepth(int depth, float originalRadius)
		{
			if (depth == 3)
			{
				return 160f;
			}
			if (depth >= 4)
			{
				return 80f;
			}
			return originalRadius;
		}

		private static BodyLayout CreateBody(BodyLayout[] layouts, IReadOnlyList<bool> gasFlags, int bodyIndex, int parentIndex, int depth)
		{
			BodyLayout result = (layouts[bodyIndex] = new BodyLayout(bodyIndex, gasFlags[bodyIndex])
			{
				ParentIndex = parentIndex,
				Depth = depth
			});
			if (parentIndex >= 0)
			{
				layouts[parentIndex].Children.Add(bodyIndex);
			}
			return result;
		}

		private static void AddChildrenDepthFirst(BodyLayout parent, BodyLayout[] layouts, IReadOnlyList<bool> gasFlags, ref int cursor, Func<double> nextDouble)
		{
			double hostChance = GetHostChance(parent.Depth);
			while (cursor < layouts.Length && nextDouble() < hostChance)
			{
				AddChildrenDepthFirst(CreateBody(layouts, gasFlags, cursor++, parent.BodyIndex, parent.Depth + 1), layouts, gasFlags, ref cursor, nextDouble);
			}
		}

		private static void AssignSatelliteOrbits(BodyLayout host, BodyLayout[] layouts)
		{
			int num = 0;
			for (int i = 0; i < host.Children.Count; i++)
			{
				BodyLayout bodyLayout = layouts[host.Children[i]];
				int num2 = (bodyLayout.IsGas ? 3 : ((bodyLayout.Children.Count > 0) ? 1 : 0));
				bodyLayout.SiblingNumber = i + 1;
				bodyLayout.OrbitIndex = i + 1 + num + num2;
				num += num2 * 2;
				AssignSatelliteOrbits(bodyLayout, layouts);
			}
		}
	}
	[BepInPlugin("Zincon.DSPNestedMoons", "mooooooon", "1.0.2")]
	[BepInProcess("DSPGAME.exe")]
	[BepInDependency("Zincon.DSPAddPlanetMoon2Patch", "3.0.15")]
	[BepInIncompatibility("dsp.galactic-scale.2")]
	public sealed class Plugin : BaseUnityPlugin
	{
		internal static class DspAddPlanetCompatibility
		{
			private static object pluginInstance;

			private static FieldInfo orderedPoseUpdateField;

			internal static void Initialize()
			{
				Type type = AccessTools.TypeByName("DSPAddPlanet.Plugin");
				if (type == null)
				{
					throw new TypeLoadException("DSPAddPlanet.Plugin was not found. mooooooon requires Zincon.DSPAddPlanetMoon2Patch 3.0.15 or newer.");
				}
				PropertyInfo propertyInfo = AccessTools.Property(type, "Instance");
				orderedPoseUpdateField = AccessTools.Field(type, "needsOrderedPoseUpdate");
				pluginInstance = propertyInfo?.GetValue(null, null);
				if (pluginInstance == null || orderedPoseUpdateField == null || orderedPoseUpdateField.FieldType != typeof(bool))
				{
					throw new MissingMemberException("The installed DSPAddPlanet recursive-pose compatibility contract has changed.");
				}
			}

			internal static void RequireOrderedPoseUpdates()
			{
				orderedPoseUpdateField.SetValue(pluginInstance, true);
			}
		}

		public const string PluginGuid = "Zincon.DSPNestedMoons";

		public const string PluginName = "mooooooon";

		public const string PluginVersion = "1.0.2";

		public const string DspAddPlanetGuid = "Zincon.DSPAddPlanetMoon2Patch";

		public const string DspAddPlanetMinimumVersion = "3.0.15";

		private Harmony harmony;

		private void Awake()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			try
			{
				StarGenerationPatch.ValidateTarget();
				DspAddPlanetCompatibility.Initialize();
				harmony = new Harmony("Zincon.DSPNestedMoons");
				harmony.PatchAll(typeof(StarGenerationPatch));
				((BaseUnityPlugin)this).Logger.LogInfo((object)"mooooooon 1.0.2 loaded. Natural recursive moon generation is enabled for new universes.");
			}
			catch (Exception arg)
			{
				Harmony obj = harmony;
				if (obj != null)
				{
					obj.UnpatchSelf();
				}
				harmony = null;
				((BaseUnityPlugin)this).Logger.LogError((object)$"Failed to enable recursive moon generation:\n{arg}");
			}
		}

		private void OnDestroy()
		{
			Harmony obj = harmony;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
			harmony = null;
		}
	}
	[HarmonyPatch(typeof(StarGen), "CreateStarPlanets")]
	internal static class StarGenerationPatch
	{
		private readonly struct OrbitAnchor
		{
			internal int OrbitIndex { get; }

			internal float OrbitRadius { get; }

			internal OrbitAnchor(int orbitIndex, float orbitRadius)
			{
				OrbitIndex = orbitIndex;
				OrbitRadius = orbitRadius;
			}
		}

		private const double StarGravity = 1.3538551990520382E-06;

		private const double SatelliteGravity = 1.0830842106853677E-08;

		private const double FourPiSquared = 39.47841760435743;

		internal static void ValidateTarget()
		{
			MethodInfo methodInfo = AccessTools.Method(typeof(StarGen), "CreateStarPlanets", new Type[3]
			{
				typeof(GalaxyData),
				typeof(StarData),
				typeof(GameDesc)
			}, (Type[])null);
			if (methodInfo == null || methodInfo.ReturnType != typeof(void) || !methodInfo.IsStatic)
			{
				throw new MissingMethodException("StarGen.CreateStarPlanets(GalaxyData, StarData, GameDesc) has changed.");
			}
		}

		[HarmonyPostfix]
		[HarmonyPriority(800)]
		[HarmonyBefore(new string[] { "Zincon.DSPAddPlanetMoon2Patch" })]
		private static void CreateStarPlanetsPostfix(GalaxyData galaxy, StarData star)
		{
			if (galaxy != null && star?.planets != null && star.planets.Length >= 2)
			{
				ApplyNaturalLayout(galaxy, star);
				Plugin.DspAddPlanetCompatibility.RequireOrderedPoseUpdates();
			}
		}

		private static void ApplyNaturalLayout(GalaxyData galaxy, StarData star)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Invalid comparison between Unknown and I4
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			PlanetData[] planets = star.planets;
			bool[] array = new bool[planets.Length];
			List<OrbitAnchor> list = new List<OrbitAnchor>();
			for (int i = 0; i < planets.Length; i++)
			{
				PlanetData val = planets[i];
				if (val == null)
				{
					throw new InvalidOperationException($"Star {star.id} contains an empty body slot at index {i}.");
				}
				array[i] = (int)val.type == 5;
				if (val.orbitAroundPlanet == null)
				{
					list.Add(new OrbitAnchor(val.orbitIndex, val.orbitRadius));
				}
			}
			int seed = (star.seed * 397) ^ (star.id * 7919) ^ 0x4D6F6F6E;
			BodyLayout[] array2 = NestedMoonLayoutGenerator.Generate(array, seed);
			int num = 0;
			int num2 = 0;
			int val2 = 0;
			for (int j = 0; j < array2.Length; j++)
			{
				BodyLayout bodyLayout = array2[j];
				PlanetData val3 = planets[j];
				val2 = Math.Max(val2, bodyLayout.Depth);
				if (bodyLayout.ParentIndex < 0)
				{
					OrbitAnchor orbitAnchor = ((num < list.Count) ? list[num] : CreateAdditionalRootAnchor(star, num2 + 1));
					val3.orbitAroundPlanet = null;
					val3.orbitAround = 0;
					val3.orbitIndex = orbitAnchor.OrbitIndex;
					val3.number = num + 1;
					val3.orbitRadius = orbitAnchor.OrbitRadius;
					val3.sunDistance = val3.orbitRadius;
					val3.orbitalPeriod = CalculateOrbitPeriod(val3.orbitRadius, 1.3538551990520382E-06 * (double)star.mass);
					num2 = val3.orbitIndex;
					num++;
				}
				else
				{
					PlanetData val4 = (val3.orbitAroundPlanet = planets[bodyLayout.ParentIndex]);
					val3.orbitAround = val4.number;
					val3.orbitIndex = bodyLayout.OrbitIndex;
					val3.number = bodyLayout.SiblingNumber;
					val3.orbitRadius = CalculateSatelliteOrbitRadius(star, val4, val3);
					val3.sunDistance = GetRootOrbitRadius(val4);
					val3.orbitalPeriod = CalculateOrbitPeriod(val3.orbitRadius, 1.0830842106853677E-08);
				}
				ApplyDepthRadius(galaxy, val3, bodyLayout.Depth);
				UpdateRuntimeRotations(val3);
				UpdateLuminosity(val3);
				val3.singularity = (EPlanetSingularity)(val3.singularity & -33);
			}
			for (int k = 0; k < array2.Length; k++)
			{
				if (array2[k].Children.Count > 0)
				{
					PlanetData obj = planets[k];
					obj.singularity = (EPlanetSingularity)(obj.singularity | 0x20);
				}
			}
			Plugin.DspAddPlanetCompatibility.RequireOrderedPoseUpdates();
		}

		private static OrbitAnchor CreateAdditionalRootAnchor(StarData star, int requestedIndex)
		{
			int num = Math.Max(1, requestedIndex);
			float orbitRadius;
			if (num < StarGen.orbitRadius.Length)
			{
				orbitRadius = StarGen.orbitRadius[num] * star.orbitScaler;
			}
			else
			{
				int num2 = StarGen.orbitRadius.Length - 1;
				float num3 = StarGen.orbitRadius[num2] - StarGen.orbitRadius[num2 - 1];
				orbitRadius = (StarGen.orbitRadius[num2] + num3 * (float)(num - num2)) * star.orbitScaler;
			}
			return new OrbitAnchor(num, orbitRadius);
		}

		private static float CalculateSatelliteOrbitRadius(StarData star, PlanetData parent, PlanetData satellite)
		{
			//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)
			DotNet35Random val = new DotNet35Random(satellite.infoSeed);
			double num = val.NextDouble();
			double num2 = val.NextDouble();
			float num3 = Mathf.Pow(1.2f, (float)(num * (num2 - 0.5) * 0.5));
			return ((1600f * (float)satellite.orbitIndex + 200f) * Mathf.Pow(star.orbitScaler, 0.3f) * Mathf.Lerp(num3, 1f, 0.5f) + parent.realRadius) / 40000f;
		}

		private static double CalculateOrbitPeriod(float orbitRadius, double gravity)
		{
			double num = orbitRadius;
			return Math.Sqrt(39.47841760435743 * num * num * num / gravity);
		}

		private static float GetRootOrbitRadius(PlanetData body)
		{
			PlanetData val = body;
			while (val.orbitAroundPlanet != null)
			{
				val = val.orbitAroundPlanet;
			}
			return val.orbitRadius;
		}

		private static void ApplyDepthRadius(GalaxyData galaxy, PlanetData body, int depth)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Invalid comparison between Unknown and I4
			float radiusForDepth = NestedMoonLayoutGenerator.GetRadiusForDepth(depth, body.radius);
			if (!(Math.Abs(radiusForDepth - body.radius) < 0.01f))
			{
				body.radius = radiusForDepth;
				if ((int)body.type != 5)
				{
					body.scale = 1f;
					body.precision = 200;
					body.segment = 5;
				}
				if (body.id >= 0 && body.id < galaxy.astrosData.Length)
				{
					galaxy.astrosData[body.id].uRadius = body.realRadius;
				}
			}
		}

		private static void UpdateRuntimeRotations(PlanetData body)
		{
			//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_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: 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_0025: 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_003a: 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)
			//IL_0043: 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)
			//IL_0055: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			Quaternion val = Quaternion.AngleAxis(body.orbitLongitude, Vector3.up) * Quaternion.AngleAxis(body.orbitInclination, Vector3.forward);
			body.runtimeOrbitRotation = ((body.orbitAroundPlanet == null) ? val : (body.orbitAroundPlanet.runtimeOrbitRotation * val));
			body.runtimeSystemRotation = body.runtimeOrbitRotation * Quaternion.AngleAxis(body.obliquity, Vector3.forward);
		}

		private static void UpdateLuminosity(PlanetData body)
		{
			body.luminosity = Mathf.Pow(body.star.lightBalanceRadius / (body.sunDistance + 0.01f), 0.6f);
			if (body.luminosity > 1f)
			{
				body.luminosity = Mathf.Log(body.luminosity) + 1f;
				body.luminosity = Mathf.Log(body.luminosity) + 1f;
				body.luminosity = Mathf.Log(body.luminosity) + 1f;
			}
			body.luminosity = Mathf.Round(body.luminosity * 100f) / 100f;
		}
	}
}