using System;
using System.Collections.Generic;
using System.Linq;
using ProBuilder2.Common;

namespace ProBuilder2.MeshOperations
{
	// Token: 0x02000003 RID: 3
	public class pbMeshUtils
	{
		// Token: 0x06000017 RID: 23 RVA: 0x00004A30 File Offset: 0x00002E30
		public static List<pb_Face> GetNeighborFaces(pb_Object pb, pb_Face originFace, Dictionary<int, int> lookup = null, IEnumerable<pb_Face> mask = null)
		{
			if (lookup == null)
			{
				lookup = pb.sharedIndices.ToDictionary();
			}
			List<pb_Face> list = new List<pb_Face>();
			HashSet<pb_Edge> hashSet = new HashSet<pb_Edge>();
			for (int i = 0; i < originFace.edges.Length; i++)
			{
				hashSet.Add(new pb_Edge(lookup[originFace.edges[i].x], lookup[originFace.edges[i].y]));
			}
			pb_Edge pb_Edge = new pb_Edge(-1, -1);
			for (int j = 0; j < pb.faces.Length; j++)
			{
				foreach (pb_Edge pb_Edge2 in pb.faces[j].edges)
				{
					pb_Edge.x = lookup[pb_Edge2.x];
					pb_Edge.y = lookup[pb_Edge2.y];
					bool flag = hashSet.Contains(pb_Edge);
					if (flag && (mask == null || !mask.Contains(pb.faces[j])))
					{
						list.Add(pb.faces[j]);
						break;
					}
				}
			}
			return list;
		}

		// Token: 0x06000018 RID: 24 RVA: 0x00004B64 File Offset: 0x00002F64
		public static Dictionary<pb_Face, List<pb_Face>> GenerateNeighborLookup(pb_Object pb, IList<pb_Face> InFaces)
		{
			Dictionary<int, int> dictionary = pb.sharedIndices.ToDictionary();
			Dictionary<pb_Face, List<pb_Face>> dictionary2 = new Dictionary<pb_Face, List<pb_Face>>();
			int num = InFaces.Count<pb_Face>();
			HashSet<pb_Edge>[] array = new HashSet<pb_Edge>[num];
			for (int i = 0; i < num; i++)
			{
				array[i] = new HashSet<pb_Edge>(pb_Edge.GetUniversalEdges(InFaces[i].edges, dictionary));
			}
			for (int j = 0; j < num - 1; j++)
			{
				if (!dictionary2.ContainsKey(InFaces[j]))
				{
					dictionary2.Add(InFaces[j], new List<pb_Face>());
				}
				for (int k = j + 1; k < num; k++)
				{
					bool flag = array[j].Overlaps(array[k]);
					if (flag)
					{
						dictionary2[InFaces[j]].Add(InFaces[k]);
						List<pb_Face> list;
						if (dictionary2.TryGetValue(InFaces[k], out list))
						{
							list.Add(InFaces[j]);
						}
						else
						{
							dictionary2.Add(InFaces[k], new List<pb_Face> { InFaces[j] });
						}
					}
				}
			}
			return dictionary2;
		}

		// Token: 0x06000019 RID: 25 RVA: 0x00004CA4 File Offset: 0x000030A4
		public static pb_Face[] GetNeighborFaces(pb_Object pb, Dictionary<int, int> sharedIndicesLookup, pb_Face[] selFaces)
		{
			List<pb_Face> list = new List<pb_Face>();
			pb_Edge[] array = pbMeshUtils.GetPerimeterEdges(sharedIndicesLookup, selFaces).ToArray<pb_Edge>();
			pb_Edge[] array2 = new pb_Edge[array.Length];
			for (int i = 0; i < array.Length; i++)
			{
				array2[i] = new pb_Edge(sharedIndicesLookup[array[i].x], sharedIndicesLookup[array[i].y]);
			}
			pb_Edge pb_Edge = new pb_Edge(-1, -1);
			HashSet<pb_Face> hashSet = new HashSet<pb_Face>(selFaces);
			foreach (pb_Face pb_Face in pb.faces)
			{
				if (hashSet.Contains(pb_Face))
				{
					hashSet.Remove(pb_Face);
				}
				else
				{
					foreach (pb_Edge pb_Edge2 in pb_Face.edges)
					{
						pb_Edge.x = sharedIndicesLookup[pb_Edge2.x];
						pb_Edge.y = sharedIndicesLookup[pb_Edge2.y];
						if (array2.Contains(pb_Edge))
						{
							list.Add(pb_Face);
							break;
						}
					}
				}
			}
			return list.ToArray();
		}

		// Token: 0x0600001A RID: 26 RVA: 0x00004DCC File Offset: 0x000031CC
		public static List<pb_Tuple<pb_Face, pb_Edge>> GetNeighborFaces(pb_Object pb, pb_Edge edge, Dictionary<int, int> lookup = null)
		{
			if (lookup == null)
			{
				lookup = pb.sharedIndices.ToDictionary();
			}
			List<pb_Tuple<pb_Face, pb_Edge>> list = new List<pb_Tuple<pb_Face, pb_Edge>>();
			pb_Edge pb_Edge = new pb_Edge(lookup[edge.x], lookup[edge.y]);
			pb_Edge pb_Edge2 = new pb_Edge(0, 0);
			for (int i = 0; i < pb.faces.Length; i++)
			{
				pb_Edge[] edges = pb.faces[i].edges;
				for (int j = 0; j < edges.Length; j++)
				{
					pb_Edge2.x = edges[j].x;
					pb_Edge2.y = edges[j].y;
					if ((pb_Edge.x == lookup[pb_Edge2.x] && pb_Edge.y == lookup[pb_Edge2.y]) || (pb_Edge.x == lookup[pb_Edge2.y] && pb_Edge.y == lookup[pb_Edge2.x]))
					{
						list.Add(new pb_Tuple<pb_Face, pb_Edge>(pb.faces[i], new pb_Edge(edges[j])));
						break;
					}
				}
			}
			return list;
		}

		// Token: 0x0600001B RID: 27 RVA: 0x00004EF8 File Offset: 0x000032F8
		public static pb_Face[] GetNeighborFaces(pb_Object pb, pb_Edge[] edges)
		{
			List<pb_Face> list = new List<pb_Face>();
			Dictionary<int, int> dictionary = pb.sharedIndices.ToDictionary();
			foreach (pb_Face pb_Face in pb.faces)
			{
				foreach (pb_Edge pb_Edge in edges)
				{
					if (pb_Face.edges.IndexOf(pb_Edge, dictionary) > -1)
					{
						list.Add(pb_Face);
					}
				}
			}
			return list.Distinct<pb_Face>().ToArray<pb_Face>();
		}

		// Token: 0x0600001C RID: 28 RVA: 0x00004F84 File Offset: 0x00003384
		internal static List<pb_Face>[][] GetNeighborFacesJagged(pb_Object pb, pb_Edge[][] selEdges)
		{
			int num = selEdges.Length;
			List<pb_Face>[][] array = new List<pb_Face>[num][];
			for (int i = 0; i < num; i++)
			{
				array[i] = new List<pb_Face>[selEdges[i].Length];
				for (int j = 0; j < selEdges[i].Length; j++)
				{
					array[i][j] = new List<pb_Face>();
				}
			}
			pb_IntArray[] sharedIndices = pb.sharedIndices;
			pb_Edge[][] array2 = new pb_Edge[num][];
			for (int k = 0; k < num; k++)
			{
				array2[k] = pb_Edge.GetUniversalEdges(selEdges[k], sharedIndices).Distinct<pb_Edge>().ToArray<pb_Edge>();
			}
			for (int l = 0; l < pb.faces.Length; l++)
			{
				pb_Edge[] array3 = pb_Edge.GetUniversalEdges(pb.faces[l].edges, sharedIndices).Distinct<pb_Edge>().ToArray<pb_Edge>();
				for (int m = 0; m < num; m++)
				{
					int num2 = -1;
					for (int n = 0; n < array2[m].Length; n++)
					{
						if (array3.Contains(array2[m][n]))
						{
							num2 = n;
							break;
						}
					}
					if (num2 > -1)
					{
						array[m][num2].Add(pb.faces[l]);
					}
				}
			}
			return array;
		}

		// Token: 0x0600001D RID: 29 RVA: 0x000050CC File Offset: 0x000034CC
		public static List<pb_Face> GetNeighborFaces(pb_Object pb, int index)
		{
			List<pb_Face> list = new List<pb_Face>();
			pb_IntArray[] sharedIndices = pb.sharedIndices;
			int num = sharedIndices.IndexOf(index);
			foreach (pb_Face pb_Face in pb.faces)
			{
				if (pb_Face.distinctIndices.ContainsMatch(sharedIndices[num]))
				{
					list.Add(pb_Face);
				}
			}
			return list;
		}

		// Token: 0x0600001E RID: 30 RVA: 0x00005138 File Offset: 0x00003538
		public static IEnumerable<pb_Face> GetNeighborFaces(pb_Object pb, IEnumerable<int> indices)
		{
			List<pb_Face> list = new List<pb_Face>();
			Dictionary<int, int> dictionary = pb.sharedIndices.ToDictionary();
			HashSet<int> hashSet = new HashSet<int>();
			foreach (int num in indices)
			{
				hashSet.Add(dictionary[num]);
			}
			for (int i = 0; i < pb.faces.Length; i++)
			{
				int[] distinctIndices = pb.faces[i].distinctIndices;
				for (int j = 0; j < distinctIndices.Length; j++)
				{
					if (hashSet.Contains(dictionary[distinctIndices[j]]))
					{
						list.Add(pb.faces[i]);
						break;
					}
				}
			}
			return list;
		}

		// Token: 0x0600001F RID: 31 RVA: 0x00005224 File Offset: 0x00003624
		public static pb_Edge[] GetConnectedEdges(pb_Object pb, int[] indices)
		{
			Dictionary<int, int> dictionary = pb.sharedIndices.ToDictionary();
			List<pb_Edge> list = new List<pb_Edge>();
			HashSet<int> hashSet = new HashSet<int>();
			for (int i = 0; i < indices.Length; i++)
			{
				hashSet.Add(dictionary[indices[i]]);
			}
			pb_Edge[] array = pb_Edge.AllEdges(pb.faces);
			HashSet<pb_Edge> hashSet2 = new HashSet<pb_Edge>();
			pb_Edge pb_Edge = new pb_Edge(0, 0);
			for (int j = 0; j < array.Length; j++)
			{
				pb_Edge pb_Edge2 = new pb_Edge(dictionary[array[j].x], dictionary[array[j].y]);
				if (hashSet.Contains(pb_Edge2.x) || (hashSet.Contains(pb_Edge2.y) && !hashSet2.Contains(pb_Edge)))
				{
					list.Add(array[j]);
					hashSet2.Add(pb_Edge2);
				}
			}
			return list.ToArray();
		}

		// Token: 0x06000020 RID: 32 RVA: 0x00005317 File Offset: 0x00003717
		public static IEnumerable<pb_Edge> GetPerimeterEdges(pb_Object pb, IEnumerable<pb_Face> faces)
		{
			return pbMeshUtils.GetPerimeterEdges(pb.sharedIndices.ToDictionary(), faces);
		}

		// Token: 0x06000021 RID: 33 RVA: 0x0000532C File Offset: 0x0000372C
		public static IEnumerable<pb_Edge> GetPerimeterEdges(Dictionary<int, int> sharedIndicesLookup, IEnumerable<pb_Face> faces)
		{
			List<pb_Edge> list = faces.SelectMany((pb_Face x) => x.edges).ToList<pb_Edge>();
			int count = list.Count;
			Dictionary<pb_Edge, List<pb_Edge>> dictionary = new Dictionary<pb_Edge, List<pb_Edge>>();
			for (int i = 0; i < count; i++)
			{
				pb_Edge pb_Edge = new pb_Edge(sharedIndicesLookup[list[i].x], sharedIndicesLookup[list[i].y]);
				List<pb_Edge> list2;
				if (dictionary.TryGetValue(pb_Edge, out list2))
				{
					list2.Add(list[i]);
				}
				else
				{
					dictionary.Add(pb_Edge, new List<pb_Edge> { list[i] });
				}
			}
			return from x in dictionary
				where x.Value.Count < 2
				select x.Value[0];
		}

		// Token: 0x06000022 RID: 34 RVA: 0x0000543C File Offset: 0x0000383C
		public static int[] GetPerimeterEdges(pb_Object pb, pb_Edge[] edges)
		{
			if (edges.Length == pb_Edge.AllEdges(pb.faces).Length || edges.Length < 3)
			{
				return new int[0];
			}
			pb_Edge[] universalEdges = pb_Edge.GetUniversalEdges(edges, pb.sharedIndices.ToDictionary());
			int[] array = new int[universalEdges.Length];
			for (int i = 0; i < universalEdges.Length - 1; i++)
			{
				for (int j = i + 1; j < universalEdges.Length; j++)
				{
					if (universalEdges[i].x == universalEdges[j].x || universalEdges[i].x == universalEdges[j].y || universalEdges[i].y == universalEdges[j].x || universalEdges[i].y == universalEdges[j].y)
					{
						array[i]++;
						array[j]++;
					}
				}
			}
			int num = pb_Math.Min<int>(array);
			List<int> list = new List<int>();
			for (int k = 0; k < array.Length; k++)
			{
				if (array[k] <= num)
				{
					list.Add(k);
				}
			}
			return (list.Count == edges.Length) ? new int[0] : list.ToArray();
		}

		// Token: 0x06000023 RID: 35 RVA: 0x00005580 File Offset: 0x00003980
		public static IEnumerable<pb_Face> GetPerimeterFaces(pb_Object pb, IEnumerable<pb_Face> faces)
		{
			Dictionary<int, int> dictionary = pb.sharedIndices.ToDictionary();
			Dictionary<pb_Edge, List<pb_Face>> dictionary2 = new Dictionary<pb_Edge, List<pb_Face>>();
			foreach (pb_Face pb_Face in faces)
			{
				foreach (pb_Edge pb_Edge in pb_Face.edges)
				{
					pb_Edge pb_Edge2 = new pb_Edge(dictionary[pb_Edge.x], dictionary[pb_Edge.y]);
					if (dictionary2.ContainsKey(pb_Edge2))
					{
						dictionary2[pb_Edge2].Add(pb_Face);
					}
					else
					{
						dictionary2.Add(pb_Edge2, new List<pb_Face> { pb_Face });
					}
				}
			}
			return (from x in dictionary2
				where x.Value.Count < 2
				select x.Value[0]).Distinct<pb_Face>();
		}

		// Token: 0x06000024 RID: 36 RVA: 0x000056AC File Offset: 0x00003AAC
		public static int[] GetPerimeterVertices(pb_Object pb, int[] indices, pb_Edge[] universal_edges_all)
		{
			int num = indices.Length;
			pb_IntArray[] sharedIndices = pb.sharedIndices;
			int[] array = new int[num];
			for (int i = 0; i < num; i++)
			{
				array[i] = sharedIndices.IndexOf(indices[i]);
			}
			int[] array2 = new int[indices.Length];
			for (int j = 0; j < indices.Length - 1; j++)
			{
				for (int k = j + 1; k < indices.Length; k++)
				{
					if (universal_edges_all.Contains(array[j], array[k]))
					{
						array2[j]++;
						array2[k]++;
					}
				}
			}
			int num2 = pb_Math.Min<int>(array2);
			List<int> list = new List<int>();
			for (int l = 0; l < num; l++)
			{
				if (array2[l] <= num2)
				{
					list.Add(l);
				}
			}
			return (list.Count >= num) ? new int[0] : list.ToArray();
		}

		// Token: 0x06000025 RID: 37 RVA: 0x000057B4 File Offset: 0x00003BB4
		private static pb_WingedEdge EdgeRingNext(pb_WingedEdge edge)
		{
			if (edge == null)
			{
				return null;
			}
			pb_WingedEdge pb_WingedEdge = edge.next;
			pb_WingedEdge pb_WingedEdge2 = edge.previous;
			int num = 0;
			while (pb_WingedEdge != pb_WingedEdge2 && pb_WingedEdge != edge)
			{
				pb_WingedEdge = pb_WingedEdge.next;
				if (pb_WingedEdge == pb_WingedEdge2)
				{
					return null;
				}
				pb_WingedEdge2 = pb_WingedEdge2.previous;
				num++;
			}
			if (num % 2 == 0 || pb_WingedEdge == edge)
			{
				pb_WingedEdge = null;
			}
			return pb_WingedEdge;
		}

		// Token: 0x06000026 RID: 38 RVA: 0x0000581C File Offset: 0x00003C1C
		public static IEnumerable<pb_Edge> GetEdgeRing(pb_Object pb, pb_Edge[] edges)
		{
			List<pb_WingedEdge> wingedEdges = pb_WingedEdge.GetWingedEdges(pb, false);
			List<pb_EdgeLookup> list = pb_EdgeLookup.GetEdgeLookup(edges, pb.sharedIndices.ToDictionary()).ToList<pb_EdgeLookup>();
			list.Distinct<pb_EdgeLookup>();
			Dictionary<pb_Edge, pb_WingedEdge> dictionary = new Dictionary<pb_Edge, pb_WingedEdge>();
			for (int i = 0; i < wingedEdges.Count; i++)
			{
				if (!dictionary.ContainsKey(wingedEdges[i].edge.common))
				{
					dictionary.Add(wingedEdges[i].edge.common, wingedEdges[i]);
				}
			}
			HashSet<pb_EdgeLookup> hashSet = new HashSet<pb_EdgeLookup>();
			for (int j = 0; j < list.Count; j++)
			{
				pb_WingedEdge pb_WingedEdge;
				if (dictionary.TryGetValue(list[j].common, out pb_WingedEdge) && !hashSet.Contains(pb_WingedEdge.edge))
				{
					pb_WingedEdge pb_WingedEdge2 = pb_WingedEdge;
					while (pb_WingedEdge2 != null)
					{
						if (!hashSet.Add(pb_WingedEdge2.edge))
						{
							break;
						}
						pb_WingedEdge2 = pbMeshUtils.EdgeRingNext(pb_WingedEdge2);
						if (pb_WingedEdge2 != null && pb_WingedEdge2.opposite != null)
						{
							pb_WingedEdge2 = pb_WingedEdge2.opposite;
						}
					}
					pb_WingedEdge2 = pbMeshUtils.EdgeRingNext(pb_WingedEdge.opposite);
					if (pb_WingedEdge2 != null && pb_WingedEdge2.opposite != null)
					{
						pb_WingedEdge2 = pb_WingedEdge2.opposite;
					}
					while (pb_WingedEdge2 != null)
					{
						if (!hashSet.Add(pb_WingedEdge2.edge))
						{
							break;
						}
						pb_WingedEdge2 = pbMeshUtils.EdgeRingNext(pb_WingedEdge2);
						if (pb_WingedEdge2 != null && pb_WingedEdge2.opposite != null)
						{
							pb_WingedEdge2 = pb_WingedEdge2.opposite;
						}
					}
				}
			}
			return hashSet.Select((pb_EdgeLookup x) => x.local);
		}

		// Token: 0x06000027 RID: 39 RVA: 0x000059E0 File Offset: 0x00003DE0
		public static bool GetEdgeLoop(pb_Object pb, pb_Edge[] edges, out pb_Edge[] loop)
		{
			List<pb_WingedEdge> wingedEdges = pb_WingedEdge.GetWingedEdges(pb, false);
			IEnumerable<pb_EdgeLookup> edgeLookup = pb_EdgeLookup.GetEdgeLookup(edges, pb.sharedIndices.ToDictionary());
			HashSet<pb_EdgeLookup> hashSet = new HashSet<pb_EdgeLookup>(edgeLookup);
			HashSet<pb_EdgeLookup> hashSet2 = new HashSet<pb_EdgeLookup>();
			for (int i = 0; i < wingedEdges.Count; i++)
			{
				if (!hashSet2.Contains(wingedEdges[i].edge) && hashSet.Contains(wingedEdges[i].edge))
				{
					if (!pbMeshUtils.GetEdgeLoopInternal(wingedEdges[i], wingedEdges[i].edge.common.y, hashSet2))
					{
						pbMeshUtils.GetEdgeLoopInternal(wingedEdges[i], wingedEdges[i].edge.common.x, hashSet2);
					}
				}
			}
			loop = hashSet2.Select((pb_EdgeLookup x) => x.local).ToArray<pb_Edge>();
			return true;
		}

		// Token: 0x06000028 RID: 40 RVA: 0x00005AE4 File Offset: 0x00003EE4
		private static bool GetEdgeLoopInternal(pb_WingedEdge start, int startIndex, HashSet<pb_EdgeLookup> used)
		{
			int num = startIndex;
			pb_WingedEdge pb_WingedEdge = start;
			do
			{
				used.Add(pb_WingedEdge.edge);
				List<pb_WingedEdge> list = pbMeshUtils.GetSpokes(pb_WingedEdge, num, true).DistinctBy((pb_WingedEdge x) => x.edge.common).ToList<pb_WingedEdge>();
				pb_WingedEdge = null;
				if (list != null && list.Count == 4)
				{
					pb_WingedEdge = list[2];
					num = ((pb_WingedEdge.edge.common.x != num) ? pb_WingedEdge.edge.common.x : pb_WingedEdge.edge.common.y);
				}
			}
			while (pb_WingedEdge != null && !used.Contains(pb_WingedEdge.edge));
			return pb_WingedEdge != null;
		}

		// Token: 0x06000029 RID: 41 RVA: 0x00005BA8 File Offset: 0x00003FA8
		private static pb_WingedEdge NextSpoke(pb_WingedEdge wing, int pivot, bool opp)
		{
			if (opp)
			{
				return wing.opposite;
			}
			if (wing.next.edge.common.Contains(pivot))
			{
				return wing.next;
			}
			if (wing.previous.edge.common.Contains(pivot))
			{
				return wing.previous;
			}
			return null;
		}

		// Token: 0x0600002A RID: 42 RVA: 0x00005C08 File Offset: 0x00004008
		public static List<pb_WingedEdge> GetSpokes(pb_WingedEdge wing, int sharedIndex, bool allowHoles = false)
		{
			List<pb_WingedEdge> list = new List<pb_WingedEdge>();
			pb_WingedEdge pb_WingedEdge = wing;
			bool flag = false;
			for (;;)
			{
				list.Add(pb_WingedEdge);
				pb_WingedEdge = pbMeshUtils.NextSpoke(pb_WingedEdge, sharedIndex, flag);
				flag = !flag;
				if (pb_WingedEdge != null && pb_WingedEdge.edge.common.Equals(wing.edge.common))
				{
					break;
				}
				if (pb_WingedEdge == null)
				{
					goto Block_3;
				}
			}
			return list;
			Block_3:
			if (!allowHoles)
			{
				return null;
			}
			pb_WingedEdge = wing.opposite;
			flag = false;
			List<pb_WingedEdge> list2 = new List<pb_WingedEdge>();
			while (pb_WingedEdge != null && !pb_WingedEdge.edge.common.Equals(wing.edge.common))
			{
				list2.Add(pb_WingedEdge);
				pb_WingedEdge = pbMeshUtils.NextSpoke(pb_WingedEdge, sharedIndex, flag);
				flag = !flag;
			}
			list2.Reverse();
			list.AddRange(list2);
			return list;
		}
	}
}