using Microsoft.Win32;
using System;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Disco.ClientBootstrapper.Interop
{
    public static class InstallInterop
    {
        [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
        private static extern bool MoveFileEx(string lpExistingFileName, string lpNewFileName, MoveFileFlags dwFlags);
        [Flags]
        private enum MoveFileFlags
        {
            MOVEFILE_REPLACE_EXISTING = 0x00000001,
            MOVEFILE_COPY_ALLOWED = 0x00000002,
            MOVEFILE_DELAY_UNTIL_REBOOT = 0x00000004,
            MOVEFILE_WRITE_THROUGH = 0x00000008,
            MOVEFILE_CREATE_HARDLINK = 0x00000010,
            MOVEFILE_FAIL_IF_NOT_TRACKABLE = 0x00000020
        }

        private static async Task Install(string rootFilesystemLocation, RegistryKey rootRegistryLocation, string filesystemInstallLocation, string virtualRootFilesystemLocation, Uri forcedServerUrl, CancellationToken cancellationToken)
        {
            var SourceLocation = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
            var InstallLocation = Path.Combine(rootFilesystemLocation, filesystemInstallLocation);
            var BootstrapperCmdLinePath = Path.Combine(virtualRootFilesystemLocation, filesystemInstallLocation, "Disco.ClientBootstrapper.exe");

            var GroupPolicyScriptsIniLocation = Path.Combine(rootFilesystemLocation, @"Windows\System32\GroupPolicy\Machine\Scripts\scripts.ini");
            var GroupPolicyScriptsIniBackupLocation = Path.Combine(rootFilesystemLocation, @"Windows\System32\GroupPolicy\Machine\Scripts\disco_scripts.ini");

            // Create file system Location
            #region "Create File System Location"
            Program.Status.UpdateStatus(null, null, "Creating Installation Location");
            await Program.SleepThread(500, false, cancellationToken);
            if (Directory.Exists(InstallLocation))
            {
                // Try and Delete Directory
                try
                {
                    Directory.Delete(InstallLocation, true);
                }
                catch (Exception ex)
                {
                    throw new IOException($"Unable to delete folder: {InstallLocation}", ex);
                }
            }
            if (!Directory.Exists(InstallLocation))
            {
                var installDir = Directory.CreateDirectory(InstallLocation);
                installDir.Attributes = installDir.Attributes | FileAttributes.Hidden;
            }
            cancellationToken.ThrowIfCancellationRequested();
            #endregion

            // Copy files to file system location
            #region "Copy to File System"
            Program.Status.UpdateStatus(null, null, "Copying Files");
            await Program.SleepThread(500, false, cancellationToken);

            // Copy Bootstrapper
            // ie: Executing Assembly
            File.Copy(System.Reflection.Assembly.GetExecutingAssembly().Location, Path.Combine(InstallLocation, "Disco.ClientBootstrapper.exe"));

            cancellationToken.ThrowIfCancellationRequested();

            foreach (var file in Directory.EnumerateFiles(SourceLocation))
            {
                cancellationToken.ThrowIfCancellationRequested();
                var fileName = Path.GetFileName(file);

                // Only Copy Certain Files

                // Copy Wireless Certificates
                if (fileName.StartsWith("WLAN_Cert_Root_", StringComparison.OrdinalIgnoreCase) ||
                    fileName.StartsWith("WLAN_Cert_Intermediate_", StringComparison.OrdinalIgnoreCase) ||
                    fileName.StartsWith("WLAN_Cert_Personal_", StringComparison.OrdinalIgnoreCase))
                    File.Copy(file, Path.Combine(InstallLocation, fileName));

                // Copy Wireless Profiles
                if (fileName.StartsWith("WLAN_Profile_", StringComparison.OrdinalIgnoreCase) &&
                    fileName.EndsWith(".xml", StringComparison.OrdinalIgnoreCase))
                    File.Copy(file, Path.Combine(InstallLocation, fileName));

            }
            #endregion

            // Backup & Create Group Policy Scripts.ini
            #region "Group Policy Scripts.ini"
            Program.Status.UpdateStatus(null, null, "Creating Group Policy Script Entry");
            await Program.SleepThread(500, false, cancellationToken);
            // Backup
            if (!File.Exists(GroupPolicyScriptsIniBackupLocation))
            {
                if (File.Exists(GroupPolicyScriptsIniLocation))
                {
                    File.Move(GroupPolicyScriptsIniLocation, GroupPolicyScriptsIniBackupLocation);
                }
            }
            cancellationToken.ThrowIfCancellationRequested();

            // Create
            if (File.Exists(GroupPolicyScriptsIniLocation))
                File.Delete(GroupPolicyScriptsIniLocation);
            if (!Directory.Exists(Path.GetDirectoryName(GroupPolicyScriptsIniLocation)))
                Directory.CreateDirectory(Path.GetDirectoryName(GroupPolicyScriptsIniLocation));
            using (var scriptsIniStream = File.Open(GroupPolicyScriptsIniLocation, FileMode.Create, FileAccess.Write))
            {
                using (var scriptsIniStreamWriter = new StreamWriter(scriptsIniStream, Encoding.Unicode))
                {
                    scriptsIniStreamWriter.WriteLine("[Startup]");
                    scriptsIniStreamWriter.WriteLine($"0CmdLine={BootstrapperCmdLinePath}");
                    if (forcedServerUrl == null)
                        scriptsIniStreamWriter.WriteLine("0Parameters=/AllowUninstall");
                    else
                        scriptsIniStreamWriter.WriteLine($"0Parameters=/AllowUninstall {forcedServerUrl}");
                }
            }
            cancellationToken.ThrowIfCancellationRequested();
            #endregion

            // Backup & Create Group Policy Registry
            #region "Group Policy Registry"
            Program.Status.UpdateStatus(null, null, "Creating Group Policy Registry Entries");
            await Program.SleepThread(500, false, cancellationToken);
            // Backup Scripts
            using (var regGroupPolicy = rootRegistryLocation.OpenSubKey(@"Microsoft\Windows\CurrentVersion\Group Policy", true))
            {
                if (regGroupPolicy != null && regGroupPolicy.GetSubKeyNames().Contains("Scripts") && !regGroupPolicy.GetSubKeyNames().Contains("Disco_Scripts"))
                {
                    RegistryUtilities.RenameSubKey(regGroupPolicy, "Scripts", "Disco_Scripts");
                }
            }
            cancellationToken.ThrowIfCancellationRequested();

            // Create Scripts
            rootRegistryLocation.CreateSubKey(@"Microsoft\Windows\CurrentVersion\Group Policy\Scripts\Shutdown").Dispose();
            using (var regScriptsStartup = rootRegistryLocation.CreateSubKey(@"Microsoft\Windows\CurrentVersion\Group Policy\Scripts\Startup\0"))
            {
                regScriptsStartup.SetValue("GPO-ID", "LocalGPO", RegistryValueKind.String);
                regScriptsStartup.SetValue("SOM-ID", "Local", RegistryValueKind.String);
                regScriptsStartup.SetValue("FileSysPath", Path.Combine(Environment.SystemDirectory, @"GroupPolicy\Machine"), RegistryValueKind.String);
                regScriptsStartup.SetValue("DisplayName", "Local Group Policy", RegistryValueKind.String);
                regScriptsStartup.SetValue("GPOName", "Local Group Policy", RegistryValueKind.String);
                regScriptsStartup.SetValue("PSScriptOrder", 1, RegistryValueKind.DWord);
                using (var regScriptsStartup0 = regScriptsStartup.CreateSubKey("0"))
                {
                    regScriptsStartup0.SetValue("Script", BootstrapperCmdLinePath, RegistryValueKind.String);
                    if (forcedServerUrl == null)
                        regScriptsStartup0.SetValue("Parameters", "/AllowUninstall", RegistryValueKind.String);
                    else
                        regScriptsStartup0.SetValue("Parameters", $"/AllowUninstall {forcedServerUrl}", RegistryValueKind.String);
                    regScriptsStartup0.SetValue("IsPowershell", 0, RegistryValueKind.DWord);
                    regScriptsStartup0.SetValue("ExecTime", new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, RegistryValueKind.Binary);
                }
            }
            rootRegistryLocation.CreateSubKey(@"Microsoft\Windows\CurrentVersion\Group Policy\State\Machine\Scripts\Shutdown").Dispose();
            cancellationToken.ThrowIfCancellationRequested();

            // Backup Scripts State
            using (var regGroupPolicy = rootRegistryLocation.OpenSubKey(@"Microsoft\Windows\CurrentVersion\Group Policy\State\Machine", true))
            {
                if (regGroupPolicy != null && regGroupPolicy.GetSubKeyNames().Contains("Scripts") && !regGroupPolicy.GetSubKeyNames().Contains("Disco_Scripts"))
                {
                    RegistryUtilities.RenameSubKey(regGroupPolicy, "Scripts", "Disco_Scripts");
                }
            }
            cancellationToken.ThrowIfCancellationRequested();

            // Create Scripts State
            using (var regStateScriptsStartup = rootRegistryLocation.CreateSubKey(@"Microsoft\Windows\CurrentVersion\Group Policy\State\Machine\Scripts\Startup\0"))
            {
                regStateScriptsStartup.SetValue("GPO-ID", "LocalGPO", RegistryValueKind.String);
                regStateScriptsStartup.SetValue("SOM-ID", "Local", RegistryValueKind.String);
                regStateScriptsStartup.SetValue("FileSysPath", Path.Combine(Environment.SystemDirectory, "GroupPolicy\\Machine"), RegistryValueKind.String);
                regStateScriptsStartup.SetValue("DisplayName", "Local Group Policy", RegistryValueKind.String);
                regStateScriptsStartup.SetValue("GPOName", "Local Group Policy", RegistryValueKind.String);
                regStateScriptsStartup.SetValue("PSScriptOrder", 1, RegistryValueKind.DWord);
                using (var regStateScriptsStartup0 = regStateScriptsStartup.CreateSubKey("0"))
                {
                    regStateScriptsStartup0.SetValue("Script", BootstrapperCmdLinePath, RegistryValueKind.String);
                    if (forcedServerUrl == null)
                        regStateScriptsStartup0.SetValue("Parameters", "/AllowUninstall", RegistryValueKind.String);
                    else
                        regStateScriptsStartup0.SetValue("Parameters", $"/AllowUninstall {forcedServerUrl}", RegistryValueKind.String);
                    regStateScriptsStartup0.SetValue("ExecTime", new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, RegistryValueKind.Binary);
                }
            }
            cancellationToken.ThrowIfCancellationRequested();
            #endregion

            // Set Registry Startup Environment Policies
            #region "Registry Startup Policies"
            Program.Status.UpdateStatus(null, null, "Creating Startup Policy Registry Entries");
            await Program.SleepThread(500, false, cancellationToken);
            using (var regWinlogon = rootRegistryLocation.OpenSubKey(@"Microsoft\Windows NT\CurrentVersion\Winlogon", true))
            {
                regWinlogon.SetValue("HideStartupScripts", 0, RegistryValueKind.DWord);
                regWinlogon.SetValue("RunStartupScriptSync", 1, RegistryValueKind.DWord);
            }
            #endregion
        }

        public static async Task Install(string installLocation, string wimImageId, string tempPath, Uri forcedServerUrl, CancellationToken cancellationToken)
        {
            Program.Status.UpdateStatus("Installing Bootstrapper", "Starting", "Please wait...", false);

            if (string.IsNullOrWhiteSpace(installLocation))
                installLocation = Path.Combine(Path.GetPathRoot(Environment.SystemDirectory), "Disco");

            cancellationToken.ThrowIfCancellationRequested();

            if (installLocation.EndsWith(".wim", StringComparison.OrdinalIgnoreCase))
            {
                // Offline File System (WIM)
                Program.Status.UpdateStatus("Installing Bootstrapper (Offline)", "Installing", $"Install Location: {installLocation}");
                await Program.SleepThread(1000, false, cancellationToken);

                // Mount WIM
                int wimImageIndex = 0;
                using (var wim = new WIMInterop.WindowsImageContainer(installLocation, WIMInterop.WindowsImageContainer.CreateFileMode.OpenExisting, WIMInterop.WindowsImageContainer.CreateFileAccess.Write))
                {
                    cancellationToken.ThrowIfCancellationRequested();
                    if (wimImageId == null)
                        wimImageId = "1";
                    if (!int.TryParse(wimImageId, out wimImageIndex))
                    {
                        Program.Status.UpdateStatus(null, "Analysing WIM", $"Looking for Image Name: {wimImageId}");
                        await Program.SleepThread(500, false, cancellationToken);
                        for (int i = 0; i < wim.ImageCount; i++)
                        {
                            var wimImageInfo = new System.Xml.XmlDocument();
                            using (var wimImage = wim[i])
                                wimImageInfo.LoadXml(wimImage.ImageInformation);
                            var wimImageInfoName = wimImageInfo.SelectSingleNode("//IMAGE/NAME");
                            if (wimImageInfoName != null && wimImageInfoName.InnerText.Equals(wimImageId, StringComparison.OrdinalIgnoreCase))
                            {
                                wimImageIndex = i + 1;
                                Program.Status.UpdateStatus(null, "Analysing WIM", $"Found Image Id '{wimImageId}' at Index {wimImageIndex}");
                                await Program.SleepThread(500, false, cancellationToken);
                                break;
                            }
                        }
                    }
                }
                cancellationToken.ThrowIfCancellationRequested();
                if (wimImageIndex == 0)
                {
                    Program.Status.UpdateStatus(null, "Error", $"Unable to load WIM Image Id: {wimImageId}");
                    await Program.SleepThread(5000, false, cancellationToken);
                    return;
                }

                // Get Temp Path
                var wimMountPath = Path.Combine(tempPath ?? Path.GetTempPath(), "DiscoClientBootstrapperWimMount");
                if (Directory.Exists(wimMountPath))
                    Directory.Delete(wimMountPath, true);
                Directory.CreateDirectory(wimMountPath);

                cancellationToken.ThrowIfCancellationRequested();

                var wimTempMountPath = Path.Combine(tempPath ?? Path.GetTempPath(), "DiscoClientBootstrapperWimTempMount");
                if (Directory.Exists(wimTempMountPath))
                    Directory.Delete(wimTempMountPath, true);
                Directory.CreateDirectory(wimTempMountPath);

                cancellationToken.ThrowIfCancellationRequested();

                bool wimCommitChanges = true;
                WIMInterop.WindowsImageContainer.NativeMethods.MessageCallback m_MessageCallback = null;
                try
                {
                    // Mount WIM
                    Program.Status.UpdateStatus(null, "Mounting WIM", $"Mounting WIM Image to '{wimMountPath}'");
                    await Program.SleepThread(500, false, cancellationToken);
                    m_MessageCallback = new WIMInterop.WindowsImageContainer.NativeMethods.MessageCallback(WimImageEventMessagePump);
                    WIMInterop.WindowsImageContainer.NativeMethods.RegisterCallback(m_MessageCallback);

                    WIMInterop.WindowsImageContainer.NativeMethods.MountImage(wimMountPath, installLocation, wimImageIndex, wimTempMountPath);

                    // Load Local Machine Registry
                    var wimHivePath = Path.Combine(wimMountPath, "Windows\\System32\\config\\SOFTWARE");
                    Program.Status.UpdateStatus(null, "Mounting Offline Registry Hive", $"Mounting Offline Registry Hive at '{wimHivePath}'");
                    await Program.SleepThread(500, false, cancellationToken);
                    using (var wimReg = new RegistryInterop(RegistryInterop.RegistryHives.HKEY_LOCAL_MACHINE, "DiscoClientBootstrapperWimHive", wimHivePath))
                    {
                        try
                        {
                            cancellationToken.ThrowIfCancellationRequested();
                            using (RegistryKey rootRegistryLocation = Registry.LocalMachine.OpenSubKey("DiscoClientBootstrapperWimHive", true))
                            {
                                string rootFileSystemLocation = wimMountPath;
                                string fileSystemInstallLocation = "Disco";
                                string virtualRootFileSystemLocation = "C:\\";

                                cancellationToken.ThrowIfCancellationRequested();
                                await Install(rootFileSystemLocation, rootRegistryLocation, fileSystemInstallLocation, virtualRootFileSystemLocation, forcedServerUrl, cancellationToken);
                                cancellationToken.ThrowIfCancellationRequested();
                            }
                        }
                        finally
                        {
                            // Unload Local Machine Registry
                            Program.Status.UpdateStatus(null, "Unmounting Offline Registry Hive", $"Unmounting Offline Registry Hive at '{wimHivePath}'");
                            await Program.SleepThread(500, false, cancellationToken);
                            wimReg.Unload();
                        }
                    }
                }
                catch (Exception)
                {
                    wimCommitChanges = false;
                    throw;
                }
                finally
                {
                    // Unmount WIM
                    Program.Status.UpdateStatus(null, "Unmounting WIM", $"Unmounting WIM Image at '{wimMountPath}'");
                    await Program.SleepThread(500, false, cancellationToken);
                    WIMInterop.WindowsImageContainer.NativeMethods.DismountImage(wimMountPath, installLocation, wimImageIndex, wimCommitChanges);

                    if (m_MessageCallback != null)
                    {
                        WIMInterop.WindowsImageContainer.NativeMethods.UnregisterMessageCallback(m_MessageCallback);
                        m_MessageCallback = null;
                    }

                    if (Directory.Exists(wimMountPath))
                        Directory.Delete(wimMountPath, true);
                    if (Directory.Exists(wimTempMountPath))
                        Directory.Delete(wimTempMountPath, true);

                    cancellationToken.ThrowIfCancellationRequested();
                }
            }
            else
            {
                // Online File System
                Program.Status.UpdateStatus("Installing Bootstrapper (Online)", "Installing", $"Install Location: {installLocation}", true, -1);
                await Program.SleepThread(1000, false, cancellationToken);
                string rootFileSystemLocation = Path.GetPathRoot(installLocation);
                RegistryKey rootRegistryLocation = Registry.LocalMachine.OpenSubKey("SOFTWARE", true);
                string fileSystemInstallLocation = installLocation.Substring(rootFileSystemLocation.Length);

                await Install(rootFileSystemLocation, rootRegistryLocation, fileSystemInstallLocation, rootFileSystemLocation, forcedServerUrl, cancellationToken);
                Program.Status.UpdateStatus(null, "Online File System Installation Complete", string.Empty, true, -1);
                await Program.SleepThread(1000, false, cancellationToken);
            }
            Program.Status.UpdateStatus(null, "Complete", "Finished Installing Bootstrapper");
            await Program.SleepThread(1500, false, cancellationToken);
        }

        private static uint WimImageEventMessagePump(
            uint MessageId,
            IntPtr wParam,
            IntPtr lParam,
            IntPtr UserData
        )
        {
            uint status = (uint)WIMInterop.WindowsImageContainer.NativeMethods.WIMMessage.WIM_MSG_SUCCESS;
            WIMInterop.DefaultImageEventArgs eventArgs = new WIMInterop.DefaultImageEventArgs(wParam, lParam, UserData);

            //System.Diagnostics.Debug.WriteLine(MessageId);

            switch ((WIMInterop.WindowsImageContainer.ImageEventMessage)MessageId)
            {

                case WIMInterop.WindowsImageContainer.ImageEventMessage.Progress:
                case WIMInterop.WindowsImageContainer.ImageEventMessage.MountCleanupProgress:
                    var timeRemainingMil = eventArgs.LeftParameter.ToInt32();
                    string timeRemainingMessage;
                    if (timeRemainingMil > 0)
                        timeRemainingMessage = TimeSpan.FromMilliseconds(timeRemainingMil).ToString(@"hh\:mm\:ss");
                    else
                        timeRemainingMessage = "Calculating, please wait...";

                    var progress = eventArgs.WideParameter.ToInt32();
                    Program.Status.UpdateStatus(null, null, $"Time remaining: {timeRemainingMessage}", true, progress);

                    break;
                default:
                    break;
            }

            return status;
        }

        public static async Task Uninstall(CancellationToken cancellationToken)
        {
            // Application Directory
            var appDirectory = Path.GetDirectoryName(typeof(Program).Assembly.Location);
            if (Program.AllowUninstall && !appDirectory.StartsWith(@"\\"))
            {
                Program.Status.UpdateStatus("System Preparation (Bootstrapper)", "Uninstalling Bootstrapper...", string.Empty, false, 0);
                await Program.SleepThread(1000, true, cancellationToken);

                // Remove Registry Entries
                using (var regWinlogon = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon", true))
                {
                    regWinlogon.DeleteValue("HideStartupScripts", false);
                    regWinlogon.DeleteValue("RunStartupScriptSync", false);
                }
                Registry.LocalMachine.DeleteSubKeyTree(@"SOFTWARE\Microsoft\Windows\CurrentVersion\Group Policy\Scripts\Shutdown", false);
                Registry.LocalMachine.DeleteSubKeyTree(@"SOFTWARE\Microsoft\Windows\CurrentVersion\Group Policy\Scripts\Startup", false);
                Registry.LocalMachine.DeleteSubKeyTree(@"SOFTWARE\Microsoft\Windows\CurrentVersion\Group Policy\State\Machine\Scripts\Shutdown", false);
                Registry.LocalMachine.DeleteSubKeyTree(@"SOFTWARE\Microsoft\Windows\CurrentVersion\Group Policy\State\Machine\Scripts\Startup", false);

                // Restore Registry Backups
                using (var regGroupPolicy = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Windows\CurrentVersion\Group Policy", true))
                {
                    if (regGroupPolicy != null && regGroupPolicy.GetSubKeyNames().Contains("Disco_Scripts"))
                    {
                        regGroupPolicy.DeleteSubKeyTree("Scripts");
                        RegistryUtilities.RenameSubKey(regGroupPolicy, "Disco_Scripts", "Scripts");
                    }
                }
                using (var regGroupPolicy = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Windows\CurrentVersion\Group Policy\State\Machine", true))
                {
                    if (regGroupPolicy != null && regGroupPolicy.GetSubKeyNames().Contains("Disco_Scripts"))
                    {
                        regGroupPolicy.DeleteSubKeyTree("Scripts");
                        RegistryUtilities.RenameSubKey(regGroupPolicy, "Disco_Scripts", "Scripts");
                    }
                }

                // Delete Group Policy Script File
                var groupPolicyScriptsPath = Path.Combine(Environment.SystemDirectory, @"GroupPolicy\Machine\Scripts\scripts.ini");
                if (File.Exists(groupPolicyScriptsPath))
                    File.Delete(groupPolicyScriptsPath);
                var groupPolicyScriptsBackupPath = Path.Combine(Environment.SystemDirectory, @"GroupPolicy\Machine\Scripts\disco_scripts.ini");
                if (File.Exists(groupPolicyScriptsBackupPath))
                    File.Move(groupPolicyScriptsBackupPath, groupPolicyScriptsPath);

                // Queue Folder for Deletion at next startup
                ForceDeleteFolder(new DirectoryInfo(appDirectory));
            }
        }

        private static void ForceDeleteFolder(DirectoryInfo d)
        {
            foreach (var sd in d.GetDirectories())
                ForceDeleteFolder(sd);
            foreach (var f in d.GetFiles())
            {
                try
                {
                    File.Delete(f.FullName);
                }
                catch (Exception)
                {
                    MoveFileEx(f.FullName, null, MoveFileFlags.MOVEFILE_DELAY_UNTIL_REBOOT);
                }
            }

            try
            {
                Directory.Delete(d.FullName);
            }
            catch (Exception)
            {
                MoveFileEx(d.FullName, null, MoveFileFlags.MOVEFILE_DELAY_UNTIL_REBOOT);
            }
        }
    }

    public static class RegistryUtilities
    {
        /// <summary>
        /// Renames a subkey of the passed in registry key since 
        /// the Framework totally forgot to include such a handy feature.
        /// </summary>
        /// <param name="regKey">The RegistryKey that contains the subkey 
        /// you want to rename (must be writeable)</param>
        /// <param name="subKeyName">The name of the subkey that you want to rename
        /// </param>
        /// <param name="newSubKeyName">The new name of the RegistryKey</param>
        /// <returns>True if succeeds</returns>
        public static bool RenameSubKey(RegistryKey parentKey,
            string subKeyName, string newSubKeyName)
        {
            CopyKey(parentKey, subKeyName, newSubKeyName);
            parentKey.DeleteSubKeyTree(subKeyName);
            return true;
        }

        /// <summary>
        /// Copy a registry key.  The parentKey must be writeable.
        /// </summary>
        /// <param name="parentKey"></param>
        /// <param name="keyNameToCopy"></param>
        /// <param name="newKeyName"></param>
        /// <returns></returns>
        public static bool CopyKey(RegistryKey parentKey,
            string keyNameToCopy, string newKeyName)
        {
            //Create new key
            using (RegistryKey destinationKey = parentKey.CreateSubKey(newKeyName))
            {
                //Open the sourceKey we are copying from
                using (RegistryKey sourceKey = parentKey.OpenSubKey(keyNameToCopy))
                {
                    RecurseCopyKey(sourceKey, destinationKey);
                }
            }

            return true;
        }

        private static void RecurseCopyKey(RegistryKey sourceKey, RegistryKey destinationKey)
        {
            //copy all the values
            foreach (string valueName in sourceKey.GetValueNames())
            {
                object objValue = sourceKey.GetValue(valueName);
                RegistryValueKind valKind = sourceKey.GetValueKind(valueName);

                if (valueName == "ExecTime")
                {
                    destinationKey.SetValue(valueName, objValue, RegistryValueKind.Binary);
                }
                else
                {
                    destinationKey.SetValue(valueName, objValue, valKind);
                }
            }

            //For Each subKey 
            //Create a new subKey in destinationKey 
            //Call myself 
            foreach (string sourceSubKeyName in sourceKey.GetSubKeyNames())
            {
                using (RegistryKey sourceSubKey = sourceKey.OpenSubKey(sourceSubKeyName))
                {
                    using (RegistryKey destSubKey = destinationKey.CreateSubKey(sourceSubKeyName))
                    {
                        RecurseCopyKey(sourceSubKey, destSubKey);
                    }
                }
            }
        }
    }


}