using System;
using System.Collections;
using System.IO;
using System.Runtime.InteropServices;
using System.Security;
using System.Text;

namespace Microsoft.Win32
{
	// Token: 0x0200007C RID: 124
	internal class Win32RegistryApi : IRegistryApi
	{
		// Token: 0x06000765 RID: 1893
		[DllImport("advapi32.dll", CharSet = CharSet.Unicode)]
		private static extern int RegCreateKey(IntPtr keyBase, string keyName, out IntPtr keyHandle);

		// Token: 0x06000766 RID: 1894
		[DllImport("advapi32.dll", CharSet = CharSet.Unicode)]
		private static extern int RegCloseKey(IntPtr keyHandle);

		// Token: 0x06000767 RID: 1895
		[DllImport("advapi32.dll", CharSet = CharSet.Unicode)]
		private static extern int RegConnectRegistry(string machineName, IntPtr hKey, out IntPtr keyHandle);

		// Token: 0x06000768 RID: 1896
		[DllImport("advapi32.dll", CharSet = CharSet.Unicode)]
		private static extern int RegFlushKey(IntPtr keyHandle);

		// Token: 0x06000769 RID: 1897
		[DllImport("advapi32.dll", CharSet = CharSet.Unicode)]
		private static extern int RegOpenKeyEx(IntPtr keyBase, string keyName, IntPtr reserved, int access, out IntPtr keyHandle);

		// Token: 0x0600076A RID: 1898
		[DllImport("advapi32.dll", CharSet = CharSet.Unicode)]
		private static extern int RegDeleteKey(IntPtr keyHandle, string valueName);

		// Token: 0x0600076B RID: 1899
		[DllImport("advapi32.dll", CharSet = CharSet.Unicode)]
		private static extern int RegDeleteValue(IntPtr keyHandle, string valueName);

		// Token: 0x0600076C RID: 1900
		[DllImport("advapi32.dll", CharSet = CharSet.Unicode)]
		private static extern int RegEnumKey(IntPtr keyBase, int index, StringBuilder nameBuffer, int bufferLength);

		// Token: 0x0600076D RID: 1901
		[DllImport("advapi32.dll", CharSet = CharSet.Unicode)]
		private static extern int RegEnumValue(IntPtr keyBase, int index, StringBuilder nameBuffer, ref int nameLength, IntPtr reserved, ref RegistryValueKind type, IntPtr data, IntPtr dataLength);

		// Token: 0x0600076E RID: 1902
		[DllImport("advapi32.dll", CharSet = CharSet.Unicode)]
		private static extern int RegSetValueEx(IntPtr keyBase, string valueName, IntPtr reserved, RegistryValueKind type, string data, int rawDataLength);

		// Token: 0x0600076F RID: 1903
		[DllImport("advapi32.dll", CharSet = CharSet.Unicode)]
		private static extern int RegSetValueEx(IntPtr keyBase, string valueName, IntPtr reserved, RegistryValueKind type, byte[] rawData, int rawDataLength);

		// Token: 0x06000770 RID: 1904
		[DllImport("advapi32.dll", CharSet = CharSet.Unicode)]
		private static extern int RegSetValueEx(IntPtr keyBase, string valueName, IntPtr reserved, RegistryValueKind type, ref int data, int rawDataLength);

		// Token: 0x06000771 RID: 1905
		[DllImport("advapi32.dll", CharSet = CharSet.Unicode)]
		private static extern int RegQueryValueEx(IntPtr keyBase, string valueName, IntPtr reserved, ref RegistryValueKind type, IntPtr zero, ref int dataSize);

		// Token: 0x06000772 RID: 1906
		[DllImport("advapi32.dll", CharSet = CharSet.Unicode)]
		private static extern int RegQueryValueEx(IntPtr keyBase, string valueName, IntPtr reserved, ref RegistryValueKind type, [Out] byte[] data, ref int dataSize);

		// Token: 0x06000773 RID: 1907
		[DllImport("advapi32.dll", CharSet = CharSet.Unicode)]
		private static extern int RegQueryValueEx(IntPtr keyBase, string valueName, IntPtr reserved, ref RegistryValueKind type, ref int data, ref int dataSize);

		// Token: 0x06000774 RID: 1908 RVA: 0x00017410 File Offset: 0x00015610
		private static IntPtr GetHandle(RegistryKey key)
		{
			return (IntPtr)key.Handle;
		}

		// Token: 0x06000775 RID: 1909 RVA: 0x00017420 File Offset: 0x00015620
		private static bool IsHandleValid(RegistryKey key)
		{
			return key.Handle != null;
		}

		// Token: 0x06000776 RID: 1910 RVA: 0x00017430 File Offset: 0x00015630
		public object GetValue(RegistryKey rkey, string name, object defaultValue, RegistryValueOptions options)
		{
			RegistryValueKind registryValueKind = RegistryValueKind.Unknown;
			int num = 0;
			IntPtr handle = Win32RegistryApi.GetHandle(rkey);
			int num2 = Win32RegistryApi.RegQueryValueEx(handle, name, IntPtr.Zero, ref registryValueKind, IntPtr.Zero, ref num);
			if (num2 == 2 || num2 == 1018)
			{
				return defaultValue;
			}
			if (num2 != 234 && num2 != 0)
			{
				this.GenerateException(num2);
			}
			object obj;
			if (registryValueKind == RegistryValueKind.String)
			{
				byte[] array;
				num2 = this.GetBinaryValue(rkey, name, registryValueKind, out array, num);
				obj = RegistryKey.DecodeString(array);
			}
			else if (registryValueKind == RegistryValueKind.ExpandString)
			{
				byte[] array2;
				num2 = this.GetBinaryValue(rkey, name, registryValueKind, out array2, num);
				obj = RegistryKey.DecodeString(array2);
				if ((options & RegistryValueOptions.DoNotExpandEnvironmentNames) == RegistryValueOptions.None)
				{
					obj = Environment.ExpandEnvironmentVariables((string)obj);
				}
			}
			else if (registryValueKind == RegistryValueKind.DWord)
			{
				int num3 = 0;
				num2 = Win32RegistryApi.RegQueryValueEx(handle, name, IntPtr.Zero, ref registryValueKind, ref num3, ref num);
				obj = num3;
			}
			else if (registryValueKind == RegistryValueKind.Binary)
			{
				byte[] array3;
				num2 = this.GetBinaryValue(rkey, name, registryValueKind, out array3, num);
				obj = array3;
			}
			else
			{
				if (registryValueKind != RegistryValueKind.MultiString)
				{
					throw new SystemException();
				}
				obj = null;
				byte[] array4;
				num2 = this.GetBinaryValue(rkey, name, registryValueKind, out array4, num);
				if (num2 == 0)
				{
					obj = RegistryKey.DecodeString(array4).Split(new char[1]);
				}
			}
			if (num2 != 0)
			{
				this.GenerateException(num2);
			}
			return obj;
		}

		// Token: 0x06000777 RID: 1911 RVA: 0x00017580 File Offset: 0x00015780
		public void SetValue(RegistryKey rkey, string name, object value, RegistryValueKind valueKind)
		{
			Type type = value.GetType();
			IntPtr handle = Win32RegistryApi.GetHandle(rkey);
			int num2;
			if (valueKind == RegistryValueKind.DWord && type == typeof(int))
			{
				int num = (int)value;
				num2 = Win32RegistryApi.RegSetValueEx(handle, name, IntPtr.Zero, RegistryValueKind.DWord, ref num, 4);
			}
			else if (valueKind == RegistryValueKind.Binary && type == typeof(byte[]))
			{
				byte[] array = (byte[])value;
				num2 = Win32RegistryApi.RegSetValueEx(handle, name, IntPtr.Zero, RegistryValueKind.Binary, array, array.Length);
			}
			else if (valueKind == RegistryValueKind.MultiString && type == typeof(string[]))
			{
				string[] array2 = (string[])value;
				StringBuilder stringBuilder = new StringBuilder();
				foreach (string text in array2)
				{
					stringBuilder.Append(text);
					stringBuilder.Append('\0');
				}
				stringBuilder.Append('\0');
				byte[] bytes = Encoding.Unicode.GetBytes(stringBuilder.ToString());
				num2 = Win32RegistryApi.RegSetValueEx(handle, name, IntPtr.Zero, RegistryValueKind.MultiString, bytes, bytes.Length);
			}
			else if ((valueKind == RegistryValueKind.String || valueKind == RegistryValueKind.ExpandString) && type == typeof(string))
			{
				string text2 = string.Format("{0}{1}", value, '\0');
				num2 = Win32RegistryApi.RegSetValueEx(handle, name, IntPtr.Zero, valueKind, text2, text2.Length * this.NativeBytesPerCharacter);
			}
			else
			{
				if (type.IsArray)
				{
					throw new ArgumentException("Only string and byte arrays can written as registry values");
				}
				throw new ArgumentException("Type does not match the valueKind");
			}
			if (num2 != 0)
			{
				this.GenerateException(num2);
			}
		}

		// Token: 0x06000778 RID: 1912 RVA: 0x00017724 File Offset: 0x00015924
		public void SetValue(RegistryKey rkey, string name, object value)
		{
			Type type = value.GetType();
			IntPtr handle = Win32RegistryApi.GetHandle(rkey);
			int num2;
			if (type == typeof(int))
			{
				int num = (int)value;
				num2 = Win32RegistryApi.RegSetValueEx(handle, name, IntPtr.Zero, RegistryValueKind.DWord, ref num, 4);
			}
			else if (type == typeof(byte[]))
			{
				byte[] array = (byte[])value;
				num2 = Win32RegistryApi.RegSetValueEx(handle, name, IntPtr.Zero, RegistryValueKind.Binary, array, array.Length);
			}
			else if (type == typeof(string[]))
			{
				string[] array2 = (string[])value;
				StringBuilder stringBuilder = new StringBuilder();
				foreach (string text in array2)
				{
					stringBuilder.Append(text);
					stringBuilder.Append('\0');
				}
				stringBuilder.Append('\0');
				byte[] bytes = Encoding.Unicode.GetBytes(stringBuilder.ToString());
				num2 = Win32RegistryApi.RegSetValueEx(handle, name, IntPtr.Zero, RegistryValueKind.MultiString, bytes, bytes.Length);
			}
			else
			{
				if (type.IsArray)
				{
					throw new ArgumentException("Only string and byte arrays can written as registry values");
				}
				string text2 = string.Format("{0}{1}", value, '\0');
				num2 = Win32RegistryApi.RegSetValueEx(handle, name, IntPtr.Zero, RegistryValueKind.String, text2, text2.Length * this.NativeBytesPerCharacter);
			}
			if (num2 == 1018)
			{
				throw RegistryKey.CreateMarkedForDeletionException();
			}
			if (num2 != 0)
			{
				this.GenerateException(num2);
			}
		}

		// Token: 0x06000779 RID: 1913 RVA: 0x00017890 File Offset: 0x00015A90
		private int GetBinaryValue(RegistryKey rkey, string name, RegistryValueKind type, out byte[] data, int size)
		{
			byte[] array = new byte[size];
			IntPtr handle = Win32RegistryApi.GetHandle(rkey);
			int num = Win32RegistryApi.RegQueryValueEx(handle, name, IntPtr.Zero, ref type, array, ref size);
			data = array;
			return num;
		}

		// Token: 0x0600077A RID: 1914 RVA: 0x000178C4 File Offset: 0x00015AC4
		public int SubKeyCount(RegistryKey rkey)
		{
			StringBuilder stringBuilder = new StringBuilder(1024);
			IntPtr handle = Win32RegistryApi.GetHandle(rkey);
			int num = 0;
			for (;;)
			{
				int num2 = Win32RegistryApi.RegEnumKey(handle, num, stringBuilder, stringBuilder.Capacity);
				if (num2 == 1018)
				{
					break;
				}
				if (num2 != 0)
				{
					if (num2 == 259)
					{
						return num;
					}
					this.GenerateException(num2);
				}
				num++;
			}
			throw RegistryKey.CreateMarkedForDeletionException();
		}

		// Token: 0x0600077B RID: 1915 RVA: 0x00017938 File Offset: 0x00015B38
		public int ValueCount(RegistryKey rkey)
		{
			StringBuilder stringBuilder = new StringBuilder(1024);
			IntPtr handle = Win32RegistryApi.GetHandle(rkey);
			int num = 0;
			for (;;)
			{
				RegistryValueKind registryValueKind = RegistryValueKind.Unknown;
				int capacity = stringBuilder.Capacity;
				int num2 = Win32RegistryApi.RegEnumValue(handle, num, stringBuilder, ref capacity, IntPtr.Zero, ref registryValueKind, IntPtr.Zero, IntPtr.Zero);
				if (num2 == 1018)
				{
					break;
				}
				if (num2 != 0 && num2 != 234)
				{
					if (num2 == 259)
					{
						return num;
					}
					this.GenerateException(num2);
				}
				num++;
			}
			throw RegistryKey.CreateMarkedForDeletionException();
		}

		// Token: 0x0600077C RID: 1916 RVA: 0x000179D0 File Offset: 0x00015BD0
		public RegistryKey OpenRemoteBaseKey(RegistryHive hKey, string machineName)
		{
			IntPtr intPtr = new IntPtr((int)hKey);
			IntPtr intPtr2;
			int num = Win32RegistryApi.RegConnectRegistry(machineName, intPtr, out intPtr2);
			if (num != 0)
			{
				this.GenerateException(num);
			}
			return new RegistryKey(hKey, intPtr2, true);
		}

		// Token: 0x0600077D RID: 1917 RVA: 0x00017A04 File Offset: 0x00015C04
		public RegistryKey OpenSubKey(RegistryKey rkey, string keyName, bool writable)
		{
			int num = 131097;
			if (writable)
			{
				num |= 131078;
			}
			IntPtr handle = Win32RegistryApi.GetHandle(rkey);
			IntPtr intPtr;
			int num2 = Win32RegistryApi.RegOpenKeyEx(handle, keyName, IntPtr.Zero, num, out intPtr);
			if (num2 == 2 || num2 == 1018)
			{
				return null;
			}
			if (num2 != 0)
			{
				this.GenerateException(num2);
			}
			return new RegistryKey(intPtr, Win32RegistryApi.CombineName(rkey, keyName), writable);
		}

		// Token: 0x0600077E RID: 1918 RVA: 0x00017A70 File Offset: 0x00015C70
		public void Flush(RegistryKey rkey)
		{
			if (!Win32RegistryApi.IsHandleValid(rkey))
			{
				return;
			}
			IntPtr handle = Win32RegistryApi.GetHandle(rkey);
			Win32RegistryApi.RegFlushKey(handle);
		}

		// Token: 0x0600077F RID: 1919 RVA: 0x00017A98 File Offset: 0x00015C98
		public void Close(RegistryKey rkey)
		{
			if (!Win32RegistryApi.IsHandleValid(rkey))
			{
				return;
			}
			IntPtr handle = Win32RegistryApi.GetHandle(rkey);
			Win32RegistryApi.RegCloseKey(handle);
		}

		// Token: 0x06000780 RID: 1920 RVA: 0x00017AC0 File Offset: 0x00015CC0
		public RegistryKey CreateSubKey(RegistryKey rkey, string keyName)
		{
			IntPtr handle = Win32RegistryApi.GetHandle(rkey);
			IntPtr intPtr;
			int num = Win32RegistryApi.RegCreateKey(handle, keyName, out intPtr);
			if (num == 1018)
			{
				throw RegistryKey.CreateMarkedForDeletionException();
			}
			if (num != 0)
			{
				this.GenerateException(num);
			}
			return new RegistryKey(intPtr, Win32RegistryApi.CombineName(rkey, keyName), true);
		}

		// Token: 0x06000781 RID: 1921 RVA: 0x00017B10 File Offset: 0x00015D10
		public void DeleteKey(RegistryKey rkey, string keyName, bool shouldThrowWhenKeyMissing)
		{
			IntPtr handle = Win32RegistryApi.GetHandle(rkey);
			int num = Win32RegistryApi.RegDeleteKey(handle, keyName);
			if (num != 2)
			{
				if (num != 0)
				{
					this.GenerateException(num);
				}
				return;
			}
			if (shouldThrowWhenKeyMissing)
			{
				throw new ArgumentException("key " + keyName);
			}
		}

		// Token: 0x06000782 RID: 1922 RVA: 0x00017B58 File Offset: 0x00015D58
		public void DeleteValue(RegistryKey rkey, string value, bool shouldThrowWhenKeyMissing)
		{
			IntPtr handle = Win32RegistryApi.GetHandle(rkey);
			int num = Win32RegistryApi.RegDeleteValue(handle, value);
			if (num == 1018)
			{
				return;
			}
			if (num != 2)
			{
				if (num != 0)
				{
					this.GenerateException(num);
				}
				return;
			}
			if (shouldThrowWhenKeyMissing)
			{
				throw new ArgumentException("value " + value);
			}
		}

		// Token: 0x06000783 RID: 1923 RVA: 0x00017BAC File Offset: 0x00015DAC
		public string[] GetSubKeyNames(RegistryKey rkey)
		{
			IntPtr handle = Win32RegistryApi.GetHandle(rkey);
			StringBuilder stringBuilder = new StringBuilder(1024);
			ArrayList arrayList = new ArrayList();
			int num = 0;
			for (;;)
			{
				int num2 = Win32RegistryApi.RegEnumKey(handle, num, stringBuilder, stringBuilder.Capacity);
				if (num2 == 0)
				{
					arrayList.Add(stringBuilder.ToString());
					stringBuilder.Length = 0;
				}
				else
				{
					if (num2 == 259)
					{
						break;
					}
					this.GenerateException(num2);
				}
				num++;
			}
			return (string[])arrayList.ToArray(typeof(string));
		}

		// Token: 0x06000784 RID: 1924 RVA: 0x00017C40 File Offset: 0x00015E40
		public string[] GetValueNames(RegistryKey rkey)
		{
			IntPtr handle = Win32RegistryApi.GetHandle(rkey);
			ArrayList arrayList = new ArrayList();
			int num = 0;
			for (;;)
			{
				StringBuilder stringBuilder = new StringBuilder(1024);
				int capacity = stringBuilder.Capacity;
				RegistryValueKind registryValueKind = RegistryValueKind.Unknown;
				int num2 = Win32RegistryApi.RegEnumValue(handle, num, stringBuilder, ref capacity, IntPtr.Zero, ref registryValueKind, IntPtr.Zero, IntPtr.Zero);
				if (num2 == 0 || num2 == 234)
				{
					arrayList.Add(stringBuilder.ToString());
				}
				else
				{
					if (num2 == 259)
					{
						break;
					}
					if (num2 == 1018)
					{
						goto Block_3;
					}
					this.GenerateException(num2);
				}
				num++;
			}
			return (string[])arrayList.ToArray(typeof(string));
			Block_3:
			throw RegistryKey.CreateMarkedForDeletionException();
		}

		// Token: 0x06000785 RID: 1925 RVA: 0x00017D04 File Offset: 0x00015F04
		private void GenerateException(int errorCode)
		{
			switch (errorCode)
			{
			case 2:
				break;
			default:
				if (errorCode == 53)
				{
					throw new IOException("The network path was not found.");
				}
				if (errorCode != 87)
				{
					throw new SystemException();
				}
				break;
			case 5:
				throw new SecurityException();
			}
			throw new ArgumentException();
		}

		// Token: 0x06000786 RID: 1926 RVA: 0x00017D5C File Offset: 0x00015F5C
		public string ToString(RegistryKey rkey)
		{
			return rkey.Name;
		}

		// Token: 0x06000787 RID: 1927 RVA: 0x00017D64 File Offset: 0x00015F64
		internal static string CombineName(RegistryKey rkey, string localName)
		{
			return rkey.Name + "\\" + localName;
		}

		// Token: 0x04000109 RID: 265
		private const int OpenRegKeyRead = 131097;

		// Token: 0x0400010A RID: 266
		private const int OpenRegKeyWrite = 131078;

		// Token: 0x0400010B RID: 267
		private const int Int32ByteSize = 4;

		// Token: 0x0400010C RID: 268
		private const int BufferMaxLength = 1024;

		// Token: 0x0400010D RID: 269
		private readonly int NativeBytesPerCharacter = Marshal.SystemDefaultCharSize;
	}
}