using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;
using Microsoft.CodeAnalysis;
using Setting;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Empress.CapsuleParade
{
	[BepInPlugin("empress.paralives.capsuleparade", "Empress Capsule Parade", "1.0.0")]
	public sealed class EmpressCapsuleParadePlugin : BaseUnityPlugin
	{
		public const string PluginGuid = "empress.paralives.capsuleparade";

		public const string PluginName = "Empress Capsule Parade";

		public const string PluginVersion = "1.0.0";

		private void Awake()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("EmpressCapsuleParadeRuntime");
			Object.DontDestroyOnLoad((Object)val);
			((Object)val).hideFlags = (HideFlags)61;
			val.AddComponent<EmpressCapsuleParadeRuntime>();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Empress Capsule Parade 1.0.0 loaded");
		}
	}
	public sealed class EmpressCapsuleParadeRuntime : MonoBehaviour
	{
		private readonly Dictionary<int, EmpressCapsuleState> states = new Dictionary<int, EmpressCapsuleState>();

		private readonly List<int> cleanup = new List<int>();

		private Material femaleMaterial;

		private Material maleMaterial;

		private Material noneMaterial;

		private float nextScan;

		private float nextErrorLog;

		private void Awake()
		{
			CreateMaterials();
		}

		private void LateUpdate()
		{
			if (Time.unscaledTime < nextScan)
			{
				return;
			}
			nextScan = Time.unscaledTime + 0.2f;
			try
			{
				CharacterVisual[] array = Resources.FindObjectsOfTypeAll<CharacterVisual>();
				for (int i = 0; i < array.Length; i++)
				{
					SyncVisual(array[i]);
				}
				CleanupStates();
			}
			catch (Exception ex)
			{
				if (Time.unscaledTime >= nextErrorLog)
				{
					nextErrorLog = Time.unscaledTime + 5f;
					Debug.LogWarning((object)("Empress Capsule Parade sync failed: " + ex.Message));
				}
			}
		}

		private void SyncVisual(CharacterVisual visual)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)visual == (Object)null || (Object)(object)((Component)visual).gameObject == (Object)null)
			{
				return;
			}
			Scene scene = ((Component)visual).gameObject.scene;
			if (((Scene)(ref scene)).IsValid())
			{
				int instanceID = ((Object)visual).GetInstanceID();
				if (!states.TryGetValue(instanceID, out var value) || (Object)(object)value.Capsule == (Object)null)
				{
					value = CreateState(visual);
					states[instanceID] = value;
				}
				value.Visual = visual;
				AssetCharacter character = GetCharacter(visual.CharacterGUID);
				EmpressCapsuleSize size = GetSize(character);
				Material material = GetMaterial(character);
				if ((Object)(object)value.Renderer != (Object)null && (Object)(object)value.Renderer.sharedMaterial != (Object)(object)material)
				{
					value.Renderer.sharedMaterial = material;
				}
				Transform transform = value.Capsule.transform;
				transform.SetParent(((Component)visual).transform, false);
				transform.localPosition = new Vector3(0f, size.Height * 0.5f, 0f);
				transform.localRotation = Quaternion.identity;
				transform.localScale = new Vector3(size.Diameter, size.Height * 0.5f, size.Diameter);
				value.Capsule.SetActive(visual.IsVisible && ((Component)visual).gameObject.activeInHierarchy);
				HideOriginalRenderers(visual, transform);
			}
		}

		private EmpressCapsuleState CreateState(CharacterVisual visual)
		{
			GameObject val = GameObject.CreatePrimitive((PrimitiveType)1);
			((Object)val).name = "EmpressCapsule";
			val.transform.SetParent(((Component)visual).transform, false);
			val.layer = ((Component)visual).gameObject.layer;
			Collider component = val.GetComponent<Collider>();
			if ((Object)(object)component != (Object)null)
			{
				Object.Destroy((Object)(object)component);
			}
			Renderer component2 = val.GetComponent<Renderer>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.sharedMaterial = noneMaterial;
				component2.receiveShadows = true;
			}
			return new EmpressCapsuleState
			{
				Visual = visual,
				Capsule = val,
				Renderer = component2
			};
		}

		private void HideOriginalRenderers(CharacterVisual visual, Transform capsuleTransform)
		{
			SkinnedMeshRenderer[] componentsInChildren = ((Component)visual).GetComponentsInChildren<SkinnedMeshRenderer>(true);
			foreach (SkinnedMeshRenderer val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null && !((Component)val).transform.IsChildOf(capsuleTransform))
				{
					((Renderer)val).enabled = false;
				}
			}
			MeshRenderer[] componentsInChildren2 = ((Component)visual).GetComponentsInChildren<MeshRenderer>(true);
			foreach (MeshRenderer val2 in componentsInChildren2)
			{
				if ((Object)(object)val2 != (Object)null && !((Component)val2).transform.IsChildOf(capsuleTransform) && !IsSelectionRenderer(visual, val2))
				{
					((Renderer)val2).enabled = false;
				}
			}
		}

		private bool IsSelectionRenderer(CharacterVisual visual, MeshRenderer renderer)
		{
			if ((Object)(object)visual.SelectionObject == (Object)null)
			{
				return false;
			}
			return (Object)(object)renderer == (Object)(object)visual.SelectionObject.Renderer;
		}

		private AssetCharacter GetCharacter(ulong guid)
		{
			if (guid == 0L || (Object)(object)AssetManager.Instance == (Object)null)
			{
				return null;
			}
			return AssetManager.Instance.GetCharacter(guid);
		}

		private EmpressCapsuleSize GetSize(AssetCharacter character)
		{
			string stageName = GetStageName(character);
			if (Contains(stageName, "baby"))
			{
				return new EmpressCapsuleSize(0.48f, 0.34f);
			}
			if (Contains(stageName, "toddler"))
			{
				return new EmpressCapsuleSize(0.82f, 0.44f);
			}
			if (Contains(stageName, "child"))
			{
				return new EmpressCapsuleSize(1.18f, 0.5f);
			}
			if (Contains(stageName, "preteen"))
			{
				return new EmpressCapsuleSize(1.42f, 0.54f);
			}
			if (Contains(stageName, "teen"))
			{
				return new EmpressCapsuleSize(1.58f, 0.58f);
			}
			if (Contains(stageName, "youngadult"))
			{
				return new EmpressCapsuleSize(1.76f, 0.62f);
			}
			if (Contains(stageName, "adult"))
			{
				return new EmpressCapsuleSize(1.72f, 0.62f);
			}
			if (Contains(stageName, "elder"))
			{
				return new EmpressCapsuleSize(1.66f, 0.6f);
			}
			float num = ((character != null) ? character.Data.Age : 18f);
			if (num < 2f)
			{
				return new EmpressCapsuleSize(0.48f, 0.34f);
			}
			if (num < 5f)
			{
				return new EmpressCapsuleSize(0.82f, 0.44f);
			}
			if (num < 9f)
			{
				return new EmpressCapsuleSize(1.18f, 0.5f);
			}
			if (num < 13f)
			{
				return new EmpressCapsuleSize(1.42f, 0.54f);
			}
			if (num < 18f)
			{
				return new EmpressCapsuleSize(1.58f, 0.58f);
			}
			if (num < 40f)
			{
				return new EmpressCapsuleSize(1.76f, 0.62f);
			}
			if (num < 65f)
			{
				return new EmpressCapsuleSize(1.72f, 0.62f);
			}
			return new EmpressCapsuleSize(1.66f, 0.6f);
		}

		private string GetStageName(AssetCharacter character)
		{
			if (character == null)
			{
				return string.Empty;
			}
			try
			{
				LifeStage currentLifeStageOfCharacter = LifeStageManager.Instance.GetCurrentLifeStageOfCharacter(character);
				return (currentLifeStageOfCharacter != null && currentLifeStageOfCharacter.DisplayName != null) ? currentLifeStageOfCharacter.DisplayName : string.Empty;
			}
			catch
			{
				return string.Empty;
			}
		}

		private bool Contains(string value, string fragment)
		{
			if (value != null)
			{
				return value.IndexOf(fragment, StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return false;
		}

		private Material GetMaterial(AssetCharacter character)
		{
			if ((Object)(object)femaleMaterial == (Object)null || (Object)(object)maleMaterial == (Object)null || (Object)(object)noneMaterial == (Object)null)
			{
				CreateMaterials();
			}
			ulong num = ((character != null) ? character.Data.Gender : 0);
			Genders val = Settings.Get<Genders>();
			if (val != null)
			{
				if (num == val.FemaleGender)
				{
					return femaleMaterial;
				}
				if (num == val.MaleGender)
				{
					return maleMaterial;
				}
			}
			return noneMaterial;
		}

		private void CreateMaterials()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			femaleMaterial = CreateMaterial("EmpressCapsulePink", new Color(1f, 0.22f, 0.66f, 1f));
			maleMaterial = CreateMaterial("EmpressCapsuleBlue", new Color(0.18f, 0.47f, 1f, 1f));
			noneMaterial = CreateMaterial("EmpressCapsuleWhite", new Color(1f, 1f, 1f, 1f));
		}

		private Material CreateMaterial(string name, Color color)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			Shader val = Shader.Find("Universal Render Pipeline/Lit");
			if ((Object)(object)val == (Object)null)
			{
				val = Shader.Find("Standard");
			}
			if ((Object)(object)val == (Object)null)
			{
				val = Shader.Find("Unlit/Color");
			}
			if ((Object)(object)val == (Object)null)
			{
				val = Shader.Find("Sprites/Default");
			}
			Material val2 = new Material(val);
			((Object)val2).name = name;
			val2.color = color;
			if (val2.HasProperty("_BaseColor"))
			{
				val2.SetColor("_BaseColor", color);
			}
			if (val2.HasProperty("_Color"))
			{
				val2.SetColor("_Color", color);
			}
			if (val2.HasProperty("_Smoothness"))
			{
				val2.SetFloat("_Smoothness", 0.55f);
			}
			if (val2.HasProperty("_Metallic"))
			{
				val2.SetFloat("_Metallic", 0f);
			}
			return val2;
		}

		private void CleanupStates()
		{
			cleanup.Clear();
			foreach (KeyValuePair<int, EmpressCapsuleState> state in states)
			{
				if ((Object)(object)state.Value.Visual == (Object)null || (Object)(object)state.Value.Capsule == (Object)null)
				{
					cleanup.Add(state.Key);
				}
			}
			for (int i = 0; i < cleanup.Count; i++)
			{
				states.Remove(cleanup[i]);
			}
		}

		private void OnDestroy()
		{
			DestroyMaterial(femaleMaterial);
			DestroyMaterial(maleMaterial);
			DestroyMaterial(noneMaterial);
		}

		private void DestroyMaterial(Material material)
		{
			if ((Object)(object)material != (Object)null)
			{
				Object.Destroy((Object)(object)material);
			}
		}
	}
	internal sealed class EmpressCapsuleState
	{
		public CharacterVisual Visual;

		public GameObject Capsule;

		public Renderer Renderer;
	}
	internal struct EmpressCapsuleSize
	{
		public float Height;

		public float Diameter;

		public EmpressCapsuleSize(float height, float diameter)
		{
			Height = height;
			Diameter = diameter;
		}
	}
}