using System;
using System.Collections;
using System.Globalization;
using System.Reflection;
using System.Runtime.InteropServices;

namespace Mono.Globalization.Unicode
{
	// Token: 0x02000085 RID: 133
	internal class MSCompatUnicodeTable
	{
		// Token: 0x06000798 RID: 1944 RVA: 0x00018168 File Offset: 0x00016368
		unsafe static MSCompatUnicodeTable()
		{
			IntPtr intPtr = MSCompatUnicodeTable.GetResource("collation.core.bin");
			if (intPtr == IntPtr.Zero)
			{
				return;
			}
			byte* ptr = (byte*)(void*)intPtr;
			intPtr = MSCompatUnicodeTable.GetResource("collation.tailoring.bin");
			if (intPtr == IntPtr.Zero)
			{
				return;
			}
			byte* ptr2 = (byte*)(void*)intPtr;
			if (ptr == null || ptr2 == null)
			{
				return;
			}
			if (*ptr != 3 || *ptr2 != 3)
			{
				return;
			}
			uint num = 1U;
			uint num2 = MSCompatUnicodeTable.UInt32FromBytePtr(ptr, num);
			num += 4U;
			MSCompatUnicodeTable.ignorableFlags = ptr + num;
			num += num2;
			num2 = MSCompatUnicodeTable.UInt32FromBytePtr(ptr, num);
			num += 4U;
			MSCompatUnicodeTable.categories = ptr + num;
			num += num2;
			num2 = MSCompatUnicodeTable.UInt32FromBytePtr(ptr, num);
			num += 4U;
			MSCompatUnicodeTable.level1 = ptr + num;
			num += num2;
			num2 = MSCompatUnicodeTable.UInt32FromBytePtr(ptr, num);
			num += 4U;
			MSCompatUnicodeTable.level2 = ptr + num;
			num += num2;
			num2 = MSCompatUnicodeTable.UInt32FromBytePtr(ptr, num);
			num += 4U;
			MSCompatUnicodeTable.level3 = ptr + num;
			num += num2;
			num = 1U;
			uint num3 = MSCompatUnicodeTable.UInt32FromBytePtr(ptr2, num);
			num += 4U;
			MSCompatUnicodeTable.tailoringInfos = new TailoringInfo[num3];
			int num4 = 0;
			while ((long)num4 < (long)((ulong)num3))
			{
				int num5 = (int)MSCompatUnicodeTable.UInt32FromBytePtr(ptr2, num);
				num += 4U;
				int num6 = (int)MSCompatUnicodeTable.UInt32FromBytePtr(ptr2, num);
				num += 4U;
				int num7 = (int)MSCompatUnicodeTable.UInt32FromBytePtr(ptr2, num);
				num += 4U;
				TailoringInfo tailoringInfo = new TailoringInfo(num5, num6, num7, ptr2[(UIntPtr)(num++)] != 0);
				MSCompatUnicodeTable.tailoringInfos[num4] = tailoringInfo;
				num4++;
			}
			num += 2U;
			num3 = MSCompatUnicodeTable.UInt32FromBytePtr(ptr2, num);
			num += 4U;
			MSCompatUnicodeTable.tailoringArr = new char[num3];
			int num8 = 0;
			while ((long)num8 < (long)((ulong)num3))
			{
				MSCompatUnicodeTable.tailoringArr[num8] = (char)((int)ptr2[num] + ((int)ptr2[num + 1U] << 8));
				num8++;
				num += 2U;
			}
			MSCompatUnicodeTable.isReady = true;
		}

		// Token: 0x06000799 RID: 1945 RVA: 0x0001834C File Offset: 0x0001654C
		public static TailoringInfo GetTailoringInfo(int lcid)
		{
			for (int i = 0; i < MSCompatUnicodeTable.tailoringInfos.Length; i++)
			{
				if (MSCompatUnicodeTable.tailoringInfos[i].LCID == lcid)
				{
					return MSCompatUnicodeTable.tailoringInfos[i];
				}
			}
			return null;
		}

		// Token: 0x0600079A RID: 1946 RVA: 0x0001838C File Offset: 0x0001658C
		public unsafe static void BuildTailoringTables(CultureInfo culture, TailoringInfo t, ref Contraction[] contractions, ref Level2Map[] diacriticals)
		{
			ArrayList arrayList = new ArrayList();
			ArrayList arrayList2 = new ArrayList();
			fixed (char* ptr = (ref MSCompatUnicodeTable.tailoringArr != null && MSCompatUnicodeTable.tailoringArr.Length != 0 ? ref MSCompatUnicodeTable.tailoringArr[0] : ref *null))
			{
				int i = t.TailoringIndex;
				int num = i + t.TailoringCount;
				while (i < num)
				{
					int num2 = i + 1;
					switch (ptr[i])
					{
					case '\u0001':
					{
						i++;
						while (ptr[num2] != '\0')
						{
							num2++;
						}
						char[] array = new char[num2 - i];
						Marshal.Copy((IntPtr)((void*)(ptr + i)), array, 0, num2 - i);
						byte[] array2 = new byte[4];
						for (int j = 0; j < 4; j++)
						{
							array2[j] = (byte)ptr[num2 + 1 + j];
						}
						arrayList.Add(new Contraction(array, null, array2));
						i = num2 + 6;
						break;
					}
					case '\u0002':
						arrayList2.Add(new Level2Map((byte)ptr[i + 1], (byte)ptr[i + 2]));
						i += 3;
						break;
					case '\u0003':
					{
						i++;
						while (ptr[num2] != '\0')
						{
							num2++;
						}
						char[] array = new char[num2 - i];
						Marshal.Copy((IntPtr)((void*)(ptr + i)), array, 0, num2 - i);
						num2++;
						int num3 = num2;
						while (ptr[num3] != '\0')
						{
							num3++;
						}
						string text = new string(ptr, num2, num3 - num2);
						arrayList.Add(new Contraction(array, text, null));
						i = num3 + 1;
						break;
					}
					default:
						throw new NotImplementedException(string.Format("Mono INTERNAL ERROR (Should not happen): Collation tailoring table is broken for culture {0} ({1}) at 0x{2:X}", culture.LCID, culture.Name, i));
					}
				}
			}
			arrayList.Sort(ContractionComparer.Instance);
			arrayList2.Sort(Level2MapComparer.Instance);
			contractions = arrayList.ToArray(typeof(Contraction)) as Contraction[];
			diacriticals = arrayList2.ToArray(typeof(Level2Map)) as Level2Map[];
		}

		// Token: 0x0600079B RID: 1947 RVA: 0x000185BC File Offset: 0x000167BC
		private unsafe static void SetCJKReferences(string name, ref CodePointIndexer cjkIndexer, ref byte* catTable, ref byte* lv1Table, ref CodePointIndexer lv2Indexer, ref byte* lv2Table)
		{
			switch (name)
			{
			case "zh-CHS":
				catTable = MSCompatUnicodeTable.cjkCHScategory;
				lv1Table = MSCompatUnicodeTable.cjkCHSlv1;
				cjkIndexer = MSCompatUnicodeTableUtil.CjkCHS;
				break;
			case "zh-CHT":
				catTable = MSCompatUnicodeTable.cjkCHTcategory;
				lv1Table = MSCompatUnicodeTable.cjkCHTlv1;
				cjkIndexer = MSCompatUnicodeTableUtil.Cjk;
				break;
			case "ja":
				catTable = MSCompatUnicodeTable.cjkJAcategory;
				lv1Table = MSCompatUnicodeTable.cjkJAlv1;
				cjkIndexer = MSCompatUnicodeTableUtil.Cjk;
				break;
			case "ko":
				catTable = MSCompatUnicodeTable.cjkKOcategory;
				lv1Table = MSCompatUnicodeTable.cjkKOlv1;
				lv2Table = MSCompatUnicodeTable.cjkKOlv2;
				cjkIndexer = MSCompatUnicodeTableUtil.Cjk;
				lv2Indexer = MSCompatUnicodeTableUtil.Cjk;
				break;
			}
		}

		// Token: 0x0600079C RID: 1948 RVA: 0x000186C0 File Offset: 0x000168C0
		public unsafe static byte Category(int cp)
		{
			return MSCompatUnicodeTable.categories[MSCompatUnicodeTableUtil.Category.ToIndex(cp)];
		}

		// Token: 0x0600079D RID: 1949 RVA: 0x000186D4 File Offset: 0x000168D4
		public unsafe static byte Level1(int cp)
		{
			return MSCompatUnicodeTable.level1[MSCompatUnicodeTableUtil.Level1.ToIndex(cp)];
		}

		// Token: 0x0600079E RID: 1950 RVA: 0x000186E8 File Offset: 0x000168E8
		public unsafe static byte Level2(int cp)
		{
			return MSCompatUnicodeTable.level2[MSCompatUnicodeTableUtil.Level2.ToIndex(cp)];
		}

		// Token: 0x0600079F RID: 1951 RVA: 0x000186FC File Offset: 0x000168FC
		public unsafe static byte Level3(int cp)
		{
			return MSCompatUnicodeTable.level3[MSCompatUnicodeTableUtil.Level3.ToIndex(cp)];
		}

		// Token: 0x060007A0 RID: 1952 RVA: 0x00018710 File Offset: 0x00016910
		public static bool IsSortable(string s)
		{
			foreach (char c in s)
			{
				if (!MSCompatUnicodeTable.IsSortable((int)c))
				{
					return false;
				}
			}
			return true;
		}

		// Token: 0x060007A1 RID: 1953 RVA: 0x0001874C File Offset: 0x0001694C
		public static bool IsSortable(int cp)
		{
			return !MSCompatUnicodeTable.IsIgnorable(cp) || cp == 0 || cp == 1600 || cp == 65279 || (6155 <= cp && cp <= 6158) || (8204 <= cp && cp <= 8207) || (8234 <= cp && cp <= 8238) || (8298 <= cp && cp <= 8303) || (8204 <= cp && cp <= 8207) || (65529 <= cp && cp <= 65533);
		}

		// Token: 0x060007A2 RID: 1954 RVA: 0x00018818 File Offset: 0x00016A18
		public static bool IsIgnorable(int cp)
		{
			return MSCompatUnicodeTable.IsIgnorable(cp, 1);
		}

		// Token: 0x060007A3 RID: 1955 RVA: 0x00018824 File Offset: 0x00016A24
		public unsafe static bool IsIgnorable(int cp, byte flag)
		{
			if (cp == 0)
			{
				return false;
			}
			if ((flag & 1) != 0)
			{
				UnicodeCategory unicodeCategory = char.GetUnicodeCategory((char)cp);
				if (unicodeCategory == UnicodeCategory.OtherNotAssigned)
				{
					return true;
				}
				if (55424 <= cp && cp < 56192)
				{
					return true;
				}
			}
			int num = MSCompatUnicodeTableUtil.Ignorable.ToIndex(cp);
			return num >= 0 && (MSCompatUnicodeTable.ignorableFlags[num] & flag) != 0;
		}

		// Token: 0x060007A4 RID: 1956 RVA: 0x00018894 File Offset: 0x00016A94
		public static bool IsIgnorableSymbol(int cp)
		{
			return MSCompatUnicodeTable.IsIgnorable(cp, 2);
		}

		// Token: 0x060007A5 RID: 1957 RVA: 0x000188A0 File Offset: 0x00016AA0
		public static bool IsIgnorableNonSpacing(int cp)
		{
			return MSCompatUnicodeTable.IsIgnorable(cp, 4);
		}

		// Token: 0x060007A6 RID: 1958 RVA: 0x000188AC File Offset: 0x00016AAC
		public static int ToKanaTypeInsensitive(int i)
		{
			return (12353 > i || i > 12436) ? i : (i + 96);
		}

		// Token: 0x060007A7 RID: 1959 RVA: 0x000188DC File Offset: 0x00016ADC
		public static int ToWidthCompat(int i)
		{
			if (i < 8592)
			{
				return i;
			}
			if (i > 65280)
			{
				if (i <= 65374)
				{
					return i - 65280 + 32;
				}
				switch (i)
				{
				case 65504:
					return 162;
				case 65505:
					return 163;
				case 65506:
					return 172;
				case 65507:
					return 175;
				case 65508:
					return 166;
				case 65509:
					return 165;
				case 65510:
					return 8361;
				}
			}
			if (i > 13054)
			{
				return i;
			}
			if (i <= 8595)
			{
				return 56921 + i;
			}
			if (i < 9474)
			{
				return i;
			}
			if (i <= 9675)
			{
				if (i == 9474)
				{
					return 65512;
				}
				if (i == 9632)
				{
					return 65517;
				}
				if (i != 9675)
				{
					return i;
				}
				return 65518;
			}
			else
			{
				if (i < 12288)
				{
					return i;
				}
				if (i < 12593)
				{
					switch (i)
					{
					case 12288:
						return 32;
					case 12289:
						return 65380;
					case 12290:
						return 65377;
					default:
						if (i == 12300)
						{
							return 65378;
						}
						if (i == 12301)
						{
							return 65379;
						}
						if (i != 12539)
						{
							return i;
						}
						return 65381;
					}
				}
				else
				{
					if (i < 12644)
					{
						return i - 12592 + 65440;
					}
					if (i == 12644)
					{
						return 65440;
					}
					return i;
				}
			}
		}

		// Token: 0x060007A8 RID: 1960 RVA: 0x00018A8C File Offset: 0x00016C8C
		public static bool HasSpecialWeight(char c)
		{
			if (c < 'ぁ')
			{
				return false;
			}
			if ('ｦ' <= c && c < 'ﾞ')
			{
				return true;
			}
			if ('㌀' <= c)
			{
				return false;
			}
			if (c < 'ゝ')
			{
				return c < '\u3099';
			}
			if (c < '\u3100')
			{
				return c != '・';
			}
			return c >= '㋐' && c < '㋿';
		}

		// Token: 0x060007A9 RID: 1961 RVA: 0x00018B14 File Offset: 0x00016D14
		public static byte GetJapaneseDashType(char c)
		{
			switch (c)
			{
			case 'ー':
				return 5;
			case 'ヽ':
			case 'ヾ':
				break;
			default:
				if (c != 'ゝ' && c != 'ゞ' && c != 'ｰ')
				{
					return 3;
				}
				break;
			}
			return 4;
		}

		// Token: 0x060007AA RID: 1962 RVA: 0x00018B68 File Offset: 0x00016D68
		public static bool IsHalfWidthKana(char c)
		{
			return 'ｦ' <= c && c <= 'ﾝ';
		}

		// Token: 0x060007AB RID: 1963 RVA: 0x00018B84 File Offset: 0x00016D84
		public static bool IsHiragana(char c)
		{
			return 'ぁ' <= c && c <= 'ゔ';
		}

		// Token: 0x060007AC RID: 1964 RVA: 0x00018BA0 File Offset: 0x00016DA0
		public static bool IsJapaneseSmallLetter(char c)
		{
			if ('ｧ' <= c && c <= 'ｯ')
			{
				return true;
			}
			if ('\u3040' < c && c < 'ヺ')
			{
				switch (c)
				{
				case 'ぁ':
				case 'ぃ':
				case 'ぅ':
				case 'ぇ':
				case 'ぉ':
					break;
				default:
					switch (c)
					{
					case 'ァ':
					case 'ィ':
					case 'ゥ':
					case 'ェ':
					case 'ォ':
						break;
					default:
						switch (c)
						{
						case 'ゃ':
						case 'ゅ':
						case 'ょ':
							break;
						default:
							switch (c)
							{
							case 'ャ':
							case 'ュ':
							case 'ョ':
								break;
							default:
								if (c != 'ヵ' && c != 'ヶ' && c != 'っ' && c != 'ゎ' && c != 'ッ' && c != 'ヮ')
								{
									return false;
								}
								break;
							}
							break;
						}
						break;
					}
					break;
				}
				return true;
			}
			return false;
		}

		// Token: 0x170000DC RID: 220
		// (get) Token: 0x060007AD RID: 1965 RVA: 0x00018CC8 File Offset: 0x00016EC8
		public static bool IsReady
		{
			get
			{
				return MSCompatUnicodeTable.isReady;
			}
		}

		// Token: 0x060007AE RID: 1966 RVA: 0x00018CD0 File Offset: 0x00016ED0
		private static IntPtr GetResource(string name)
		{
			int num;
			Module module;
			return Assembly.GetExecutingAssembly().GetManifestResourceInternal(name, out num, out module);
		}

		// Token: 0x060007AF RID: 1967 RVA: 0x00018CEC File Offset: 0x00016EEC
		private unsafe static uint UInt32FromBytePtr(byte* raw, uint idx)
		{
			return (uint)((int)raw[idx] + ((int)raw[idx + 1U] << 8) + ((int)raw[idx + 2U] << 16) + ((int)raw[idx + 3U] << 24));
		}

		// Token: 0x060007B0 RID: 1968 RVA: 0x00018D14 File Offset: 0x00016F14
		public unsafe static void FillCJK(string culture, ref CodePointIndexer cjkIndexer, ref byte* catTable, ref byte* lv1Table, ref CodePointIndexer lv2Indexer, ref byte* lv2Table)
		{
			object obj = MSCompatUnicodeTable.forLock;
			lock (obj)
			{
				MSCompatUnicodeTable.FillCJKCore(culture, ref cjkIndexer, ref catTable, ref lv1Table, ref lv2Indexer, ref lv2Table);
				MSCompatUnicodeTable.SetCJKReferences(culture, ref cjkIndexer, ref catTable, ref lv1Table, ref lv2Indexer, ref lv2Table);
			}
		}

		// Token: 0x060007B1 RID: 1969 RVA: 0x00018D70 File Offset: 0x00016F70
		private unsafe static void FillCJKCore(string culture, ref CodePointIndexer cjkIndexer, ref byte* catTable, ref byte* lv1Table, ref CodePointIndexer cjkLv2Indexer, ref byte* lv2Table)
		{
			if (!MSCompatUnicodeTable.IsReady)
			{
				return;
			}
			string text = null;
			switch (culture)
			{
			case "zh-CHS":
				text = "cjkCHS";
				catTable = MSCompatUnicodeTable.cjkCHScategory;
				lv1Table = MSCompatUnicodeTable.cjkCHSlv1;
				break;
			case "zh-CHT":
				text = "cjkCHT";
				catTable = MSCompatUnicodeTable.cjkCHTcategory;
				lv1Table = MSCompatUnicodeTable.cjkCHTlv1;
				break;
			case "ja":
				text = "cjkJA";
				catTable = MSCompatUnicodeTable.cjkJAcategory;
				lv1Table = MSCompatUnicodeTable.cjkJAlv1;
				break;
			case "ko":
				text = "cjkKO";
				catTable = MSCompatUnicodeTable.cjkKOcategory;
				lv1Table = MSCompatUnicodeTable.cjkKOlv1;
				break;
			}
			if (text == null || lv1Table != 0)
			{
				return;
			}
			uint num2 = 0U;
			string text2 = string.Format("collation.{0}.bin", text);
			IntPtr intPtr = MSCompatUnicodeTable.GetResource(text2);
			if (intPtr == IntPtr.Zero)
			{
				return;
			}
			byte* ptr = (byte*)(void*)intPtr;
			num2 += 1U;
			uint num3 = MSCompatUnicodeTable.UInt32FromBytePtr(ptr, num2);
			num2 += 4U;
			catTable = ptr + num2;
			lv1Table = ptr + num2 + num3;
			switch (culture)
			{
			case "zh-CHS":
				MSCompatUnicodeTable.cjkCHScategory = catTable;
				MSCompatUnicodeTable.cjkCHSlv1 = lv1Table;
				break;
			case "zh-CHT":
				MSCompatUnicodeTable.cjkCHTcategory = catTable;
				MSCompatUnicodeTable.cjkCHTlv1 = lv1Table;
				break;
			case "ja":
				MSCompatUnicodeTable.cjkJAcategory = catTable;
				MSCompatUnicodeTable.cjkJAlv1 = lv1Table;
				break;
			case "ko":
				MSCompatUnicodeTable.cjkKOcategory = catTable;
				MSCompatUnicodeTable.cjkKOlv1 = lv1Table;
				break;
			}
			if (text != "cjkKO")
			{
				return;
			}
			intPtr = MSCompatUnicodeTable.GetResource("collation.cjkKOlv2.bin");
			if (intPtr == IntPtr.Zero)
			{
				return;
			}
			ptr = (byte*)(void*)intPtr;
			num2 = 5U;
			MSCompatUnicodeTable.cjkKOlv2 = ptr + num2;
			lv2Table = MSCompatUnicodeTable.cjkKOlv2;
		}

		// Token: 0x0400012A RID: 298
		private const int ResourceVersionSize = 1;

		// Token: 0x0400012B RID: 299
		public static int MaxExpansionLength = 3;

		// Token: 0x0400012C RID: 300
		private unsafe static readonly byte* ignorableFlags;

		// Token: 0x0400012D RID: 301
		private unsafe static readonly byte* categories;

		// Token: 0x0400012E RID: 302
		private unsafe static readonly byte* level1;

		// Token: 0x0400012F RID: 303
		private unsafe static readonly byte* level2;

		// Token: 0x04000130 RID: 304
		private unsafe static readonly byte* level3;

		// Token: 0x04000131 RID: 305
		private unsafe static byte* cjkCHScategory;

		// Token: 0x04000132 RID: 306
		private unsafe static byte* cjkCHTcategory;

		// Token: 0x04000133 RID: 307
		private unsafe static byte* cjkJAcategory;

		// Token: 0x04000134 RID: 308
		private unsafe static byte* cjkKOcategory;

		// Token: 0x04000135 RID: 309
		private unsafe static byte* cjkCHSlv1;

		// Token: 0x04000136 RID: 310
		private unsafe static byte* cjkCHTlv1;

		// Token: 0x04000137 RID: 311
		private unsafe static byte* cjkJAlv1;

		// Token: 0x04000138 RID: 312
		private unsafe static byte* cjkKOlv1;

		// Token: 0x04000139 RID: 313
		private unsafe static byte* cjkKOlv2;

		// Token: 0x0400013A RID: 314
		private static readonly char[] tailoringArr;

		// Token: 0x0400013B RID: 315
		private static readonly TailoringInfo[] tailoringInfos;

		// Token: 0x0400013C RID: 316
		private static object forLock = new object();

		// Token: 0x0400013D RID: 317
		public static readonly bool isReady;
	}
}