using Microsoft.Win32;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security;
using System.Text;
using System.Threading.Tasks;

namespace Ramitta.lib
{
    /// <summary>
    /// 注册表操作类 - 提供完整的注册表增删改查功能
    /// </summary>
    public static class RegistryOperations
    {
        #region 枚举定义

        /// <summary>
        /// 注册表值类型
        /// </summary>
        public enum RegValueKind
        {
            String = 1,
            ExpandString = 2,
            Binary = 3,
            DWord = 4,
            MultiString = 7,
            QWord = 11
        }

        /// <summary>
        /// 注册表根键类型
        /// </summary>
        public enum RegRootKey
        {
            ClassesRoot,
            CurrentUser,
            LocalMachine,
            Users,
            CurrentConfig
        }

        #endregion

        #region 私有方法

        /// <summary>
        /// 解析完整注册表路径
        /// </summary>
        private static (RegRootKey rootKey, string relativePath) ParseFullPath(string fullPath)
        {
            if (string.IsNullOrWhiteSpace(fullPath))
                throw new ArgumentException("注册表路径不能为空");

            string[] parts = fullPath.Split('\\');
            if (parts.Length < 1)
                throw new ArgumentException("无效的注册表路径格式");

            string rootStr = parts[0].ToUpper();
            string relativePath = parts.Length > 1 ? string.Join("\\", parts.Skip(1)) : "";

            return rootStr switch
            {
                "HKEY_CLASSES_ROOT" or "HKCR" => (RegRootKey.ClassesRoot, relativePath),
                "HKEY_CURRENT_USER" or "HKCU" => (RegRootKey.CurrentUser, relativePath),
                "HKEY_LOCAL_MACHINE" or "HKLM" => (RegRootKey.LocalMachine, relativePath),
                "HKEY_USERS" or "HKU" => (RegRootKey.Users, relativePath),
                "HKEY_CURRENT_CONFIG" or "HKCC" => (RegRootKey.CurrentConfig, relativePath),
                _ => throw new ArgumentException($"不支持的注册表根键: {parts[0]}")
            };
        }

        /// <summary>
        /// 获取RegistryKey根键
        /// </summary>
        private static RegistryKey GetRootRegistryKey(RegRootKey rootKey)
        {
            return rootKey switch
            {
                RegRootKey.ClassesRoot => Registry.ClassesRoot,
                RegRootKey.CurrentUser => Registry.CurrentUser,
                RegRootKey.LocalMachine => Registry.LocalMachine,
                RegRootKey.Users => Registry.Users,
                RegRootKey.CurrentConfig => Registry.CurrentConfig,
                _ => throw new ArgumentException($"不支持的根键类型: {rootKey}")
            };
        }

        /// <summary>
        /// 转换值类型
        /// </summary>
        private static RegistryValueKind ToRegistryValueKind(RegValueKind valueKind)
        {
            return valueKind switch
            {
                RegValueKind.String => RegistryValueKind.String,
                RegValueKind.ExpandString => RegistryValueKind.ExpandString,
                RegValueKind.Binary => RegistryValueKind.Binary,
                RegValueKind.DWord => RegistryValueKind.DWord,
                RegValueKind.MultiString => RegistryValueKind.MultiString,
                RegValueKind.QWord => RegistryValueKind.QWord,
                _ => RegistryValueKind.Unknown
            };
        }

        #endregion

        #region 查询操作

        /// <summary>
        /// 检查注册表项是否存在
        /// </summary>
        /// <param name="fullPath">完整注册表路径</param>
        /// <returns>是否存在</returns>
        public static bool KeyExists(string fullPath)
        {
            try
            {
                var (rootKey, relativePath) = ParseFullPath(fullPath);
                using RegistryKey root = GetRootRegistryKey(rootKey);
                using RegistryKey key = root.OpenSubKey(relativePath);
                return key != null;
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// 检查注册表值是否存在
        /// </summary>
        /// <param name="fullPath">完整注册表路径</param>
        /// <param name="valueName">值名称</param>
        /// <returns>是否存在</returns>
        public static bool ValueExists(string fullPath, string valueName)
        {
            try
            {
                var (rootKey, relativePath) = ParseFullPath(fullPath);
                using RegistryKey root = GetRootRegistryKey(rootKey);
                using RegistryKey key = root.OpenSubKey(relativePath);
                return key?.GetValue(valueName) != null;
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// 读取注册表值
        /// </summary>
        /// <param name="fullPath">完整注册表路径</param>
        /// <param name="valueName">值名称</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns>读取到的值，如果不存在返回默认值</returns>
        public static object ReadValue(string fullPath, string valueName, object defaultValue = null)
        {
            try
            {
                var (rootKey, relativePath) = ParseFullPath(fullPath);
                using RegistryKey root = GetRootRegistryKey(rootKey);
                using RegistryKey key = root.OpenSubKey(relativePath);

                return key?.GetValue(valueName, defaultValue) ?? defaultValue;
            }
            catch (SecurityException ex)
            {
                throw new UnauthorizedAccessException($"没有权限读取注册表路径: {fullPath}", ex);
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException($"读取注册表值时发生错误: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// 读取字符串值
        /// </summary>
        public static string ReadString(string fullPath, string valueName, string defaultValue = "")
        {
            return ReadValue(fullPath, valueName, defaultValue) as string ?? defaultValue;
        }

        /// <summary>
        /// 读取整数值(DWORD)
        /// </summary>
        public static int ReadDWord(string fullPath, string valueName, int defaultValue = 0)
        {
            object value = ReadValue(fullPath, valueName, defaultValue);
            return value is int intValue ? intValue : defaultValue;
        }

        /// <summary>
        /// 读取长整数值(QWORD)
        /// </summary>
        public static long ReadQWord(string fullPath, string valueName, long defaultValue = 0)
        {
            object value = ReadValue(fullPath, valueName, defaultValue);
            return value is long longValue ? longValue : defaultValue;
        }

        /// <summary>
        /// 读取二进制值
        /// </summary>
        public static byte[] ReadBinary(string fullPath, string valueName, byte[] defaultValue = null)
        {
            object value = ReadValue(fullPath, valueName, defaultValue);
            return value as byte[] ?? defaultValue ?? Array.Empty<byte>();
        }

        /// <summary>
        /// 读取多字符串值
        /// </summary>
        public static string[] ReadMultiString(string fullPath, string valueName, string[] defaultValue = null)
        {
            object value = ReadValue(fullPath, valueName, defaultValue);
            return value as string[] ?? defaultValue ?? Array.Empty<string>();
        }

        /// <summary>
        /// 获取所有子键名称
        /// </summary>
        public static string[] GetSubKeyNames(string fullPath)
        {
            try
            {
                var (rootKey, relativePath) = ParseFullPath(fullPath);
                using RegistryKey root = GetRootRegistryKey(rootKey);
                using RegistryKey key = root.OpenSubKey(relativePath);

                return key?.GetSubKeyNames() ?? Array.Empty<string>();
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException($"获取子键列表失败: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// 获取所有值名称
        /// </summary>
        public static string[] GetValueNames(string fullPath)
        {
            try
            {
                var (rootKey, relativePath) = ParseFullPath(fullPath);
                using RegistryKey root = GetRootRegistryKey(rootKey);
                using RegistryKey key = root.OpenSubKey(relativePath);

                return key?.GetValueNames() ?? Array.Empty<string>();
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException($"获取值名称列表失败: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// 获取值的数据类型
        /// </summary>
        public static RegValueKind? GetValueKind(string fullPath, string valueName)
        {
            try
            {
                var (rootKey, relativePath) = ParseFullPath(fullPath);
                using RegistryKey root = GetRootRegistryKey(rootKey);
                using RegistryKey key = root.OpenSubKey(relativePath);

                if (key == null) return null;

                RegistryValueKind kind = key.GetValueKind(valueName);
                return (RegValueKind)kind;
            }
            catch
            {
                return null;
            }
        }

        #endregion

        #region 新增操作

        /// <summary>
        /// 创建注册表项
        /// </summary>
        /// <param name="fullPath">完整注册表路径</param>
        /// <returns>是否创建成功</returns>
        public static bool CreateKey(string fullPath)
        {
            try
            {
                var (rootKey, relativePath) = ParseFullPath(fullPath);
                using RegistryKey root = GetRootRegistryKey(rootKey);
                using RegistryKey key = root.CreateSubKey(relativePath);
                return key != null;
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException($"创建注册表项失败: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// 写入注册表值
        /// </summary>
        /// <param name="fullPath">完整注册表路径</param>
        /// <param name="valueName">值名称</param>
        /// <param name="value">值数据</param>
        /// <param name="valueKind">值类型</param>
        public static void WriteValue(string fullPath, string valueName, object value, RegValueKind valueKind = RegValueKind.String)
        {
            try
            {
                var (rootKey, relativePath) = ParseFullPath(fullPath);
                using RegistryKey root = GetRootRegistryKey(rootKey);
                using RegistryKey key = root.CreateSubKey(relativePath);

                if (key == null)
                    throw new InvalidOperationException($"无法创建或打开注册表项: {fullPath}");

                RegistryValueKind registryValueKind = ToRegistryValueKind(valueKind);
                key.SetValue(valueName, value, registryValueKind);
            }
            catch (SecurityException ex)
            {
                throw new UnauthorizedAccessException($"没有权限写入注册表路径: {fullPath}", ex);
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException($"写入注册表值时发生错误: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// 写入字符串值
        /// </summary>
        public static void WriteString(string fullPath, string valueName, string value)
        {
            WriteValue(fullPath, valueName, value, RegValueKind.String);
        }

        /// <summary>
        /// 写入扩展字符串值
        /// </summary>
        public static void WriteExpandString(string fullPath, string valueName, string value)
        {
            WriteValue(fullPath, valueName, value, RegValueKind.ExpandString);
        }

        /// <summary>
        /// 写入DWORD值
        /// </summary>
        public static void WriteDWord(string fullPath, string valueName, int value)
        {
            WriteValue(fullPath, valueName, value, RegValueKind.DWord);
        }

        /// <summary>
        /// 写入QWORD值
        /// </summary>
        public static void WriteQWord(string fullPath, string valueName, long value)
        {
            WriteValue(fullPath, valueName, value, RegValueKind.QWord);
        }

        /// <summary>
        /// 写入二进制值
        /// </summary>
        public static void WriteBinary(string fullPath, string valueName, byte[] value)
        {
            WriteValue(fullPath, valueName, value, RegValueKind.Binary);
        }

        /// <summary>
        /// 写入多字符串值
        /// </summary>
        public static void WriteMultiString(string fullPath, string valueName, string[] value)
        {
            WriteValue(fullPath, valueName, value, RegValueKind.MultiString);
        }

        #endregion

        #region 修改操作

        /// <summary>
        /// 重命名注册表值
        /// </summary>
        /// <param name="fullPath">完整注册表路径</param>
        /// <param name="oldValueName">原值名称</param>
        /// <param name="newValueName">新值名称</param>
        public static void RenameValue(string fullPath, string oldValueName, string newValueName)
        {
            try
            {
                // 读取原值
                object value = ReadValue(fullPath, oldValueName);
                RegValueKind? kind = GetValueKind(fullPath, oldValueName);

                if (value == null || kind == null)
                    throw new InvalidOperationException($"原值不存在或无法读取: {oldValueName}");

                // 写入新值
                WriteValue(fullPath, newValueName, value, kind.Value);

                // 删除原值
                DeleteValue(fullPath, oldValueName);
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException($"重命名注册表值失败: {ex.Message}", ex);
            }
        }

        #endregion

        #region 删除操作

        /// <summary>
        /// 删除注册表值
        /// </summary>
        /// <param name="fullPath">完整注册表路径</param>
        /// <param name="valueName">值名称</param>
        /// <returns>是否删除成功</returns>
        public static bool DeleteValue(string fullPath, string valueName)
        {
            try
            {
                var (rootKey, relativePath) = ParseFullPath(fullPath);
                using RegistryKey root = GetRootRegistryKey(rootKey);
                using RegistryKey key = root.OpenSubKey(relativePath, true);

                if (key == null) return false;

                key.DeleteValue(valueName, false);
                return true;
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException($"删除注册表值失败: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// 删除注册表项
        /// </summary>
        /// <param name="fullPath">完整注册表路径</param>
        /// <param name="recursive">是否递归删除所有子项</param>
        /// <returns>是否删除成功</returns>
        public static bool DeleteKey(string fullPath, bool recursive = true)
        {
            try
            {
                var (rootKey, relativePath) = ParseFullPath(fullPath);
                using RegistryKey root = GetRootRegistryKey(rootKey);

                if (recursive)
                {
                    root.DeleteSubKeyTree(relativePath, false);
                }
                else
                {
                    root.DeleteSubKey(relativePath, false);
                }
                return true;
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException($"删除注册表项失败: {ex.Message}", ex);
            }
        }

        #endregion

        #region 高级功能

        /// <summary>
        /// 递归获取所有子键
        /// </summary>
        public static List<string> GetAllSubKeys(string fullPath, int maxDepth = 10)
        {
            List<string> results = new List<string>();
            GetAllSubKeysRecursive(fullPath, results, 0, maxDepth);
            return results;
        }

        private static void GetAllSubKeysRecursive(string currentPath, List<string> results, int currentDepth, int maxDepth)
        {
            if (currentDepth >= maxDepth) return;

            try
            {
                string[] subKeys = GetSubKeyNames(currentPath);
                foreach (string subKey in subKeys)
                {
                    string subKeyPath = $"{currentPath}\\{subKey}";
                    results.Add(subKeyPath);
                    GetAllSubKeysRecursive(subKeyPath, results, currentDepth + 1, maxDepth);
                }
            }
            catch
            {
                // 忽略无权限访问的键
            }
        }

        /// <summary>
        /// 备份注册表项到文件
        /// </summary>
        public static async Task BackupToFile(string fullPath, string outputFilePath)
        {
            try
            {
                var (rootKey, relativePath) = ParseFullPath(fullPath);
                using RegistryKey root = GetRootRegistryKey(rootKey);
                using RegistryKey key = root.OpenSubKey(relativePath);

                if (key == null)
                    throw new InvalidOperationException($"注册表项不存在: {fullPath}");

                StringBuilder sb = new StringBuilder();
                sb.AppendLine($"注册表备份: {fullPath}");
                sb.AppendLine($"备份时间: {DateTime.Now}");
                sb.AppendLine("=" + new string('=', 50));

                // 备份值
                string[] valueNames = key.GetValueNames();
                foreach (string valueName in valueNames)
                {
                    object value = key.GetValue(valueName);
                    RegistryValueKind kind = key.GetValueKind(valueName);
                    sb.AppendLine($"值: {valueName ?? "(默认)"}");
                    sb.AppendLine($"类型: {kind}");
                    sb.AppendLine($"数据: {ConvertValueToString(value, kind)}");
                    sb.AppendLine();
                }

                // 备份子键结构
                sb.AppendLine("子键结构:");
                BackupSubKeysRecursive(key, sb, 1);

                await File.WriteAllTextAsync(outputFilePath, sb.ToString(), Encoding.UTF8);
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException($"备份注册表失败: {ex.Message}", ex);
            }
        }

        private static void BackupSubKeysRecursive(RegistryKey parentKey, StringBuilder sb, int depth)
        {
            string[] subKeyNames = parentKey.GetSubKeyNames();
            foreach (string subKeyName in subKeyNames)
            {
                sb.AppendLine($"{new string(' ', depth * 2)}[{subKeyName}]");
                using RegistryKey subKey = parentKey.OpenSubKey(subKeyName);
                if (subKey != null)
                {
                    BackupSubKeysRecursive(subKey, sb, depth + 1);
                }
            }
        }

        private static string ConvertValueToString(object value, RegistryValueKind kind)
        {
            return kind switch
            {
                RegistryValueKind.String or RegistryValueKind.ExpandString => value as string ?? string.Empty,
                RegistryValueKind.DWord => ((int)value).ToString(),
                RegistryValueKind.QWord => ((long)value).ToString(),
                RegistryValueKind.Binary => BitConverter.ToString((byte[])value),
                RegistryValueKind.MultiString => string.Join("; ", (string[])value),
                _ => value?.ToString() ?? string.Empty
            };
        }

        #endregion
    }
}