using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using UnityEngine;
using UnityEngine.Rendering;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("AdvancedStructureSkins.Shared")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("AdvancedStructureSkins.Shared")]
[assembly: AssemblyTitle("AdvancedStructureSkins.Shared")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace AdvancedStructureSkins.Shared.SDK
{
	[Serializable]
	public class MaterialPropertyOverride
	{
		public string propertyName = "";

		public ShaderPropertyType propertyType;

		public Color colorValue;

		public float floatValue;

		public int intValue;

		public Vector4 vectorValue;

		public Texture textureValue;

		public StructureFlags targetStructures;
	}
	public enum StructureType
	{
		Disc,
		Pillar,
		Ball,
		Cube,
		Wall,
		SmallRock,
		LargeRock
	}
	[Serializable]
	public class MaterialPropertyOverrideManifest
	{
		public List<MaterialPropertyOverride> overrides;
	}
	[Serializable]
	public class ShaderManifest
	{
		public Material material;

		public List<MaterialPropertyOverride> overrides;
	}
	public class SkinManifest : ScriptableObject
	{
		public string skinName;

		public Texture previewTexture;

		public bool allowedInComp;

		public List<ShaderManifest> shaders;

		public List<TextureSetManifest> textures;
	}
	[Flags]
	public enum StructureFlags : byte
	{
		None = 0,
		Disc = 1,
		Pillar = 2,
		Ball = 4,
		Cube = 8,
		Wall = 0x10,
		SmallRock = 0x20,
		LargeRock = 0x40,
		Global = 0x80
	}
	[Serializable]
	public class TextureSetManifest
	{
		public string name;

		public Texture previewTexture;

		public List<TextureEntry> textures = new List<TextureEntry>();

		public StructureFlags targets;
	}
	[Serializable]
	public class TextureEntry
	{
		public TextureType type;

		public List<Texture> textures;
	}
	public enum TextureType
	{
		Main,
		Normal,
		Mat,
		Ground
	}
}
namespace AdvancedStructureSkins.Shared.SDK.Binary
{
	public class BinaryHandler
	{
		public static byte[] Write(SkinManifest manifest)
		{
			using MemoryStream memoryStream = new MemoryStream();
			using BinaryWriter binaryWriter = new BinaryWriter(memoryStream);
			binaryWriter.Write(1);
			binaryWriter.Write(string.IsNullOrEmpty(manifest.skinName) ? ((Object)manifest).name : manifest.skinName);
			binaryWriter.Write(((Object)(object)manifest.previewTexture != (Object)null) ? ((Object)manifest.previewTexture).name : "");
			binaryWriter.Write(manifest.allowedInComp);
			binaryWriter.Write(manifest.shaders?.Count ?? 0);
			if (manifest.shaders != null)
			{
				foreach (ShaderManifest shader in manifest.shaders)
				{
					WriteShaderManifest(binaryWriter, shader);
				}
			}
			binaryWriter.Write(manifest.textures?.Count ?? 0);
			if (manifest.textures != null)
			{
				foreach (TextureSetManifest texture in manifest.textures)
				{
					WriteTextureSet(binaryWriter, texture);
				}
			}
			return memoryStream.ToArray();
		}

		public static void WriteShaderManifest(BinaryWriter writer, ShaderManifest manifest)
		{
			Material material = manifest.material;
			writer.Write(((material != null) ? ((Object)material).name : null) ?? "");
			writer.Write(manifest.overrides?.Count ?? 0);
			if (manifest.overrides == null)
			{
				return;
			}
			foreach (MaterialPropertyOverride @override in manifest.overrides)
			{
				WriteOverride(writer, @override);
			}
		}

		private static void WriteOverride(BinaryWriter writer, MaterialPropertyOverride o)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			writer.Write(o.propertyName ?? "");
			writer.Write((byte)o.propertyType);
			writer.Write(o.colorValue.r);
			writer.Write(o.colorValue.g);
			writer.Write(o.colorValue.b);
			writer.Write(o.colorValue.a);
			writer.Write(o.floatValue);
			writer.Write(o.intValue);
			writer.Write(o.vectorValue.x);
			writer.Write(o.vectorValue.y);
			writer.Write(o.vectorValue.z);
			writer.Write(o.vectorValue.w);
			writer.Write(((Object)(object)o.textureValue == (Object)null) ? string.Empty : ((Object)o.textureValue).name);
			writer.Write((byte)o.targetStructures);
		}

		private static void WriteTextureSet(BinaryWriter writer, TextureSetManifest t)
		{
			writer.Write(t.name);
			writer.Write(((Object)(object)t.previewTexture != (Object)null) ? ((Object)t.previewTexture).name : "");
			writer.Write(t.textures?.Count ?? 0);
			if (t.textures != null)
			{
				foreach (TextureEntry texture in t.textures)
				{
					WriteTextureEntry(writer, texture);
				}
			}
			writer.Write((byte)t.targets);
		}

		private static void WriteTextureEntry(BinaryWriter writer, TextureEntry e)
		{
			writer.Write((byte)e.type);
			writer.Write(e.textures?.Count ?? 0);
			if (e.textures == null)
			{
				return;
			}
			foreach (Texture texture in e.textures)
			{
				writer.Write(((Object)(object)texture != (Object)null) ? ((Object)texture).name : string.Empty);
			}
		}

		public static SkinManifestBinary Read(byte[] bytes)
		{
			using (MemoryStream input = new MemoryStream(bytes))
			{
				using BinaryReader binaryReader = new BinaryReader(input);
				int num = binaryReader.ReadInt32();
				int num2 = num;
				if (num2 == 1)
				{
					return ReadV1Manifest(binaryReader);
				}
			}
			return null;
		}

		private static SkinManifestBinary ReadV1Manifest(BinaryReader reader)
		{
			SkinManifestBinary skinManifestBinary = new SkinManifestBinary();
			skinManifestBinary.skinName = reader.ReadString();
			skinManifestBinary.previewTextureName = reader.ReadString();
			skinManifestBinary.allowedInComp = reader.ReadBoolean();
			int num = reader.ReadInt32();
			skinManifestBinary.shaders = new ShaderManifestBinary[num];
			for (int i = 0; i < num; i++)
			{
				skinManifestBinary.shaders[i] = ReadShaderManifest(reader);
			}
			int num2 = reader.ReadInt32();
			skinManifestBinary.textures = new TextureSetBinary[num2];
			for (int j = 0; j < num2; j++)
			{
				skinManifestBinary.textures[j] = ReadTextureSet(reader);
			}
			return skinManifestBinary;
		}

		private static ShaderManifestBinary ReadShaderManifest(BinaryReader reader)
		{
			ShaderManifestBinary shaderManifestBinary = new ShaderManifestBinary();
			shaderManifestBinary.materialName = reader.ReadString();
			int num = reader.ReadInt32();
			shaderManifestBinary.overrides = new MaterialOverrideBinary[num];
			for (int i = 0; i < num; i++)
			{
				shaderManifestBinary.overrides[i] = ReadOverride(reader);
			}
			return shaderManifestBinary;
		}

		private static MaterialOverrideBinary ReadOverride(BinaryReader reader)
		{
			//IL_001a: 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_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			MaterialOverrideBinary materialOverrideBinary = new MaterialOverrideBinary();
			materialOverrideBinary.propertyName = reader.ReadString();
			materialOverrideBinary.type = (ShaderPropertyType)reader.ReadByte();
			float num = reader.ReadSingle();
			float num2 = reader.ReadSingle();
			float num3 = reader.ReadSingle();
			float num4 = reader.ReadSingle();
			materialOverrideBinary.colorValue = new Color(num, num2, num3, num4);
			materialOverrideBinary.floatValue = reader.ReadSingle();
			materialOverrideBinary.intValue = reader.ReadInt32();
			float num5 = reader.ReadSingle();
			float num6 = reader.ReadSingle();
			float num7 = reader.ReadSingle();
			float num8 = reader.ReadSingle();
			materialOverrideBinary.vectorValue = new Vector4(num5, num6, num7, num8);
			materialOverrideBinary.textureValue = reader.ReadString();
			materialOverrideBinary.targetStructures = (StructureFlags)reader.ReadByte();
			return materialOverrideBinary;
		}

		private static TextureSetBinary ReadTextureSet(BinaryReader reader)
		{
			TextureSetBinary textureSetBinary = new TextureSetBinary();
			textureSetBinary.name = reader.ReadString();
			textureSetBinary.previewTextureName = reader.ReadString();
			int num = reader.ReadInt32();
			textureSetBinary.textures = new TextureEntryBinary[num];
			for (int i = 0; i < num; i++)
			{
				textureSetBinary.textures[i] = ReadTextureEntry(reader);
			}
			textureSetBinary.targets = (StructureFlags)reader.ReadByte();
			return textureSetBinary;
		}

		private static TextureEntryBinary ReadTextureEntry(BinaryReader reader)
		{
			TextureEntryBinary textureEntryBinary = new TextureEntryBinary();
			textureEntryBinary.type = (TextureType)reader.ReadByte();
			int num = reader.ReadInt32();
			textureEntryBinary.textures = new string[num];
			for (int i = 0; i < num; i++)
			{
				textureEntryBinary.textures[i] = reader.ReadString();
			}
			return textureEntryBinary;
		}
	}
	public class MaterialOverrideBinary
	{
		public string propertyName;

		public ShaderPropertyType type;

		public float floatValue;

		public int intValue;

		public Color colorValue;

		public Vector4 vectorValue;

		public string textureValue;

		public StructureFlags targetStructures;

		public MaterialPropertyOverride GetOverrideFromBundle(AssetBundle bundle)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected I4, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: 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)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			MaterialPropertyOverride materialPropertyOverride = new MaterialPropertyOverride
			{
				propertyName = propertyName,
				propertyType = type,
				targetStructures = targetStructures
			};
			ShaderPropertyType val = type;
			ShaderPropertyType val2 = val;
			switch ((int)val2)
			{
			case 0:
				materialPropertyOverride.colorValue = colorValue;
				break;
			case 1:
				materialPropertyOverride.vectorValue = vectorValue;
				break;
			case 2:
			case 3:
				materialPropertyOverride.floatValue = floatValue;
				break;
			case 4:
				materialPropertyOverride.textureValue = GetTextureFromBundle(bundle);
				((Object)materialPropertyOverride.textureValue).hideFlags = (HideFlags)32;
				break;
			case 5:
				materialPropertyOverride.intValue = intValue;
				break;
			}
			return materialPropertyOverride;
		}

		public Texture GetTextureFromBundle(AssetBundle bundle)
		{
			if (string.IsNullOrEmpty(textureValue))
			{
				return null;
			}
			string text = ((IEnumerable<string>)bundle.GetAllAssetNames()).FirstOrDefault((string n) => n.EndsWith(textureValue, StringComparison.OrdinalIgnoreCase));
			if (text == null)
			{
				return null;
			}
			return bundle.LoadAsset<Texture>(text);
		}
	}
	public class ShaderManifestBinary
	{
		public string materialName;

		public MaterialOverrideBinary[] overrides;

		public ShaderManifest GetShaderManifestFromBundle(AssetBundle bundle)
		{
			ShaderManifest shaderManifest = new ShaderManifest();
			string text = ((IEnumerable<string>)bundle.GetAllAssetNames()).FirstOrDefault((string n) => n.EndsWith(materialName, StringComparison.OrdinalIgnoreCase));
			if (text == null)
			{
				return null;
			}
			Material val = bundle.LoadAsset<Material>(text);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			((Object)val).hideFlags = (HideFlags)32;
			shaderManifest.material = val;
			shaderManifest.overrides = new List<MaterialPropertyOverride>();
			MaterialOverrideBinary[] array = overrides;
			foreach (MaterialOverrideBinary materialOverrideBinary in array)
			{
				shaderManifest.overrides.Add(materialOverrideBinary.GetOverrideFromBundle(bundle));
			}
			return shaderManifest;
		}
	}
	[Serializable]
	public class SkinManifestBinary
	{
		public string skinName;

		public string previewTextureName;

		public bool allowedInComp;

		public ShaderManifestBinary[] shaders;

		public TextureSetBinary[] textures;

		public SkinManifest GetSkinManifestFromBundle(AssetBundle bundle)
		{
			SkinManifest manifest = ScriptableObject.CreateInstance<SkinManifest>();
			manifest.skinName = skinName;
			manifest.previewTexture = GetTextureFromBundle(bundle);
			manifest.allowedInComp = allowedInComp;
			manifest.shaders = GetShaderManifestListFromBundle(bundle);
			manifest.textures = textures.Select((TextureSetBinary t) => t.GetManifestFromBundle(bundle)).ToList();
			manifest.textures.ForEach(delegate(TextureSetManifest t)
			{
				if ((Object)(object)t.previewTexture == (Object)null)
				{
					t.previewTexture = manifest.previewTexture;
				}
			});
			return manifest;
		}

		public List<ShaderManifest> GetShaderManifestListFromBundle(AssetBundle bundle)
		{
			List<ShaderManifest> list = new List<ShaderManifest>();
			ShaderManifestBinary[] array = shaders;
			foreach (ShaderManifestBinary shaderManifestBinary in array)
			{
				list.Add(shaderManifestBinary.GetShaderManifestFromBundle(bundle));
			}
			return list;
		}

		public Texture GetTextureFromBundle(AssetBundle bundle)
		{
			string text = ((IEnumerable<string>)bundle.GetAllAssetNames()).FirstOrDefault((string n) => n.EndsWith(previewTextureName, StringComparison.OrdinalIgnoreCase));
			if (text == null)
			{
				return null;
			}
			Texture val = bundle.LoadAsset<Texture>(text);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			((Object)val).hideFlags = (HideFlags)61;
			return val;
		}
	}
	[Serializable]
	public class MaterialOverrideBinaryArray
	{
		public MaterialOverrideBinary[] overrides;

		public MaterialPropertyOverrideManifest GetOverrideManifestFromBundle(AssetBundle bundle)
		{
			return new MaterialPropertyOverrideManifest
			{
				overrides = overrides.Select((MaterialOverrideBinary ob) => ob.GetOverrideFromBundle(bundle)).ToList()
			};
		}
	}
	public class TextureSetBinary
	{
		public string name;

		public string previewTextureName;

		public TextureEntryBinary[] textures;

		public StructureFlags targets;

		public TextureSetManifest GetManifestFromBundle(AssetBundle bundle)
		{
			TextureSetManifest textureSetManifest = new TextureSetManifest
			{
				name = name,
				previewTexture = GetPreviewTextureFromBundle(bundle),
				targets = targets,
				textures = new List<TextureEntry>()
			};
			TextureEntryBinary[] array = textures;
			foreach (TextureEntryBinary textureEntryBinary in array)
			{
				TextureEntry textureEntry = new TextureEntry
				{
					type = textureEntryBinary.type,
					textures = new List<Texture>()
				};
				string[] array2 = textureEntryBinary.textures;
				foreach (string assetName in array2)
				{
					if (string.IsNullOrEmpty(assetName))
					{
						continue;
					}
					string text = ((IEnumerable<string>)bundle.GetAllAssetNames()).FirstOrDefault((string n) => n.EndsWith(assetName, StringComparison.OrdinalIgnoreCase));
					if (text != null)
					{
						Texture val = bundle.LoadAsset<Texture>(text);
						if ((Object)(object)val != (Object)null)
						{
							textureEntry.textures.Add(val);
						}
					}
				}
				textureSetManifest.textures.Add(textureEntry);
			}
			return textureSetManifest;
		}

		public Texture GetPreviewTextureFromBundle(AssetBundle bundle)
		{
			string text = ((IEnumerable<string>)bundle.GetAllAssetNames()).FirstOrDefault((string n) => n.EndsWith(previewTextureName, StringComparison.OrdinalIgnoreCase));
			if (text == null)
			{
				return null;
			}
			Texture val = bundle.LoadAsset<Texture>(text);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			((Object)val).hideFlags = (HideFlags)61;
			return val;
		}
	}
	public class TextureEntryBinary
	{
		public TextureType type;

		public string[] textures;
	}
}