using System.IO;
using System.Reflection;

namespace DeviceService.Driver
{
    /// <summary>
    /// 驱动的程序集描述（跨 AppDomain 按值封送）。
    /// 注意：这些 DTO 只服务于"宿主 &lt;-&gt; 加载器"之间的通信，
    /// 驱动 dll 不需要引用本程序集，也不需要实现任何接口。
    /// </summary>
    [Serializable]
    public sealed class DriverAssemblyInfo
    {
        /// <summary>dll 文件名</summary>
        public string FileName { get; set; }

        /// <summary>程序集完整标识（加载成功时）</summary>
        public string AssemblyFullName { get; set; }

        /// <summary>加载失败原因（成功时为 null）</summary>
        public string Error { get; set; }

        /// <summary>带 [DriverDesc] 注解的驱动类型（按类型名排序）</summary>
        public DriverTypeInfo[] Types { get; set; }
    }

    /// <summary>
    /// 一个驱动类型的描述信息（来自 DriverDescAttribute）。
    /// 通过 (类型, 品牌) 可唯一定位到该类型。
    /// </summary>
    [Serializable]
    public sealed class DriverTypeInfo
    {
        /// <summary>CLR 类型全名</summary>
        public string FullName { get; set; }

        /// <summary>注解中的"类型"（如 CAN、串口）</summary>
        public string DriverType { get; set; }

        /// <summary>注解中的"品牌"（如 BA、BB）</summary>
        public string Brand { get; set; }
    }

    /// <summary>
    /// 驱动类型上的一个公共方法。
    /// </summary>
    [Serializable]
    public sealed class DriverMethodInfo
    {
        /// <summary>方法在该类型方法表中的索引（调用时回传）</summary>
        public int Index { get; set; }

        public string Name { get; set; }

        /// <summary>可读签名，例如 int ReadStatus(int channel)</summary>
        public string Signature { get; set; }

        public bool IsStatic { get; set; }

        public int ParameterCount { get; set; }

        /// <summary>参数列表（类型名 + 参数名），用于界面提示</summary>
        public string[] Parameters { get; set; }
    }

    /// <summary>
    /// 反射调用结果。
    /// </summary>
    [Serializable]
    public sealed class InvokeResult
    {
        public bool Success { get; set; }

        /// <summary>返回值文本（成功时）</summary>
        public string Output { get; set; }

        /// <summary>错误信息（失败时）</summary>
        public string Error { get; set; }
    }

    /// <summary>
    /// 直接调用结果：保留原始返回值与 out/ref 回填值，
    /// 供 RealProxy 动态代理把驱动调用适配成强类型接口方法。
    /// 注意：Value / ArgsOut 只能携带可跨域封送的数据（基元类型、string、[Serializable] DTO）。
    /// </summary>
    [Serializable]
    public sealed class InvokeDirectResult
    {
        public bool Success { get; set; }

        /// <summary>方法返回值（void 方法为 null）</summary>
        public object Value { get; set; }

        /// <summary>调用后的参数数组（out/ref 位置为回填值，其余位置原值）</summary>
        public object[] ArgsOut { get; set; }

        /// <summary>错误信息（失败时）</summary>
        public string Error { get; set; }
    }

    /// <summary>
    /// 运行在每个驱动包专属 AppDomain 内的加载器。
    ///
    /// 设计前提：驱动 dll 来自不同厂商，彼此没有任何共同接口/基类约定，
    /// 甚至互不兼容（同一第三方依赖的不同版本）。
    /// 因此这里只做通用反射：枚举公开类型、枚举公共方法、反射创建实例、反射调用。
    ///
    /// 该域的 ApplicationBase 被设置为某个驱动子文件夹，
    /// 所以驱动的全部依赖只能从自己目录解析，天然隔离版本冲突。
    /// </summary>
    public class DriverLoader : MarshalByRefObject
    {
        private static readonly HashSet<string> FailedAssemblies =
            new HashSet<string>(StringComparer.OrdinalIgnoreCase);

        private readonly Dictionary<string, Type> _types = new Dictionary<string, Type>(StringComparer.Ordinal);
        private readonly Dictionary<string, MethodInfo[]> _methodCache = new Dictionary<string, MethodInfo[]>(StringComparer.Ordinal);
        private readonly Dictionary<Type, object> _instances = new Dictionary<Type, object>();

        /// <summary>由 DriverManager 创建、按句柄管理的驱动实例</summary>
        private readonly Dictionary<string, ManagedInstance> _managedInstances =
            new Dictionary<string, ManagedInstance>(StringComparer.Ordinal);

        /// <summary>驱动索引：(类型, 品牌) → 驱动信息，key 形如 "CAN|BA"</summary>
        private readonly Dictionary<string, DriverTypeInfo> _driverIndex =
            new Dictionary<string, DriverTypeInfo>(StringComparer.OrdinalIgnoreCase);

        // 无限生存期，避免远程代理被回收
        public override object InitializeLifetimeService() => null;

        public DriverLoader()
        {
            AppDomain.CurrentDomain.AssemblyResolve += OnAssemblyResolve;
        }

        #region 发现

        /// <summary>
        /// 扫描本驱动目录下的所有 dll（忽略宿主自身的 MultiPlugin.* 运行时文件），
        /// 返回每个程序集的信息与公开类型列表。
        /// </summary>
        public DriverAssemblyInfo[] LoadAssemblies()
        {
            var dir = AppDomain.CurrentDomain.BaseDirectory;
            var result = new List<DriverAssemblyInfo>();

            foreach (var path in Directory.GetFiles(dir, "*.dll").OrderBy(p => p, StringComparer.OrdinalIgnoreCase))
            {
                var fileName = Path.GetFileName(path);
                if (fileName.StartsWith("MultiPlugin.", StringComparison.OrdinalIgnoreCase))
                {
                    continue; // 宿主基础设施，非驱动
                }

                var info = new DriverAssemblyInfo { FileName = fileName };
                try
                {
                    var assembly = Assembly.Load(Path.GetFileNameWithoutExtension(path));
                    info.AssemblyFullName = assembly.FullName;

                    // 只收录带 [DriverDesc] 注解的类，其余类型一律忽略
                    var drivers = new List<DriverTypeInfo>();
                    foreach (var type in assembly.GetExportedTypes())
                    {
                        if (!type.IsClass || type.IsAbstract)
                        {
                            continue;
                        }

                        var desc = ReadDriverDesc(type);
                        if (desc == null)
                        {
                            continue;
                        }

                        _types[type.FullName] = type;

                        var driverInfo = new DriverTypeInfo
                        {
                            FullName = type.FullName,
                            DriverType = desc.Item1,
                            Brand = desc.Item2
                        };
                        drivers.Add(driverInfo);
                        _driverIndex[DriverKey(desc.Item1, desc.Item2)] = driverInfo;
                    }

                    info.Types = drivers.OrderBy(t => t.FullName, StringComparer.Ordinal).ToArray();
                }
                catch (Exception ex)
                {
                    // 非托管 dll、缺少依赖、架构不匹配等都会到这里
                    info.Error = ex.Message;
                }

                result.Add(info);
            }

            return result.ToArray();
        }

        /// <summary>
        /// 按 (类型, 品牌) 查找驱动。任一字段留空视为通配。
        /// </summary>
        /// <returns>命中的第一个驱动信息；未命中返回 null</returns>
        public DriverTypeInfo FindDriver(string driverType, string brand)
        {
            var key = DriverKey(driverType, brand);
            if (_driverIndex.TryGetValue(key, out var exact))
            {
                return exact;
            }

            // 精确未命中且存在通配字段时线性扫描
            var anyType = key.StartsWith("*|", StringComparison.Ordinal);
            var anyBrand = key.EndsWith("|*", StringComparison.Ordinal);
            if (!anyType && !anyBrand)
            {
                return null;
            }

            foreach (var info in _driverIndex.Values)
            {
                if (!anyType && !string.Equals(info.DriverType?.Trim(), driverType?.Trim(), StringComparison.OrdinalIgnoreCase))
                {
                    continue;
                }

                if (!anyBrand && !string.Equals(info.Brand?.Trim(), brand?.Trim(), StringComparison.OrdinalIgnoreCase))
                {
                    continue;
                }

                return info;
            }

            return null;
        }

        /// <summary>
        /// 用鸭子反射读取 [DriverDesc] 注解的 Type/Brand 属性值。
        /// 宿主基础设施不引用 Driver.Core，只按"属性名"解耦读取，
        /// 这样厂商 SDK 升级/换版本不会影响宿主。
        /// </summary>
        private static Tuple<string, string> ReadDriverDesc(Type type)
        {
            foreach (var attr in type.GetCustomAttributes(false))
            {
                var attrType = attr.GetType();
                if (!attrType.Name.Equals("DriverDescAttribute", StringComparison.OrdinalIgnoreCase))
                {
                    continue;
                }

                var typeProp = attrType.GetProperty("Type");
                var brandProp = attrType.GetProperty("Brand");
                if (typeProp == null || brandProp == null)
                {
                    continue;
                }

                return Tuple.Create(typeProp.GetValue(attr, null) as string,
                                    brandProp.GetValue(attr, null) as string);
            }

            return null;
        }

        private static string DriverKey(string driverType, string brand)
        {
            var t = string.IsNullOrWhiteSpace(driverType) ? "*" : driverType.Trim().ToUpperInvariant();
            var b = string.IsNullOrWhiteSpace(brand) ? "*" : brand.Trim().ToUpperInvariant();
            return $"{t}|{b}";
        }

        /// <summary>
        /// 列出某个类型的公共方法（属性访问器会被过滤掉）。
        /// </summary>
        public DriverMethodInfo[] GetMethods(string typeFullName)
        {
            var type = ResolveType(typeFullName);
            if (type == null)
            {
                return new DriverMethodInfo[0];
            }

            return GetMethodInfos(type)
                .Select((m, i) =>
                {
                    var parameters = m.GetParameters();
                    return new DriverMethodInfo
                    {
                        Index = i,
                        Name = m.Name,
                        IsStatic = m.IsStatic,
                        ParameterCount = parameters.Length,
                        Signature = BuildSignature(m),
                        Parameters = parameters
                            .Select(p => $"{FormatTypeName(p.ParameterType)} {p.Name}")
                            .ToArray()
                    };
                })
                .ToArray();
        }

        #endregion

        #region 实例管理

        private sealed class ManagedInstance
        {
            public Type Type;
            public object Target;
        }

        /// <summary>
        /// 创建驱动类型的新实例（不走 Invoke 的默认缓存实例），按句柄登记供 DriverManager 管理。
        /// </summary>
        public DriverInstance CreateInstance(string typeFullName, string driverType, string brand)
        {
            var type = ResolveType(typeFullName)
                       ?? throw new InvalidOperationException($"未找到类型: {typeFullName}");

            var ctor = type.GetConstructor(Type.EmptyTypes)
                       ?? throw new MissingMethodException(typeFullName, ".ctor（缺少公共无参构造函数）");

            var target = ctor.Invoke(null);

            var handle = Guid.NewGuid().ToString("N");
            _managedInstances[handle] = new ManagedInstance { Type = type, Target = target };

            return new DriverInstance(this, handle, type.FullName, driverType, brand);
        }

        /// <summary>
        /// 在指定句柄的驱动实例上按"原始对象参数"直接调用方法，
        /// 保留原始返回值与 out/ref 回填值（供 RealProxy 动态代理使用）。
        /// </summary>
        public InvokeDirectResult InvokeOnInstanceDirect(string handle, int methodIndex, object[] args)
        {
            var result = new InvokeDirectResult();
            if (!_managedInstances.TryGetValue(handle, out var managed))
            {
                result.Success = false;
                result.Error = $"实例不存在或已释放: {handle}";
                return result;
            }

            var methods = GetMethodInfos(managed.Type);
            if (methodIndex < 0 || methodIndex >= methods.Length)
            {
                result.Success = false;
                result.Error = $"方法索引无效: {methodIndex}（共 {methods.Length} 个方法）";
                return result;
            }

            try
            {
                var method = methods[methodIndex];
                var parameters = method.GetParameters();
                args = args ?? new object[0];

                if (parameters.Length != args.Length)
                {
                    result.Success = false;
                    result.Error = $"参数数量不匹配: {method.Name} 需要 {parameters.Length} 个，实际传入 {args.Length} 个";
                    return result;
                }

                var converted = new object[parameters.Length];
                for (var i = 0; i < parameters.Length; i++)
                {
                    converted[i] = CoerceArg(args[i], parameters[i].ParameterType, parameters[i].Name);
                }

                result.Value = method.Invoke(managed.Target, converted);
                result.ArgsOut = converted;
                result.Success = true;
                return result;
            }
            catch (TargetInvocationException ex)
            {
                var inner = ex.InnerException ?? ex;
                result.Success = false;
                result.Error = $"{inner.GetType().Name}: {inner.Message}";
                return result;
            }
            catch (Exception ex)
            {
                result.Success = false;
                result.Error = $"{ex.GetType().Name}: {ex.Message}";
                return result;
            }
        }

        /// <summary>
        /// 在指定句柄的驱动实例上反射调用方法（实际执行发生在驱动自己的域内）。
        /// </summary>
        public InvokeResult InvokeOnInstance(string handle, int methodIndex, string[] rawArgs)
        {
            if (!_managedInstances.TryGetValue(handle, out var managed))
            {
                return Fail($"实例不存在或已释放: {handle}");
            }

            var methods = GetMethodInfos(managed.Type);
            if (methodIndex < 0 || methodIndex >= methods.Length)
            {
                return Fail($"方法索引无效: {methodIndex}（共 {methods.Length} 个方法）");
            }

            return ExecuteMethod(methods[methodIndex], managed.Target, rawArgs);
        }

        /// <summary>
        /// 释放指定句柄的实例；驱动实现 IDisposable 时会调用 Dispose。
        /// </summary>
        public void ReleaseInstance(string handle)
        {
            if (!_managedInstances.TryGetValue(handle, out var managed))
            {
                return;
            }

            _managedInstances.Remove(handle);
            (managed.Target as IDisposable)?.Dispose();
        }

        #endregion

        #region 调用

        /// <summary>
        /// 反射调用指定类型的方法。
        /// 实例方法会自动用公共无参构造函数创建（并缓存）实例；
        /// 静态方法无需实例。需要长期持有实例请使用 <see cref="CreateInstance"/>。
        /// </summary>
        /// <param name="rawArgs">字符串形式的实参，由 <see cref="ConvertArg"/> 按目标参数类型转换</param>
        public InvokeResult Invoke(string typeFullName, int methodIndex, string[] rawArgs)
        {
            try
            {
                var type = ResolveType(typeFullName);
                if (type == null)
                {
                    return Fail($"未找到类型: {typeFullName}");
                }

                var methods = GetMethodInfos(type);
                if (methodIndex < 0 || methodIndex >= methods.Length)
                {
                    return Fail($"方法索引无效: {methodIndex}（共 {methods.Length} 个方法）");
                }

                var method = methods[methodIndex];

                object target = null;
                if (!method.IsStatic)
                {
                    target = GetOrCreateInstance(type);
                    if (target == null)
                    {
                        return Fail($"无法实例化 {type.FullName}: 缺少公共无参构造函数。可改为只调用该类型的静态方法。");
                    }
                }

                return ExecuteMethod(method, target, rawArgs);
            }
            catch (TargetInvocationException ex)
            {
                // 驱动内部抛出的异常
                var inner = ex.InnerException ?? ex;
                return Fail($"{inner.GetType().Name}: {inner.Message}");
            }
            catch (Exception ex)
            {
                return Fail($"{ex.GetType().Name}: {ex.Message}");
            }
        }

        /// <summary>
        /// 参数转换 → 反射调用 → 汇总返回值与 out/ref 回填值。
        /// </summary>
        private static InvokeResult ExecuteMethod(MethodInfo method, object target, string[] rawArgs)
        {
            try
            {
                var parameters = method.GetParameters();
                rawArgs = rawArgs ?? new string[0];

                if (parameters.Length != rawArgs.Length)
                {
                    return Fail($"参数数量不匹配: {method.Name} 需要 {parameters.Length} 个参数，实际传入 {rawArgs.Length} 个");
                }

                var args = new object[parameters.Length];
                for (var i = 0; i < parameters.Length; i++)
                {
                    args[i] = ConvertArg(rawArgs[i], parameters[i].ParameterType, parameters[i].Name);
                }

                var returnValue = method.Invoke(target, args);

                // 汇总返回值与 out/ref 回填值（如 Open(out string msg) 的 msg）
                var parts = new List<string>();
                if (method.ReturnType != typeof(void))
                {
                    parts.Add($"返回: {Format(returnValue)}");
                }

                for (var i = 0; i < parameters.Length; i++)
                {
                    if (parameters[i].ParameterType.IsByRef)
                    {
                        parts.Add($"{parameters[i].Name} = {Format(args[i])}");
                    }
                }

                return new InvokeResult { Success = true, Output = parts.Count == 0 ? "null" : string.Join("; ", parts) };
            }
            catch (TargetInvocationException ex)
            {
                // 驱动内部抛出的异常
                var inner = ex.InnerException ?? ex;
                return Fail($"{inner.GetType().Name}: {inner.Message}");
            }
            catch (Exception ex)
            {
                return Fail($"{ex.GetType().Name}: {ex.Message}");
            }
        }

        private object GetOrCreateInstance(Type type)
        {
            if (_instances.TryGetValue(type, out var existing))
            {
                return existing;
            }

            if (type.IsAbstract || type.IsInterface)
            {
                return null;
            }

            var ctor = type.GetConstructor(Type.EmptyTypes);
            if (ctor == null)
            {
                return null;
            }

            var instance = ctor.Invoke(null);
            _instances[type] = instance;
            return instance;
        }

        #endregion

        #region 辅助

        private Type ResolveType(string typeFullName)
        {
            if (_types.TryGetValue(typeFullName, out var type))
            {
                return type;
            }

            // 兜底：在已加载的驱动程序集里查找
            type = AppDomain.CurrentDomain.GetAssemblies()
                .Where(a => !a.IsDynamic)
                .Select(a => a.GetType(typeFullName))
                .FirstOrDefault(t => t != null);

            if (type != null)
            {
                _types[typeFullName] = type;
            }

            return type;
        }

        private MethodInfo[] GetMethodInfos(Type type)
        {
            if (_methodCache.TryGetValue(type.FullName, out var cached))
            {
                return cached;
            }

            var methods = type
                .GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly)
                .Where(m => !m.IsSpecialName)   // 过滤 get_/set_/add_/remove_ 等
                .ToArray();

            _methodCache[type.FullName] = methods;
            return methods;
        }

        private static string BuildSignature(MethodInfo method)
        {
            var parameters = method.GetParameters()
                .Select(p => $"{FormatTypeName(p.ParameterType)} {p.Name}");

            return $"{(method.IsStatic ? "static " : string.Empty)}{FormatTypeName(method.ReturnType)} "
                   + $"{method.Name}({string.Join(", ", parameters)})";
        }

        private static string FormatTypeName(Type type)
        {
            if (!type.IsGenericType)
            {
                return type.Name;
            }

            var name = type.Name.Substring(0, type.Name.IndexOf('`'));
            var args = string.Join(", ", type.GetGenericArguments().Select(FormatTypeName));
            return $"{name}<{args}>";
        }

        /// <summary>
        /// 把跨域代理传来的对象参数适配为目标参数类型：
        /// 类型兼容直接用，否则退化为字符串转换（鸭子式宽松匹配）。
        /// </summary>
        private static object CoerceArg(object arg, Type targetType, string parameterName)
        {
            if (targetType.IsByRef)
            {
                targetType = targetType.GetElementType();
            }

            if (arg == null)
            {
                return targetType.IsValueType ? Activator.CreateInstance(targetType) : null;
            }

            if (targetType.IsInstanceOfType(arg))
            {
                return arg;
            }

            return ConvertArg(arg.ToString(), targetType, parameterName);
        }

        /// <summary>
        /// 把 UI 传来的字符串转换为目标参数类型。
        /// 支持常用基元类型、枚举、Guid、DateTime、字符串数组（以分号分隔）。
        /// </summary>
        private static object ConvertArg(string raw, Type targetType, string parameterName)
        {
            raw = raw ?? string.Empty;

            // out/ref 参数实际按其元素类型转换（调用后由 CLR 回填）
            if (targetType.IsByRef)
            {
                targetType = targetType.GetElementType();
            }

            if (targetType == typeof(string) || targetType == typeof(object))
            {
                return raw;
            }

            if (raw.Length == 0 && !targetType.IsValueType)
            {
                return null;
            }

            if (targetType == typeof(bool)) return bool.Parse(raw);
            if (targetType == typeof(char)) return raw[0];
            if (targetType == typeof(byte)) return byte.Parse(raw);
            if (targetType == typeof(sbyte)) return sbyte.Parse(raw);
            if (targetType == typeof(short)) return short.Parse(raw);
            if (targetType == typeof(ushort)) return ushort.Parse(raw);
            if (targetType == typeof(int)) return int.Parse(raw);
            if (targetType == typeof(uint)) return uint.Parse(raw);
            if (targetType == typeof(long)) return long.Parse(raw);
            if (targetType == typeof(ulong)) return ulong.Parse(raw);
            if (targetType == typeof(float)) return float.Parse(raw);
            if (targetType == typeof(double)) return double.Parse(raw);
            if (targetType == typeof(decimal)) return decimal.Parse(raw);
            if (targetType == typeof(Guid)) return Guid.Parse(raw);
            if (targetType == typeof(DateTime)) return DateTime.Parse(raw);
            if (targetType.IsEnum) return Enum.Parse(targetType, raw, true);

            if (targetType.IsArray)
            {
                var elementType = targetType.GetElementType();
                var parts = raw.Length == 0 ? new string[0] : raw.Split(';');
                var array = Array.CreateInstance(elementType, parts.Length);
                for (var i = 0; i < parts.Length; i++)
                {
                    array.SetValue(ConvertArg(parts[i], elementType, parameterName), i);
                }

                return array;
            }

            throw new InvalidOperationException(
                $"参数 {parameterName} 的类型 {targetType.Name} 暂不支持从字符串转换（支持：字符串、数字、bool、枚举、Guid、DateTime、数组）");
        }

        private static string Format(object value)
        {
            if (value == null)
            {
                return "null";
            }

            if (value is string text)
            {
                return Truncate(text);
            }

            if (value is Array array)
            {
                var items = array.Cast<object>().Select(x => x == null ? "null" : x.ToString());
                return Truncate($"[{string.Join(", ", items)}]");
            }

            return Truncate(value.ToString());
        }

        private static string Truncate(string text)
        {
            const int max = 4000;
            return text.Length <= max ? text : text.Substring(0, max) + " ...(已截断)";
        }

        private static InvokeResult Fail(string message) => new InvokeResult { Success = false, Error = message };

        /// <summary>
        /// 依赖解析兜底：只在本驱动目录（及加载器所在目录）内查找，
        /// 保证不会串到其他驱动包的同名程序集。
        /// </summary>
        private static Assembly OnAssemblyResolve(object sender, ResolveEventArgs args)
        {
            var simpleName = new AssemblyName(args.Name).Name;
            if (FailedAssemblies.Contains(simpleName))
            {
                return null;
            }

            var dirs = new List<string>();

            // 优先按加载器所在目录（宿主 bin）解析宿主基础设施，再兜底驱动目录
            var loaderLocation = typeof(DriverLoader).Assembly.Location;
            var loaderDir = string.IsNullOrEmpty(loaderLocation) ? null : Path.GetDirectoryName(loaderLocation);
            if (!string.IsNullOrEmpty(loaderDir))
            {
                dirs.Add(loaderDir);
            }

            var baseDir = AppDomain.CurrentDomain.BaseDirectory;
            if (!dirs.Contains(baseDir))
            {
                dirs.Add(baseDir);
            }

            foreach (var dir in dirs)
            {
                foreach (var ext in new[] { ".dll", ".exe" })
                {
                    var candidate = Path.Combine(dir, simpleName + ext);
                    if (!File.Exists(candidate))
                    {
                        continue;
                    }

                    try
                    {
                        return Assembly.LoadFrom(candidate);
                    }
                    catch
                    {
                        // 尝试下一个候选
                    }
                }
            }

            FailedAssemblies.Add(simpleName);
            return null;
        }

        #endregion
    }
}