using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using TriangleNet.Geometry;
using TriangleNet.Log;

namespace TriangleNet.IO
{
	// Token: 0x0200002A RID: 42
	public static class FileReader
	{
		// Token: 0x06000154 RID: 340 RVA: 0x000171D4 File Offset: 0x000153D4
		private static bool TryReadLine(StreamReader reader, out string[] token)
		{
			token = null;
			if (reader.EndOfStream)
			{
				return false;
			}
			string text = reader.ReadLine().Trim();
			while (string.IsNullOrEmpty(text.Trim()) || text.StartsWith("#"))
			{
				if (reader.EndOfStream)
				{
					return false;
				}
				text = reader.ReadLine().Trim();
			}
			token = text.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
			return true;
		}

		// Token: 0x06000155 RID: 341 RVA: 0x00017248 File Offset: 0x00015448
		private static void ReadVertex(InputGeometry data, int index, string[] line, int attributes, int marks)
		{
			double num = double.Parse(line[1], FileReader.nfi);
			double num2 = double.Parse(line[2], FileReader.nfi);
			int num3 = 0;
			double[] array = ((attributes == 0) ? null : new double[attributes]);
			for (int i = 0; i < attributes; i++)
			{
				if (line.Length > 3 + i)
				{
					array[i] = double.Parse(line[3 + i], FileReader.nfi);
				}
			}
			if (marks > 0 && line.Length > 3 + attributes)
			{
				num3 = int.Parse(line[3 + attributes]);
			}
			data.AddPoint(num, num2, num3, array);
		}

		// Token: 0x06000156 RID: 342 RVA: 0x000172D0 File Offset: 0x000154D0
		public static void Read(string filename, out InputGeometry geometry)
		{
			geometry = null;
			string text = Path.ChangeExtension(filename, ".poly");
			if (File.Exists(text))
			{
				geometry = FileReader.ReadPolyFile(text);
				return;
			}
			text = Path.ChangeExtension(filename, ".node");
			geometry = FileReader.ReadNodeFile(text);
		}

		// Token: 0x06000157 RID: 343 RVA: 0x00017314 File Offset: 0x00015514
		public static void Read(string filename, out InputGeometry geometry, out List<ITriangle> triangles)
		{
			triangles = null;
			FileReader.Read(filename, out geometry);
			string text = Path.ChangeExtension(filename, ".ele");
			if (File.Exists(text) && geometry != null)
			{
				triangles = FileReader.ReadEleFile(text);
			}
		}

		// Token: 0x06000158 RID: 344 RVA: 0x0001734C File Offset: 0x0001554C
		public static InputGeometry Read(string filename)
		{
			InputGeometry inputGeometry = null;
			FileReader.Read(filename, out inputGeometry);
			return inputGeometry;
		}

		// Token: 0x06000159 RID: 345 RVA: 0x00017364 File Offset: 0x00015564
		public static InputGeometry ReadNodeFile(string nodefilename)
		{
			return FileReader.ReadNodeFile(nodefilename, false);
		}

		// Token: 0x0600015A RID: 346 RVA: 0x00017370 File Offset: 0x00015570
		public static InputGeometry ReadNodeFile(string nodefilename, bool readElements)
		{
			FileReader.startIndex = 0;
			int num = 0;
			int num2 = 0;
			InputGeometry inputGeometry;
			using (StreamReader streamReader = new StreamReader(nodefilename))
			{
				string[] array;
				if (!FileReader.TryReadLine(streamReader, out array))
				{
					throw new Exception("Can't read input file.");
				}
				int num3 = int.Parse(array[0]);
				if (num3 < 3)
				{
					throw new Exception("Input must have at least three input vertices.");
				}
				if (array.Length > 1 && int.Parse(array[1]) != 2)
				{
					throw new Exception("Triangle only works with two-dimensional meshes.");
				}
				if (array.Length > 2)
				{
					num = int.Parse(array[2]);
				}
				if (array.Length > 3)
				{
					num2 = int.Parse(array[3]);
				}
				inputGeometry = new InputGeometry(num3);
				if (num3 > 0)
				{
					for (int i = 0; i < num3; i++)
					{
						if (!FileReader.TryReadLine(streamReader, out array))
						{
							throw new Exception("Can't read input file (vertices).");
						}
						if (array.Length < 3)
						{
							throw new Exception("Invalid vertex.");
						}
						if (i == 0)
						{
							FileReader.startIndex = int.Parse(array[0], FileReader.nfi);
						}
						FileReader.ReadVertex(inputGeometry, i, array, num, num2);
					}
				}
			}
			if (readElements)
			{
				string text = Path.ChangeExtension(nodefilename, ".ele");
				if (File.Exists(text))
				{
					FileReader.ReadEleFile(text, true);
				}
			}
			return inputGeometry;
		}

		// Token: 0x0600015B RID: 347 RVA: 0x000174A0 File Offset: 0x000156A0
		public static InputGeometry ReadPolyFile(string polyfilename)
		{
			return FileReader.ReadPolyFile(polyfilename, false, false);
		}

		// Token: 0x0600015C RID: 348 RVA: 0x000174AA File Offset: 0x000156AA
		public static InputGeometry ReadPolyFile(string polyfilename, bool readElements)
		{
			return FileReader.ReadPolyFile(polyfilename, readElements, false);
		}

		// Token: 0x0600015D RID: 349 RVA: 0x000174B4 File Offset: 0x000156B4
		public static InputGeometry ReadPolyFile(string polyfilename, bool readElements, bool readArea)
		{
			FileReader.startIndex = 0;
			int num = 0;
			int num2 = 0;
			InputGeometry inputGeometry;
			using (StreamReader streamReader = new StreamReader(polyfilename))
			{
				string[] array;
				if (!FileReader.TryReadLine(streamReader, out array))
				{
					throw new Exception("Can't read input file.");
				}
				int num3 = int.Parse(array[0]);
				if (array.Length > 1 && int.Parse(array[1]) != 2)
				{
					throw new Exception("Triangle only works with two-dimensional meshes.");
				}
				if (array.Length > 2)
				{
					num = int.Parse(array[2]);
				}
				if (array.Length > 3)
				{
					num2 = int.Parse(array[3]);
				}
				if (num3 > 0)
				{
					inputGeometry = new InputGeometry(num3);
					for (int i = 0; i < num3; i++)
					{
						if (!FileReader.TryReadLine(streamReader, out array))
						{
							throw new Exception("Can't read input file (vertices).");
						}
						if (array.Length < 3)
						{
							throw new Exception("Invalid vertex.");
						}
						if (i == 0)
						{
							FileReader.startIndex = int.Parse(array[0], FileReader.nfi);
						}
						FileReader.ReadVertex(inputGeometry, i, array, num, num2);
					}
				}
				else
				{
					inputGeometry = FileReader.ReadNodeFile(Path.ChangeExtension(polyfilename, ".node"));
					num3 = inputGeometry.Count;
				}
				if (inputGeometry.Points == null)
				{
					throw new Exception("No nodes available.");
				}
				if (!FileReader.TryReadLine(streamReader, out array))
				{
					throw new Exception("Can't read input file (segments).");
				}
				int num4 = int.Parse(array[0]);
				int num5 = 0;
				if (array.Length > 1)
				{
					num5 = int.Parse(array[1]);
				}
				for (int j = 0; j < num4; j++)
				{
					if (!FileReader.TryReadLine(streamReader, out array))
					{
						throw new Exception("Can't read input file (segments).");
					}
					if (array.Length < 3)
					{
						throw new Exception("Segment has no endpoints.");
					}
					int num6 = int.Parse(array[1]) - FileReader.startIndex;
					int num7 = int.Parse(array[2]) - FileReader.startIndex;
					int num8 = 0;
					if (num5 > 0 && array.Length > 3)
					{
						num8 = int.Parse(array[3]);
					}
					if (num6 < 0 || num6 >= num3)
					{
						if (Behavior.Verbose)
						{
							SimpleLog.Instance.Warning("Invalid first endpoint of segment.", "MeshReader.ReadPolyfile()");
						}
					}
					else if (num7 < 0 || num7 >= num3)
					{
						if (Behavior.Verbose)
						{
							SimpleLog.Instance.Warning("Invalid second endpoint of segment.", "MeshReader.ReadPolyfile()");
						}
					}
					else
					{
						inputGeometry.AddSegment(num6, num7, num8);
					}
				}
				if (!FileReader.TryReadLine(streamReader, out array))
				{
					throw new Exception("Can't read input file (holes).");
				}
				int num9 = int.Parse(array[0]);
				if (num9 > 0)
				{
					for (int k = 0; k < num9; k++)
					{
						if (!FileReader.TryReadLine(streamReader, out array))
						{
							throw new Exception("Can't read input file (holes).");
						}
						if (array.Length < 3)
						{
							throw new Exception("Invalid hole.");
						}
						inputGeometry.AddHole(double.Parse(array[1], FileReader.nfi), double.Parse(array[2], FileReader.nfi));
					}
				}
				if (FileReader.TryReadLine(streamReader, out array))
				{
					int num10 = int.Parse(array[0]);
					if (num10 > 0)
					{
						for (int l = 0; l < num10; l++)
						{
							if (!FileReader.TryReadLine(streamReader, out array))
							{
								throw new Exception("Can't read input file (region).");
							}
							if (array.Length < 4)
							{
								throw new Exception("Invalid region attributes.");
							}
							inputGeometry.AddRegion(double.Parse(array[1], FileReader.nfi), double.Parse(array[2], FileReader.nfi), int.Parse(array[3]));
						}
					}
				}
			}
			if (readElements)
			{
				string text = Path.ChangeExtension(polyfilename, ".ele");
				if (File.Exists(text))
				{
					FileReader.ReadEleFile(text, readArea);
				}
			}
			return inputGeometry;
		}

		// Token: 0x0600015E RID: 350 RVA: 0x00017808 File Offset: 0x00015A08
		public static List<ITriangle> ReadEleFile(string elefilename)
		{
			return FileReader.ReadEleFile(elefilename, false);
		}

		// Token: 0x0600015F RID: 351 RVA: 0x00017814 File Offset: 0x00015A14
		private static List<ITriangle> ReadEleFile(string elefilename, bool readArea)
		{
			int num = 0;
			List<ITriangle> list;
			using (StreamReader streamReader = new StreamReader(elefilename))
			{
				bool flag = false;
				string[] array;
				if (!FileReader.TryReadLine(streamReader, out array))
				{
					throw new Exception("Can't read input file (elements).");
				}
				num = int.Parse(array[0]);
				int num2 = 0;
				if (array.Length > 2)
				{
					num2 = int.Parse(array[2]);
					flag = true;
				}
				if (num2 > 1)
				{
					SimpleLog.Instance.Warning("Triangle attributes not supported.", "FileReader.Read");
				}
				list = new List<ITriangle>(num);
				for (int i = 0; i < num; i++)
				{
					if (!FileReader.TryReadLine(streamReader, out array))
					{
						throw new Exception("Can't read input file (elements).");
					}
					if (array.Length < 4)
					{
						throw new Exception("Triangle has no nodes.");
					}
					InputTriangle inputTriangle = new InputTriangle(int.Parse(array[1]) - FileReader.startIndex, int.Parse(array[2]) - FileReader.startIndex, int.Parse(array[3]) - FileReader.startIndex);
					if (num2 > 0 && flag)
					{
						int num3 = 0;
						flag = int.TryParse(array[4], out num3);
						inputTriangle.region = num3;
					}
					list.Add(inputTriangle);
				}
			}
			if (readArea)
			{
				string text = Path.ChangeExtension(elefilename, ".area");
				if (File.Exists(text))
				{
					FileReader.ReadAreaFile(text, num);
				}
			}
			return list;
		}

		// Token: 0x06000160 RID: 352 RVA: 0x00017960 File Offset: 0x00015B60
		private static double[] ReadAreaFile(string areafilename, int intriangles)
		{
			double[] array = null;
			using (StreamReader streamReader = new StreamReader(areafilename))
			{
				string[] array2;
				if (!FileReader.TryReadLine(streamReader, out array2))
				{
					throw new Exception("Can't read input file (area).");
				}
				if (int.Parse(array2[0]) != intriangles)
				{
					SimpleLog.Instance.Warning("Number of area constraints doesn't match number of triangles.", "ReadAreaFile()");
					return null;
				}
				array = new double[intriangles];
				for (int i = 0; i < intriangles; i++)
				{
					if (!FileReader.TryReadLine(streamReader, out array2))
					{
						throw new Exception("Can't read input file (area).");
					}
					if (array2.Length != 2)
					{
						throw new Exception("Triangle has no nodes.");
					}
					array[i] = double.Parse(array2[1], FileReader.nfi);
				}
			}
			return array;
		}

		// Token: 0x06000161 RID: 353 RVA: 0x00017A1C File Offset: 0x00015C1C
		public static List<Edge> ReadEdgeFile(string edgeFile, int invertices)
		{
			List<Edge> list = null;
			FileReader.startIndex = 0;
			using (StreamReader streamReader = new StreamReader(edgeFile))
			{
				string[] array;
				if (!FileReader.TryReadLine(streamReader, out array))
				{
					throw new Exception("Can't read input file (segments).");
				}
				int num = int.Parse(array[0]);
				int num2 = 0;
				if (array.Length > 1)
				{
					num2 = int.Parse(array[1]);
				}
				if (num > 0)
				{
					list = new List<Edge>(num);
				}
				for (int i = 0; i < num; i++)
				{
					if (!FileReader.TryReadLine(streamReader, out array))
					{
						throw new Exception("Can't read input file (segments).");
					}
					if (array.Length < 3)
					{
						throw new Exception("Segment has no endpoints.");
					}
					int num3 = int.Parse(array[1]) - FileReader.startIndex;
					int num4 = int.Parse(array[2]) - FileReader.startIndex;
					int num5 = 0;
					if (num2 > 0 && array.Length > 3)
					{
						num5 = int.Parse(array[3]);
					}
					if (num3 < 0 || num3 >= invertices)
					{
						if (Behavior.Verbose)
						{
							SimpleLog.Instance.Warning("Invalid first endpoint of segment.", "MeshReader.ReadPolyfile()");
						}
					}
					else if (num4 < 0 || num4 >= invertices)
					{
						if (Behavior.Verbose)
						{
							SimpleLog.Instance.Warning("Invalid second endpoint of segment.", "MeshReader.ReadPolyfile()");
						}
					}
					else
					{
						list.Add(new Edge(num3, num4, num5));
					}
				}
			}
			return list;
		}

		// Token: 0x040000EC RID: 236
		private static NumberFormatInfo nfi = CultureInfo.InvariantCulture.NumberFormat;

		// Token: 0x040000ED RID: 237
		private static int startIndex = 0;
	}
}