using System.IO;

namespace DeviceService.Driver
{
    /// <summary>
    /// 一个已隔离加载的驱动包（对应驱动根目录下的一个子文件夹）。
    /// </summary>
    public sealed class DriverPackage
    {
        /// <summary>子文件夹名（通常为厂商/设备名）</summary>
        public string Folder { get; set; }

        /// <summary>驱动包所在物理目录</summary>
        public string Directory { get; set; }

        /// <summary>驱动包专属 AppDomain</summary>
        public AppDomain Domain { get; set; }

        /// <summary>运行在该域内的加载器代理</summary>
        public DriverLoader Loader { get; set; }

        /// <summary>该包内的程序集与公开类型</summary>
        public DriverAssemblyInfo[] Assemblies { get; set; }
    }

    /// <summary>
    /// (类型, 品牌) 查找结果。
    /// </summary>
    public sealed class DriverFindResult
    {
        public DriverPackage Package { get; set; }
        public DriverTypeInfo Info { get; set; }
    }

    /// <summary>
    /// 驱动管理器：扫描根目录下所有子文件夹，每个子文件夹一个隔离域。
    ///
    /// 适用于"不同厂商提供的驱动 dll 之间没有任何契约"的场景：
    /// - 驱动 dll 不需要实现接口、不需要引用宿主程序集；
    /// - 宿主只通过反射枚举类型/方法、创建实例、调用方法；
    /// - 每个驱动包自带自己的依赖，互不干扰（可存在同名不同版本）；
    /// - 需要替换驱动文件时先卸载域，文件不会被锁定（影子复制）。
    /// </summary>
    public sealed class DriverManager
    {
        private static DriverManager _instance;

        public static DriverManager Instance
        {
            get
            {
                if (_instance == null)
                {
                    _instance = new DriverManager();
                }
                return _instance;
            }
        }

        private DriverManager()
        {
        }

        private readonly List<DriverPackage> _packages = new List<DriverPackage>();

        /// <summary>由 DriverManager 统一登记管理的驱动实例（跨域透明代理）</summary>
        private readonly Dictionary<string, DriverInstance> _managedDrivers =
            new Dictionary<string, DriverInstance>(StringComparer.Ordinal);

        public IReadOnlyList<DriverPackage> Packages => _packages;

        /// <summary>当前由 DriverManager 管理的全部驱动实例</summary>
        public IReadOnlyCollection<DriverInstance> ManagedDrivers => _managedDrivers.Values;

        /// <summary>
        /// 扫描 rootPath 下的每个子文件夹并创建隔离域加载。
        /// </summary>
        public void Scan(string rootPath, Action<string> log)
        {
            if (!Directory.Exists(rootPath))
            {
                log?.Invoke($"[错误] 目录不存在: {rootPath}");
                return;
            }

            var subDirs = Directory.GetDirectories(rootPath);
            if (subDirs.Length == 0)
            {
                log?.Invoke($"[提示] {rootPath} 下没有子文件夹（每个子文件夹应为一个驱动包）");
                return;
            }

            foreach (var dir in subDirs)
            {
                var brandDirs = Directory.GetDirectories(dir);

                foreach (var brandDir in brandDirs)
                {
                    var name = Path.GetFileName(brandDir);

                    try
                    {
                        LoadPackage(brandDir, name, log);
                    }
                    catch (Exception ex)
                    {
                        log?.Invoke($"[失败] {name}: {ex.Message}");
                    }
                }
            }
        }

        /// <summary>
        /// 列出某个类型可调用的公共方法。
        /// </summary>
        public DriverMethodInfo[] GetMethods(DriverPackage package, string typeFullName)
        {
            return package.Loader.GetMethods(typeFullName);
        }

        /// <summary>
        /// 在所有已加载驱动包中按 (类型, 品牌) 查找驱动。
        /// 任一字段留空视为通配；同一组合命中多个包时记录警告并返回第一个。
        /// </summary>
        public DriverFindResult FindDriver(string driverType, string brand, Action<string> log)
        {
            DriverFindResult first = null;

            foreach (var package in _packages)
            {
                var info = package.Loader.FindDriver(driverType, brand);
                if (info == null)
                {
                    continue;
                }

                if (first == null)
                {
                    first = new DriverFindResult { Package = package, Info = info };
                }
                else
                {
                    log?.Invoke($"[警告] (类型={driverType}, 品牌={brand}) 在多个驱动包中重复: "
                                + $"{first.Package.Folder} 与 {package.Folder}，返回第一个");
                }
            }

            return first;
        }

        /// <summary>
        /// 反射调用驱动方法（实际执行发生在该驱动自己的域内）。
        /// </summary>
        public InvokeResult Invoke(DriverPackage package, string typeFullName, int methodIndex, string[] args)
        {
            return package.Loader.Invoke(typeFullName, methodIndex, args);
        }

        /// <summary>
        /// 根据 (类型, 品牌) 找到对应的驱动类型，在其所属驱动包的 AppDomain 内
        /// 创建一个新实例并以透明代理形式返回，由 DriverManager 统一登记管理。
        ///
        /// 说明：驱动类型本身不可跨域封送（非 MarshalByRefObject，宿主也不引用厂商程序集），
        /// 因此无法用泛型 T 返回"原生类型"；宿主一律通过 <see cref="DriverInstance"/> 代理操作，
        /// 每次调用实际执行发生在驱动自己的域内。
        /// </summary>
        /// <param name="driverType">注解中的"类型"，如 CAN；留空为通配</param>
        /// <param name="brand">注解中的"品牌"，如 BA；留空为通配</param>
        /// <param name="log">日志回调（可空）</param>
        /// <returns>驱动实例代理；未找到或创建失败返回 null</returns>
        public DriverInstance CreateDriverByTypeAndBrand(string driverType, string brand, Action<string> log = null)
        {
            var hit = FindDriver(driverType, brand, log);
            if (hit == null)
            {
                log?.Invoke($"[创建] 未找到 (类型={driverType}, 品牌={brand}) 对应的驱动");
                return null;
            }

            try
            {
                var instance = hit.Package.Loader.CreateInstance(hit.Info.FullName, hit.Info.DriverType, hit.Info.Brand);
                instance.PackageFolder = hit.Package.Folder;
                _managedDrivers[instance.Handle] = instance;

                log?.Invoke($"[创建] {hit.Info.FullName}（{hit.Info.DriverType}/{hit.Info.Brand}，包 {hit.Package.Folder}）"
                            + $" => 实例 {ShortHandle(instance.Handle)}");
                return instance;
            }
            catch (Exception ex)
            {
                log?.Invoke($"[创建失败] {hit.Info.FullName}: {ex.Message}");
                return null;
            }
        }

        /// <summary>
        /// 泛型版本：T 为宿主自定义的"鸭子接口"（方法名、参数类型与驱动方法一一对应）。
        /// 返回 DispatchProxy 动态代理：接口调用按"方法名 + 参数个数"转发到驱动域内反射执行。
        ///
        /// 驱动无需实现 T、无需引用宿主程序集——这正是动态代理的意义：
        /// 不同厂商的驱动可以共享宿主定义的一套接口约定。
        ///
        /// 约束：
        /// - T 必须是接口（DispatchProxy 只针对接口生成代理类）；
        /// - 接口方法的参数/返回值必须可跨域封送（基元类型、string、[Serializable] DTO）；
        /// - 每次调用都是一次跨域反射，性能低于直接调用，适合设备控制类低频操作。
        /// </summary>
        public T CreateDriverByTypeAndBrand<T>(string driverType, string brand, Action<string> log = null)
            where T : class
        {
            var instance = CreateDriverByTypeAndBrand(driverType, brand, log);
            if (instance == null)
            {
                return null;
            }

            log?.Invoke($"[代理] {instance.TypeFullName} => {typeof(T).Name} 动态代理（实例 {ShortHandle(instance.Handle)}）");
            return DriverDispatchProxy.Create<T>(instance);
        }

        /// <summary>
        /// 释放一个由 DriverManager 管理的驱动实例（驱动实现 IDisposable 时会调用 Dispose）。
        /// </summary>
        public void ReleaseDriver(DriverInstance instance, Action<string> log = null)
        {
            if (instance == null)
            {
                return;
            }

            _managedDrivers.Remove(instance.Handle);
            try
            {
                instance.Release();
                log?.Invoke($"[释放] 实例 {ShortHandle(instance.Handle)}（{instance.TypeFullName}）");
            }
            catch (Exception ex)
            {
                log?.Invoke($"[释放失败] 实例 {ShortHandle(instance.Handle)}: {ex.Message}");
            }
        }

        /// <summary>
        /// 卸载某个驱动包前，先通过代理释放其名下所有托管实例（域卸载后代理会失效）。
        /// </summary>
        private void ReleaseInstancesOf(DriverPackage package, Action<string> log)
        {
            var targets = _managedDrivers.Values
                .Where(i => i.PackageFolder == package.Folder)
                .ToList();

            foreach (var instance in targets)
            {
                ReleaseDriver(instance, log);
            }
        }

        private static string ShortHandle(string handle) => handle.Substring(0, Math.Min(8, handle.Length));

        /// <summary>
        /// 卸载所有驱动域（释放程序集、解锁 dll 文件）。
        /// </summary>
        public void UnloadAll(Action<string> log)
        {
            // 先通过代理释放所有托管实例，域卸载后代理将失效
            foreach (var instance in _managedDrivers.Values.ToList())
            {
                ReleaseDriver(instance, log);
            }

            var domains = _packages.Select(p => p.Domain).Distinct().ToList();
            _packages.Clear();

            foreach (var domain in domains)
            {
                // 注意：必须在卸载前读取 FriendlyName，域卸载后再访问其属性会抛 AppDomainUnloadedException
                var name = domain.FriendlyName;
                try
                {
                    AppDomain.Unload(domain);
                    log?.Invoke($"[卸载] {name}");
                }
                catch (Exception ex)
                {
                    log?.Invoke($"[卸载失败] {name}: {ex.Message}");
                }
            }
        }

        private DriverPackage LoadPackage(string dir, string name, Action<string> log)
        {
            // 加载器与 DTO 契约统一使用宿主目录中的唯一副本，不再向驱动目录复制
            var loaderPath = typeof(DriverLoader).Assembly.Location;
            WarnIfStaleRuntimeFiles(dir, name, log);

            var setup = new AppDomainSetup
            {
                ApplicationName = name,
                // 关键：探测根固定为该驱动目录，依赖只会从自己目录解析
                ApplicationBase = dir,
                // 影子复制：dll 加载后不锁定，可随时卸载/替换文件
                ShadowCopyFiles = "true",
                ShadowCopyDirectories = dir,
                CachePath = Path.Combine(Path.GetTempPath(), "MultiPluginCache", name)
            };

            var domain = AppDomain.CreateDomain("Driver_" + name, null, setup);
            try
            {
                var loader = (DriverLoader)domain.CreateInstanceFromAndUnwrap(loaderPath, typeof(DriverLoader).FullName);

                var assemblies = loader.LoadAssemblies();
                var package = new DriverPackage
                {
                    Folder = name,
                    Directory = dir,
                    Domain = domain,
                    Loader = loader,
                    Assemblies = assemblies
                };
                _packages.Add(package);

                // 驱动信息持久化到 Config\Drivers.db
                DriverDatabase.Instance.SavePackage(package, log);

                var totalDrivers = assemblies.Where(a => a.Types != null).Sum(a => a.Types.Length);
                var failed = assemblies.Count(a => a.Error != null);
                log?.Invoke($"[驱动包] {name}: {assemblies.Length} 个 dll，{totalDrivers} 个驱动类型"
                            + (failed > 0 ? $"，{failed} 个无法加载" : string.Empty));

                foreach (var asm in assemblies.Where(a => a.Error != null))
                {
                    log?.Invoke($"    [!] {asm.FileName}: {asm.Error}");
                }

                return package;
            }
            catch
            {
                try { AppDomain.Unload(domain); } catch { /* 忽略 */ }
                throw;
            }
        }

        /// <summary>
        /// 卸载指定的驱动包（释放该域中的所有程序集）。
        /// </summary>
        public void Unload(DriverPackage package, Action<string> log)
        {
            // 域卸载前先释放该包名下的托管实例，避免操作失效代理
            ReleaseInstancesOf(package, log);

            _packages.Remove(package);

            // 同步移除该驱动包在 Config\Drivers.db 中的记录
            DriverDatabase.Instance.RemovePackage(package.Folder, log);

            try
            {
                AppDomain.Unload(package.Domain);
                log?.Invoke($"[卸载] {package.Folder}");
            }
            catch (Exception ex)
            {
                log?.Invoke($"[卸载失败] {package.Folder}: {ex.Message}");
            }
        }

        /// <summary>
        /// 重载指定的驱动包：卸载旧域后用同一目录重新创建域。
        /// 依赖影子复制，替换 dll 后无需重启宿主即可生效。
        /// </summary>
        public DriverPackage Reload(DriverPackage package, Action<string> log)
        {
            var dir = package.Directory;
            var name = package.Folder;

            Unload(package, log);
            log?.Invoke($"[重载] {name} ...");

            return LoadPackage(dir, name, log);
        }

        /// <summary>
        /// 早期版本会把加载器/DTO 复制到每个驱动目录，此处清理残留，避免旧版本 Contracts 干扰。
        /// 驱动目录本身不需要、也不应该包含宿主运行时文件。
        /// </summary>
        private static void WarnIfStaleRuntimeFiles(string dir, string name, Action<string> log)
        {
            foreach (var fileName in new[] { "MultiPlugin.Loader.dll", "MultiPlugin.Contracts.dll" })
            {
                var path = Path.Combine(dir, fileName);
                if (!File.Exists(path))
                {
                    continue;
                }

                try
                {
                    File.Delete(path);
                    log?.Invoke($"[清理] {name}: 已删除多余的 {fileName}（运行时统一使用宿主目录版本）");
                }
                catch (Exception ex)
                {
                    log?.Invoke($"[提示] {name}: 存在多余的 {fileName}，已忽略（{ex.Message}）");
                }
            }
        }
    }
}