using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using GaiaCommon1;
using UnityEngine;

namespace Gaia
{
	public class GaiaUtils : MonoBehaviour
	{
		public static string GetGaiaAssetDirectory()
		{
			return Path.Combine(Application.dataPath, GaiaConstants.AssetDir).Replace('\\', '/');
		}

		public static string GetGaiaAssetDirectory(GaiaConstants.FeatureType featureType)
		{
			return Path.Combine(Path.Combine(Application.dataPath, GaiaConstants.AssetDir), featureType.ToString()).Replace('\\', '/');
		}

		public static List<string> GetGaiaStampsList(GaiaConstants.FeatureType featureType)
		{
			return new List<string>(Directory.GetFiles(GetGaiaAssetDirectory(featureType), "*.jpg"));
		}

		public static string GetGaiaAssetPath(GaiaConstants.FeatureType featureType, string assetName)
		{
			GetGaiaAssetDirectory(featureType);
			return Path.Combine(GetGaiaAssetDirectory(featureType), assetName).Replace('\\', '/');
		}

		public static string GetGaiaStampAssetPath(GaiaConstants.FeatureType featureType, string assetName)
		{
			GetGaiaAssetDirectory(featureType);
			return Path.Combine(Path.Combine(GetGaiaAssetDirectory(featureType), "Data"), assetName).Replace('\\', '/');
		}

		public static string GetGaiaStampPath(Texture2D source)
		{
			return Path.ChangeExtension(Path.Combine(path2: Path.GetFileName(""), path1: Path.Combine(Path.GetDirectoryName(""), "Data")), ".bytes").Replace('\\', '/');
		}

		public static bool CheckValidGaiaStampPath(Texture2D source)
		{
			string path = "";
			if (Path.GetExtension(path).ToLower() != ".jpg")
			{
				return false;
			}
			string fileName = Path.GetFileName(path);
			path = Path.Combine(Path.GetDirectoryName(path), "Data");
			path = Path.Combine(path, fileName);
			path = Path.ChangeExtension(path, ".bytes");
			path = path.Replace('\\', '/');
			if (File.Exists(path))
			{
				return true;
			}
			return false;
		}

		public static void CreateGaiaAssetDirectories()
		{
		}

		public static T[] GetAtPath<T>(string path)
		{
			ArrayList arrayList = new ArrayList();
			T[] array = new T[arrayList.Count];
			for (int i = 0; i < arrayList.Count; i++)
			{
				array[i] = (T)arrayList[i];
			}
			return array;
		}

		public static void CreateAsset<T>() where T : ScriptableObject
		{
		}

		public static string GetAssetPath(UnityEngine.Object uo)
		{
			return "";
		}

		public static string WrapScriptableObject(ScriptableObject so)
		{
			return "";
		}

		public static void UnwrapScriptableObject(string path, string newpath)
		{
		}

		public static string WrapGameObjectAsPrefab(GameObject go)
		{
			return "";
		}

		public static string GetAssetPath(string fileName)
		{
			return "";
		}

		public static string GetAssetPath(string name, string type)
		{
			return "";
		}

		public static UnityEngine.Object GetAsset(string fileNameOrPath, Type assetType)
		{
			return null;
		}

		public static GameObject GetAssetPrefab(string name)
		{
			return null;
		}

		public static ScriptableObject GetAssetScriptableObject(string name)
		{
			return null;
		}

		public static Texture2D GetAssetTexture2D(string name)
		{
			return null;
		}

		public static void MakeTextureNormal(Texture2D texture)
		{
			_ = texture == null;
		}

		public static void MakeTextureReadable(Texture2D texture)
		{
			_ = texture == null;
		}

		public static void MakeTextureUncompressed(Texture2D texture)
		{
			_ = texture == null;
		}

		public static void CompressToSingleChannelFileImage(float[,] input, string imageName, TextureFormat imageStorageFormat = TextureFormat.RGBA32, bool exportPNG = true, bool exportJPG = true)
		{
			int length = input.GetLength(0);
			int length2 = input.GetLength(1);
			Texture2D texture2D = new Texture2D(length, length2, imageStorageFormat, mipChain: false);
			Color color = default(Color);
			color.a = 1f;
			color.r = (color.g = (color.b = 0f));
			for (int i = 0; i < length; i++)
			{
				for (int j = 0; j < length2; j++)
				{
					color.r = (color.b = (color.g = input[i, j]));
					texture2D.SetPixel(i, j, color);
				}
			}
			texture2D.Apply();
			if (exportJPG)
			{
				ExportJPG(imageName, texture2D);
			}
			if (exportPNG)
			{
				ExportPNG(imageName, texture2D);
			}
			UnityEngine.Object.DestroyImmediate(texture2D);
		}

		public static void CompressToMultiChannelFileImage(float[,,] input, string imageName, TextureFormat imageStorageFormat = TextureFormat.RGBA32, bool exportPNG = true, bool exportJPG = true)
		{
			int length = input.GetLength(0);
			int length2 = input.GetLength(1);
			int length3 = input.GetLength(2);
			int num = (length3 + 3) / 4;
			for (int i = 0; i < num; i++)
			{
				Texture2D texture2D = new Texture2D(length, length, imageStorageFormat, mipChain: false);
				Color color = default(Color);
				int num2 = i * 4;
				for (int j = 0; j < length; j++)
				{
					for (int k = 0; k < length2; k++)
					{
						color.r = ((num2 < length3) ? input[j, k, num2] : 0f);
						color.g = ((num2 + 1 < length3) ? input[j, k, num2 + 1] : 0f);
						color.b = ((num2 + 2 < length3) ? input[j, k, num2 + 2] : 0f);
						color.a = ((num2 + 3 < length3) ? input[j, k, num2 + 3] : 0f);
						texture2D.SetPixel(j, k, color);
					}
				}
				texture2D.Apply();
				if (exportJPG)
				{
					byte[] bytes = texture2D.EncodeToJPG();
					GaiaCommon1.Utils.WriteAllBytes(imageName + i + ".jpg", bytes);
				}
				if (exportPNG)
				{
					byte[] bytes2 = texture2D.EncodeToPNG();
					GaiaCommon1.Utils.WriteAllBytes(imageName + i + ".png", bytes2);
				}
				UnityEngine.Object.DestroyImmediate(texture2D);
			}
		}

		public static void CompressToMultiChannelFileImage(string imageName, HeightMap r, HeightMap g, HeightMap b, HeightMap a, TextureFormat imageStorageFormat, GaiaConstants.ImageFileType imageFileType)
		{
			int num = 0;
			int num2 = 0;
			if (r != null)
			{
				num = r.Width();
				num2 = r.Depth();
			}
			else if (g != null)
			{
				num = g.Width();
				num2 = g.Depth();
			}
			else if (b != null)
			{
				num = b.Width();
				num2 = b.Depth();
			}
			else if (a != null)
			{
				num = a.Width();
				num2 = a.Depth();
			}
			if (string.IsNullOrEmpty(imageName))
			{
				Debug.LogError("Cannot write image - no name supplied!");
				return;
			}
			if (num == 0 || num2 == 0)
			{
				Debug.LogError("Cannot write image - invalid dimensions : " + num + ", " + num2);
				return;
			}
			Texture2D texture2D = new Texture2D(num, num2, imageStorageFormat, mipChain: true, linear: false);
			Color color = default(Color);
			for (int i = 0; i < num; i++)
			{
				for (int j = 0; j < num2; j++)
				{
					color.r = r?[i, j] ?? 0f;
					color.g = g?[i, j] ?? 0f;
					color.b = b?[i, j] ?? 0f;
					color.a = a?[i, j] ?? 1f;
					texture2D.SetPixel(i, j, color);
				}
			}
			texture2D.Apply();
			switch (imageFileType)
			{
			case GaiaConstants.ImageFileType.Jpg:
			{
				byte[] bytes3 = texture2D.EncodeToJPG(100);
				GaiaCommon1.Utils.WriteAllBytes(imageName + ".jpg", bytes3);
				break;
			}
			case GaiaConstants.ImageFileType.Png:
			{
				byte[] bytes2 = texture2D.EncodeToPNG();
				GaiaCommon1.Utils.WriteAllBytes(imageName + ".png", bytes2);
				break;
			}
			case GaiaConstants.ImageFileType.Exr:
			{
				byte[] bytes = texture2D.EncodeToEXR(Texture2D.EXRFlags.CompressZIP);
				GaiaCommon1.Utils.WriteAllBytes(imageName + ".exr", bytes);
				break;
			}
			}
			UnityEngine.Object.DestroyImmediate(texture2D);
		}

		public static float[,] ConvertTextureToArray(Texture2D texture)
		{
			float[,] array = new float[texture.width, texture.height];
			for (int i = 0; i < texture.width; i++)
			{
				for (int j = 0; j < texture.height; j++)
				{
					array[i, j] = texture.GetPixel(i, j).grayscale;
				}
			}
			return array;
		}

		public static float[,] DecompressFromSingleChannelFileImage(string fileName, int width, int height, TextureFormat imageStorageFormat = TextureFormat.RGBA32, bool channelR = true, bool channelG = false, bool channelB = false, bool channelA = false)
		{
			float[,] array = null;
			if (File.Exists(fileName))
			{
				byte[] data = GaiaCommon1.Utils.ReadAllBytes(fileName);
				Texture2D texture2D = new Texture2D(width, height, imageStorageFormat, mipChain: false);
				texture2D.LoadImage(data);
				array = new float[width, height];
				for (int i = 0; i < width; i++)
				{
					for (int j = 0; j < height; j++)
					{
						array[i, j] = texture2D.GetPixel(i, j).r;
					}
				}
				UnityEngine.Object.DestroyImmediate(texture2D);
			}
			else
			{
				Debug.LogError("Unable to find " + fileName);
			}
			return array;
		}

		public static float[,] DecompressFromSingleChannelTexture(Texture2D importTexture, bool channelR = true, bool channelG = false, bool channelB = false, bool channelA = false)
		{
			if (importTexture == null || importTexture.width <= 0 || importTexture.height <= 0)
			{
				Debug.LogError("Unable to import from texture");
				return null;
			}
			float[,] array = new float[importTexture.width, importTexture.height];
			if (channelR)
			{
				for (int i = 0; i < importTexture.width; i++)
				{
					for (int j = 0; j < importTexture.height; j++)
					{
						array[i, j] = importTexture.GetPixel(i, j).r;
					}
				}
			}
			else if (channelG)
			{
				for (int k = 0; k < importTexture.width; k++)
				{
					for (int l = 0; l < importTexture.height; l++)
					{
						array[k, l] = importTexture.GetPixel(k, l).g;
					}
				}
			}
			else if (channelB)
			{
				for (int m = 0; m < importTexture.width; m++)
				{
					for (int n = 0; n < importTexture.height; n++)
					{
						array[m, n] = importTexture.GetPixel(m, n).b;
					}
				}
			}
			if (channelA)
			{
				for (int num = 0; num < importTexture.width; num++)
				{
					for (int num2 = 0; num2 < importTexture.height; num2++)
					{
						array[num, num2] = importTexture.GetPixel(num, num2).a;
					}
				}
			}
			return array;
		}

		public static void ExportJPG(string fileName, Texture2D texture)
		{
			byte[] bytes = texture.EncodeToJPG();
			GaiaCommon1.Utils.WriteAllBytes(fileName + ".jpg", bytes);
		}

		public static void ExportPNG(string fileName, Texture2D texture)
		{
			byte[] bytes = texture.EncodeToPNG();
			GaiaCommon1.Utils.WriteAllBytes(fileName + ".png", bytes);
		}

		public static float[,] LoadRawFile(string fileName)
		{
			if (!File.Exists(fileName))
			{
				Debug.LogError("Could not locate heightmap file : " + fileName);
				return null;
			}
			float[,] array = null;
			using FileStream fileStream = File.OpenRead(fileName);
			using (BinaryReader binaryReader = new BinaryReader(fileStream))
			{
				int num = Mathf.CeilToInt(Mathf.Sqrt(fileStream.Length / 2));
				array = new float[num, num];
				for (int i = 0; i < num; i++)
				{
					for (int j = 0; j < num; j++)
					{
						array[i, j] = (float)(int)binaryReader.ReadUInt16() / 65535f;
					}
				}
			}
			fileStream.Close();
			return array;
		}

		public static Mesh CreateMesh(float[,] heightmap, Vector3 targetSize)
		{
			int length = heightmap.GetLength(0);
			int length2 = heightmap.GetLength(1);
			int num = 1;
			Vector3 vector = Vector3.zero - targetSize / 2f;
			Vector2 b = new Vector2(1f / (float)(length - 1), 1f / (float)(length2 - 1));
			for (num = 1; num < 100 && length / num * (length2 / num) >= 65000; num++)
			{
			}
			targetSize = new Vector3(targetSize.x / (float)(length - 1) * (float)num, targetSize.y, targetSize.z / (float)(length2 - 1) * (float)num);
			length = (length - 1) / num + 1;
			length2 = (length2 - 1) / num + 1;
			Vector3[] array = new Vector3[length * length2];
			Vector2[] array2 = new Vector2[length * length2];
			Vector3[] array3 = new Vector3[length * length2];
			Color[] array4 = new Color[length * length2];
			int[] array5 = new int[(length - 1) * (length2 - 1) * 6];
			for (int i = 0; i < length2; i++)
			{
				for (int j = 0; j < length; j++)
				{
					array4[i * length + j] = Color.black;
					array3[i * length + j] = Vector3.up;
					array[i * length + j] = Vector3.Scale(targetSize, new Vector3(j, heightmap[j * num, i * num], i)) + vector;
					array2[i * length + j] = Vector2.Scale(new Vector2(j * num, i * num), b);
				}
			}
			int num2 = 0;
			for (int k = 0; k < length2 - 1; k++)
			{
				for (int l = 0; l < length - 1; l++)
				{
					array5[num2++] = k * length + l;
					array5[num2++] = (k + 1) * length + l;
					array5[num2++] = k * length + l + 1;
					array5[num2++] = (k + 1) * length + l;
					array5[num2++] = (k + 1) * length + l + 1;
					array5[num2++] = k * length + l + 1;
				}
			}
			Mesh mesh = new Mesh();
			mesh.vertices = array;
			mesh.colors = array4;
			mesh.normals = array3;
			mesh.uv = array2;
			mesh.triangles = array5;
			mesh.RecalculateBounds();
			mesh.RecalculateNormals();
			return mesh;
		}

		public static Bounds GetBounds(GameObject go)
		{
			Bounds result = new Bounds(go.transform.position, Vector3.zero);
			Renderer[] componentsInChildren = go.GetComponentsInChildren<Renderer>();
			foreach (Renderer renderer in componentsInChildren)
			{
				result.Encapsulate(renderer.bounds);
			}
			Collider[] componentsInChildren2 = go.GetComponentsInChildren<Collider>();
			foreach (Collider collider in componentsInChildren2)
			{
				result.Encapsulate(collider.bounds);
			}
			return result;
		}

		private Vector3 Rotate90LeftXAxis(Vector3 input)
		{
			return new Vector3(input.x, 0f - input.z, input.y);
		}

		private Vector3 Rotate90RightXAxis(Vector3 input)
		{
			return new Vector3(input.x, input.z, 0f - input.y);
		}

		private Vector3 Rotate90LeftYAxis(Vector3 input)
		{
			return new Vector3(0f - input.z, input.y, input.x);
		}

		private Vector3 Rotate90RightYAxis(Vector3 input)
		{
			return new Vector3(input.z, input.y, 0f - input.x);
		}

		private Vector3 Rotate90LeftZAxis(Vector3 input)
		{
			return new Vector3(input.y, 0f - input.x, input.z);
		}

		private Vector3 Rotate90RightZAxis(Vector3 input)
		{
			return new Vector3(0f - input.y, input.x, input.z);
		}

		public static bool Math_ApproximatelyEqual(float a, float b, float threshold)
		{
			if (a == b || Mathf.Abs(a - b) < threshold)
			{
				return true;
			}
			return false;
		}

		public static bool Math_ApproximatelyEqual(float a, float b)
		{
			return Math_ApproximatelyEqual(a, b, float.Epsilon);
		}

		public static bool Math_IsPowerOf2(int value)
		{
			return (value & (value - 1)) == 0;
		}

		public static float Math_Clamp(float min, float max, float value)
		{
			if (value < min)
			{
				return min;
			}
			if (value > max)
			{
				return max;
			}
			return value;
		}

		public static float Math_Modulo(float value, float mod)
		{
			return value - mod * (float)Math.Floor(value / mod);
		}

		public static int Math_Modulo(int value, int mod)
		{
			return (int)((float)value - (float)mod * (float)Math.Floor((float)value / (float)mod));
		}

		public static float Math_InterpolateLinear(float value1, float value2, float fraction)
		{
			return value1 * (1f - fraction) + value2 * fraction;
		}

		public static float Math_InterpolateSmooth(float value1, float value2, float fraction)
		{
			fraction = ((!(fraction < 0.5f)) ? (1f - 2f * (fraction - 1f) * (fraction - 1f)) : (2f * fraction * fraction));
			return value1 * (1f - fraction) + value2 * fraction;
		}

		public static float Math_Distance(float x1, float y1, float x2, float y2)
		{
			return Mathf.Sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
		}

		public static float Math_InterpolateSmooth2(float v1, float v2, float fraction)
		{
			float num = fraction * fraction;
			fraction = 3f * num - 2f * fraction * num;
			return v1 * (1f - fraction) + v2 * fraction;
		}

		public static float Math_InterpolateCubic(float v0, float v1, float v2, float v3, float fraction)
		{
			float num = v3 - v2 - (v0 - v1);
			float num2 = v0 - v1 - num;
			float num3 = v2 - v0;
			float num4 = fraction * fraction;
			return num * fraction * num4 + num2 * num4 + num3 * fraction + v1;
		}

		public static Vector3 RotatePointAroundPivot(Vector3 point, Vector3 pivot, Vector3 angle)
		{
			Vector3 vector = point - pivot;
			vector = Quaternion.Euler(angle) * vector;
			point = vector + pivot;
			return point;
		}

		public static GaiaSettings GetGaiaSettings()
		{
			return GetAsset("GaiaSettings.asset", typeof(GaiaSettings)) as GaiaSettings;
		}
	}
}