using System.Reflection;
using AutoMapper;
using MongoDB.Bson;

namespace Dpz.Core.Entity.Base.MapperConfig;

public class GlobalConfigMapper
{
    private static readonly Lazy<GlobalConfigMapper> LazyMapper = new(() =>
        new GlobalConfigMapper()
    );

    private GlobalConfigMapper()
    {
        Mapper = ConfigGlobalMapper();
    }

    public IMapper Mapper { get; }

    public static GlobalConfigMapper GetInstance()
    {
        return LazyMapper.Value;
    }

    public static GlobalConfigMapper Instance => LazyMapper.Value;

    private static IMapper ConfigGlobalMapper()
    {
        var config = new MapperConfigurationExpression();

        // 获取所有需要扫描的程序集
        var assemblies = GetRelevantAssemblies();

        // 使用 AutoMapper 内置扫描 (最优雅的方式)
        // 自动扫描所有实现了 Profile 的类
        // config.AddMaps(assemblies);

        // 1. 扫描所有程序集中的类型
        var allTypes = assemblies.SelectMany(a => a.GetExportedTypes()).ToArray();

        // 2. 基于 IMapFrom<T> 接口，默认规则映射
        ConfigureIMapFromMappings(allTypes, config);

        // 3. 基于 IHaveCustomMapping 接口，自定义规则映射
        ConfigureStaticInterfaceMappings(allTypes, config);

        // 4. 基于特性的映射
        ConfigureAttributeBasedMappings(allTypes, config);

        // 5. 内置映射规则
        ConfigureBuiltInMappings(config);

        var cfg = new MapperConfiguration(config);
        IMapper mapper = new Mapper(cfg);
        return mapper;
    }

    /// <summary>
    /// 获取所有相关的程序集
    /// 只扫描项目相关的程序集，避免扫描系统程序集提升性能
    /// </summary>
    private static Assembly[] GetRelevantAssemblies()
    {
        var assemblies = AppDomain
            .CurrentDomain.GetAssemblies()
            .Where(a =>
            {
                var name = a.GetName().Name;
                // 只扫描项目相关的程序集
                return name != null
                    && name.StartsWith("Dpz.Core", StringComparison.OrdinalIgnoreCase);
            })
            .Where(a => !a.IsDynamic)
            .ToArray();

        return assemblies;
    }

    /// <summary>
    /// 配置 IMapFrom 接口映射
    /// </summary>
    private static void ConfigureIMapFromMappings(
        Type[] types,
        MapperConfigurationExpression config
    )
    {
        var mapTypes =
            from x in types
            from y in x.GetInterfaces()
            let faceType = y.GetTypeInfo()
            where
                faceType.IsGenericType
                && y.GetGenericTypeDefinition() == typeof(IMapFrom<>)
                && !x.IsAbstract
                && !x.IsInterface
            select new { Source = y.GetGenericArguments()[0], Destination = x };

        foreach (var item in mapTypes)
        {
            config.CreateMap(item.Source, item.Destination);
            config.CreateMap(item.Destination, item.Source);
        }
    }

    /// <summary>
    /// 配置静态接口映射（C# 11+）
    /// </summary>
    private static void ConfigureStaticInterfaceMappings(
        Type[] types,
        MapperConfigurationExpression config
    )
    {
        var customMappingTypes = types.Where(x =>
            x.GetInterfaces().Any(i => i == typeof(IHaveCustomMapping))
            && x is { IsAbstract: false, IsInterface: false }
        );

        foreach (var type in customMappingTypes)
        {
            // 调用静态 CreateMappings 方法
            var method = type.GetMethod(
                nameof(IHaveCustomMapping.CreateMappings),
                BindingFlags.Static | BindingFlags.Public,
                null,
                [typeof(MapperConfigurationExpression)],
                null
            );
            method?.Invoke(null, [config]);
        }
    }

    /// <summary>
    /// 配置基于特性的映射
    /// </summary>
    private static void ConfigureAttributeBasedMappings(
        Type[] types,
        MapperConfigurationExpression config
    )
    {
        foreach (var type in types)
        {
            var mappingAttributes = type.GetCustomAttributes<AutoMappingAttribute>();
            foreach (var attr in mappingAttributes)
            {
                attr.ConfigureMapping(config);
            }
        }
    }

    /// <summary>
    /// 配置内置映射规则
    /// </summary>
    private static void ConfigureBuiltInMappings(MapperConfigurationExpression config)
    {
        config
            .CreateMap<string, ObjectId>()
            .ConstructUsing(
                (x, _) =>
                    !string.IsNullOrEmpty(x) && ObjectId.TryParse(x, out var oid)
                        ? oid
                        : ObjectId.Empty
            );
    }
}