/// <summary>前端提交的注册请求</summary>
public sealed class CreateUserDto
{
    public string UserName { get; set; } = "";
    public string Email { get; set; } = "";
    public string DisplayName { get; set; } = "";
    public string? Phone { get; set; }
    public int Age { get; set; }
    public bool IsActive { get; set; }
    public decimal Balance { get; set; }
    public DateTime BirthDate { get; set; }
    public Guid TenantId { get; set; }
    public string Country { get; set; } = "";
}

/// <summary>数据库实体：比 DTO 多出 Id、CreatedAt 两个由服务端决定的字段</summary>
public sealed class User
{
    public long Id { get; set; }
    public string UserName { get; set; } = "";
    public string Email { get; set; } = "";
    public string DisplayName { get; set; } = "";
    public string? Phone { get; set; }
    public int Age { get; set; }
    public bool IsActive { get; set; }
    public decimal Balance { get; set; }
    public DateTime BirthDate { get; set; }
    public Guid TenantId { get; set; }
    public string Country { get; set; } = "";
    public DateTime CreatedAt { get; set; }
}

public static class HandWrittenMapper
{
    public static User Map(CreateUserDto source) => new()
    {
        UserName = source.UserName,
        Email = source.Email,
        DisplayName = source.DisplayName,
        Phone = source.Phone,
        Age = source.Age,
        IsActive = source.IsActive,
        Balance = source.Balance,
        BirthDate = source.BirthDate,
        TenantId = source.TenantId,
        Country = source.Country,
    };
}

using System.Reflection;

public static class ReflectionMapper
{
    private const BindingFlags Flags = BindingFlags.Public | BindingFlags.Instance;

    /// <summary>每次调用都重新查元数据：最朴素的写法</summary>
    public static TTarget MapNoCache<TSource, TTarget>(TSource source) where TTarget : new()
    {
        var target = new TTarget();
        foreach (var tp in typeof(TTarget).GetProperties(Flags))
        {
            if (!tp.CanWrite) continue;

            var sp = typeof(TSource).GetProperty(tp.Name, Flags);
            if (sp is null || !sp.CanRead || sp.PropertyType != tp.PropertyType) continue;

            tp.SetValue(target, sp.GetValue(source));
        }
        return target;
    }
}

    /// <summary>元数据只查一次，缓存成 (源属性, 目标属性) 数组</summary>
    public static TTarget MapCached<TSource, TTarget>(TSource source) where TTarget : new()
    {
        var target = new TTarget();
        foreach (var (sp, tp) in PropertyPairs<TSource, TTarget>.Pairs)
        {
            tp.SetValue(target, sp.GetValue(source));
        }
        return target;
    }

    // 泛型静态类：每一对 <TSource, TTarget> 各有一份，由运行时保证只初始化一次
    private static class PropertyPairs<TSource, TTarget>
    {
        public static readonly (PropertyInfo Source, PropertyInfo Target)[] Pairs = Build();

        private static (PropertyInfo, PropertyInfo)[] Build()
        {
            var sourceProps = typeof(TSource).GetProperties(Flags)
                .Where(p => p.CanRead)
                .ToDictionary(p => p.Name);

            return typeof(TTarget).GetProperties(Flags)
                .Where(tp => tp.CanWrite
                             && sourceProps.TryGetValue(tp.Name, out var sp)
                             && sp.PropertyType == tp.PropertyType)
                .Select(tp => (sourceProps[tp.Name], tp))
                .ToArray();
        }
    }

source => new User { UserName = source.UserName, Email = source.Email, ... }

// 所在文件需要 using System.Linq.Expressions; 和 using System.Reflection;

/// <summary>
/// 构造等价于 source =&gt; new TTarget { A = source.A, B = source.B, ... } 的表达式树
/// </summary>
public static Expression<Func<TSource, TTarget>> BuildLambda<TSource, TTarget>() where TTarget : new()
{
    const BindingFlags flags = BindingFlags.Public | BindingFlags.Instance;
    var source = Expression.Parameter(typeof(TSource), "source");

    var sourceProps = typeof(TSource).GetProperties(flags)
        .Where(p => p.CanRead)
        .ToDictionary(p => p.Name);

    // 每个可写的目标属性生成一条 Target.X = source.X 绑定
    var bindings = typeof(TTarget).GetProperties(flags)
        .Where(tp => tp.CanWrite
                     && sourceProps.TryGetValue(tp.Name, out var sp)
                     && sp.PropertyType == tp.PropertyType)
        .Select(tp => Expression.Bind(tp, Expression.Property(source, sourceProps[tp.Name])));

    var body = Expression.MemberInit(Expression.New(typeof(TTarget)), bindings);
    return Expression.Lambda<Func<TSource, TTarget>>(body, source);
}

public static class ExpressionMapper
{
    /// <summary>每次调用都构造表达式树并 Compile：用来量出 Compile 本身的代价</summary>
    public static TTarget MapCompileEveryTime<TSource, TTarget>(TSource source) where TTarget : new()
        => BuildLambda<TSource, TTarget>().Compile()(source);

    /// <summary>Compile 一次，之后调用的就是一个普通委托</summary>
    public static TTarget MapCached<TSource, TTarget>(TSource source) where TTarget : new()
        => CompiledMapper<TSource, TTarget>.Map(source);

    private static class CompiledMapper<TSource, TTarget> where TTarget : new()
    {
        public static readonly Func<TSource, TTarget> Map = BuildLambda<TSource, TTarget>().Compile();
    }
}

using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;

namespace MapperBench.Generator;

[Generator]
public sealed class MapperGenerator : IIncrementalGenerator
{
    private const string AttributeFullName = "MapperBench.Generated.GenerateMapperAttribute";

    private const string AttributeSource = """
        namespace MapperBench.Generated;

        [System.AttributeUsage(System.AttributeTargets.Class)]
        internal sealed class GenerateMapperAttribute : System.Attribute
        {
        }
        """;

    public void Initialize(IncrementalGeneratorInitializationContext context)
    {
        // 1. 把特性本身注入到消费方的编译里，使用方无需额外引用
        context.RegisterPostInitializationOutput(ctx =>
            ctx.AddSource("GenerateMapperAttribute.g.cs", SourceText.From(AttributeSource, Encoding.UTF8)));

        // 2. 找到标了 [GenerateMapper] 的类，提前转成纯字符串模型
        var mappers = context.SyntaxProvider.ForAttributeWithMetadataName(
            AttributeFullName,
            predicate: static (node, _) => node is ClassDeclarationSyntax,
            transform: static (ctx, _) => Emit((INamedTypeSymbol)ctx.TargetSymbol));

        // 3. 每个类输出一个 .g.cs 文件
        context.RegisterSourceOutput(mappers, static (spc, file) =>
            spc.AddSource(file.HintName, SourceText.From(file.Source, Encoding.UTF8)));
    }

    private static GeneratedFile Emit(INamedTypeSymbol mapper)
    {
        var sb = new StringBuilder();
        sb.AppendLine("// <auto-generated />");
        sb.AppendLine("#nullable enable");
        sb.AppendLine($"namespace {mapper.ContainingNamespace.ToDisplayString()};");
        sb.AppendLine();
        sb.AppendLine($"static partial class {mapper.Name}");
        sb.AppendLine("{");

        // 只处理「static partial、没有实现体、一个参数、有返回值」的方法
        foreach (var method in mapper.GetMembers().OfType<IMethodSymbol>())
        {
            if (!method.IsStatic || !method.IsPartialDefinition
                || method.Parameters.Length != 1 || method.ReturnsVoid)
                continue;

            var source = method.Parameters[0];
            var target = method.ReturnType;
            var sourceProps = GetProperties(source.Type, p => p.GetMethod is not null)
                .ToDictionary(p => p.Name);

            sb.AppendLine($"    public static partial {target.ToDisplayString()} {method.Name}({source.Type.ToDisplayString()} {source.Name})");
            sb.AppendLine("    {");
            sb.AppendLine($"        return new {target.ToDisplayString()}");
            sb.AppendLine("        {");

            foreach (var tp in GetProperties(target, p => p.SetMethod is not null))
            {
                // 同名且同类型才赋值，其余属性（如 Id、CreatedAt）保持默认值
                if (sourceProps.TryGetValue(tp.Name, out var sp)
                    && SymbolEqualityComparer.Default.Equals(sp.Type, tp.Type))
                {
                    sb.AppendLine($"            {tp.Name} = {source.Name}.{tp.Name},");
                }
            }

            sb.AppendLine("        };");
            sb.AppendLine("    }");
        }

        sb.AppendLine("}");
        return new GeneratedFile($"{mapper.Name}.g.cs", sb.ToString());
    }

    private static IEnumerable<IPropertySymbol> GetProperties(ITypeSymbol type, System.Func<IPropertySymbol, bool> filter) =>
        type.GetMembers().OfType<IPropertySymbol>()
            .Where(p => !p.IsStatic && p.DeclaredAccessibility == Accessibility.Public && filter(p));

    // record 自带值相等，输入没变时增量管线会跳过输出阶段
    private sealed record GeneratedFile(string HintName, string Source);
}

// netstandard2.0 没有这个类型，record / init 需要它
namespace System.Runtime.CompilerServices;

internal static class IsExternalInit
{
}

using MapperBench.Generated;

namespace MapperBench.Mappers;

[GenerateMapper]
public static partial class UserMapper
{
    public static partial User Map(CreateUserDto source);
}

// <auto-generated />
#nullable enable
namespace MapperBench.Mappers;

static partial class UserMapper
{
    public static partial MapperBench.User Map(MapperBench.CreateUserDto source)
    {
        return new MapperBench.User
        {
            UserName = source.UserName,
            Email = source.Email,
            DisplayName = source.DisplayName,
            Phone = source.Phone,
            Age = source.Age,
            IsActive = source.IsActive,
            Balance = source.Balance,
            BirthDate = source.BirthDate,
            TenantId = source.TenantId,
            Country = source.Country,
        };
    }
}

[MemoryDiagnoser]
[SimpleJob(RuntimeMoniker.Net10_0)]
public class MapBenchmarks
{
    private readonly CreateUserDto _dto = SampleData.Dto;

    [Benchmark(Baseline = true)]
    public User HandWritten() => HandWrittenMapper.Map(_dto);

    [Benchmark]
    public User ReflectionNoCache() => ReflectionMapper.MapNoCache<CreateUserDto, User>(_dto);

    [Benchmark]
    public User ReflectionCached() => ReflectionMapper.MapCached<CreateUserDto, User>(_dto);

    [Benchmark]
    public User ExpressionCompileEveryTime() => ExpressionMapper.MapCompileEveryTime<CreateUserDto, User>(_dto);

    [Benchmark]
    public User ExpressionCached() => ExpressionMapper.MapCached<CreateUserDto, User>(_dto);

    [Benchmark]
    public User SourceGenerated() => UserMapper.Map(_dto);
}

using System.Collections;
using BenchmarkDotNet.Running;
using MapperBench;
using MapperBench.Mappers;
using MapperBench.Mappers.Deep;

// 跑基准之前先确认各实现的输出与手写版本完全一致，否则比较没有意义
var dto = SampleData.Dto;
var expectedUser = HandWrittenMapper.Map(dto);
var users = new Dictionary<string, User>
{
    ["ReflectionNoCache"] = ReflectionMapper.MapNoCache<CreateUserDto, User>(dto),
    ["ReflectionCached"] = ReflectionMapper.MapCached<CreateUserDto, User>(dto),
    ["ExpressionCompileEveryTime"] = ExpressionMapper.MapCompileEveryTime<CreateUserDto, User>(dto),
    ["ExpressionCached"] = ExpressionMapper.MapCached<CreateUserDto, User>(dto),
    ["SourceGenerated"] = UserMapper.Map(dto),
};

var orderDto = SampleData.CreateOrder(10);
var expectedOrder = HandWrittenOrderMapper.Map(orderDto);
var orders = new Dictionary<string, Order>
{
    ["DeepReflection"] = DeepReflectionMapper.Map<CreateOrderDto, Order>(orderDto),
    ["DeepExpression"] = DeepExpressionMapper.Map<CreateOrderDto, Order>(orderDto),
    ["DeepSourceGenerated"] = OrderMapper.Map(orderDto),
};

if (expectedOrder.Lines.Count != 10 || expectedOrder.ShippingAddress is null || expectedOrder.BillingAddress is not null)
{
    Console.Error.WriteLine("手写订单映射结果不符合预期");
    return 1;
}

foreach (var (name, actual) in users.Select(p => (p.Key, (object)p.Value))
             .Concat(orders.Select(p => (p.Key, (object)p.Value))))
{
    var expected = actual is User ? (object)expectedUser : expectedOrder;
    if (!DeepEquals(expected, actual))
    {
        Console.Error.WriteLine($"{name} 与手写版本不一致");
        return 1;
    }
}
Console.WriteLine("所有实现输出一致");

if (args.Contains("--verify-only")) return 0;

BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args);
return 0;

// 递归比较：值类型和 string 比值，List 逐项比，其它对象逐属性比
static bool DeepEquals(object? a, object? b)
{
    if (a is null || b is null) return a is null && b is null;
    if (a.GetType() != b.GetType()) return false;
    if (a is string || a.GetType().IsValueType) return a.Equals(b);
    if (a is IList la && b is IList lb)
        return la.Count == lb.Count && Enumerable.Range(0, la.Count).All(i => DeepEquals(la[i], lb[i]));

    return a.GetType().GetProperties().All(p => DeepEquals(p.GetValue(a), p.GetValue(b)));
}

/// <summary>前端提交的下单请求：含嵌套对象和集合</summary>
public sealed class CreateOrderDto
{
    public string CustomerName { get; set; } = "";
    public string Email { get; set; } = "";
    public DateTime OrderDate { get; set; }
    public decimal Discount { get; set; }
    public string? Remark { get; set; }
    public AddressDto ShippingAddress { get; set; } = new();
    public AddressDto? BillingAddress { get; set; }
    public List<OrderLineDto> Lines { get; set; } = [];
}

public sealed class AddressDto
{
    public string Country { get; set; } = "";
    public string City { get; set; } = "";
    public string Street { get; set; } = "";
    public string PostalCode { get; set; } = "";
}

public sealed class OrderLineDto
{
    public Guid ProductId { get; set; }
    public string ProductName { get; set; } = "";
    public int Quantity { get; set; }
    public decimal UnitPrice { get; set; }
}

private static object? MapObject(object? source, Type sourceType, Type targetType)
{
    if (source is null) return null;

    var target = Activator.CreateInstance(targetType)!;
    foreach (var step in Plans.GetOrAdd((sourceType, targetType), BuildPlan))
    {
        var value = step.Source.GetValue(source);
        value = step.Kind switch
        {
            Kind.Object => MapObject(value, step.Source.PropertyType, step.Target.PropertyType),
            Kind.List => MapList((IList?)value, step.SourceElement!, step.TargetElement!, step.Target.PropertyType),
            _ => value,
        };
        step.Target.SetValue(target, value);
    }
    return target;
}

private static IList? MapList(IList? source, Type sourceElement, Type targetElement, Type targetListType)
{
    if (source is null) return null;

    var result = (IList)Activator.CreateInstance(targetListType, source.Count)!;
    foreach (var item in source)
    {
        result.Add(sourceElement == targetElement ? item : MapObject(item, sourceElement, targetElement));
    }
    return result;
}

private static Expression? BuildValue(Expression value, Type targetType)
{
    if (value.Type == targetType)
        return value;

    if (MappingRules.IsList(value.Type, out var se) && MappingRules.IsList(targetType, out var te))
        return NullSafe(value, targetType, v => BuildList(v, se, te, targetType));

    if (MappingRules.IsMappableClass(value.Type) && MappingRules.IsMappableClass(targetType))
        return NullSafe(value, targetType, v => BuildNew(v, targetType));

    return null;
}

/// <summary>var v = value; v == null ? null : build(v)</summary>
private static Expression NullSafe(Expression value, Type targetType, Func<Expression, Expression> build)
{
    var v = Expression.Variable(value.Type);
    return Expression.Block(targetType, [v],
        Expression.Assign(v, value),
        Expression.Condition(
            Expression.Equal(v, Expression.Constant(null, value.Type)),
            Expression.Constant(null, targetType),
            build(v),
            targetType));
}

/// <summary>
/// 等价于：
/// var result = new List&lt;TT&gt;(source.Count);
/// for (var i = 0; i &lt; count; i++) result.Add(map(source[i]));
/// </summary>
private static Expression BuildList(Expression source, Type sourceElement, Type targetElement, Type targetListType)
{
    var result = Expression.Variable(targetListType, "result");
    var count = Expression.Variable(typeof(int), "count");
    var i = Expression.Variable(typeof(int), "i");
    var item = Expression.Variable(sourceElement, "item");
    var end = Expression.Label("end");

    var element = BuildValue(item, targetElement)
        ?? throw new NotSupportedException($"{sourceElement} -> {targetElement}");

    return Expression.Block(targetListType, [result, count, i],
        Expression.Assign(count, Expression.Property(source, "Count")),
        Expression.Assign(result, Expression.New(targetListType.GetConstructor([typeof(int)])!, count)),
        Expression.Assign(i, Expression.Constant(0)),
        Expression.Loop(
            Expression.IfThenElse(
                Expression.LessThan(i, count),
                Expression.Block([item],
                    Expression.Assign(item, Expression.Property(source, "Item", i)),
                    Expression.Call(result, targetListType.GetMethod("Add")!, element),
                    Expression.PostIncrementAssign(i)),
                Expression.Break(end)),
            end),
        result);
}

/// <summary>同类型直接赋值；List 和可映射的类调用 __Map，并保留 null</summary>
private static string? Value(string access, ITypeSymbol source, ITypeSymbol target,
    Queue<(ITypeSymbol, ITypeSymbol)> pending)
{
    if (SymbolEqualityComparer.Default.Equals(source, target))
        return access;

    if ((IsList(source, out _) && IsList(target, out _))
        || (IsMappableClass(source) && IsMappableClass(target)))
    {
        pending.Enqueue((source, target));
        return $"{access} is null ? null : __Map({access})";
    }

    return null;
}

[GenerateDeepMapper]
public static partial class OrderMapper
{
    public static partial Order Map(CreateOrderDto source);
}

// <auto-generated />
#nullable disable
namespace MapperBench.Mappers.Deep;

static partial class OrderMapper
{
    public static partial MapperBench.Order Map(MapperBench.CreateOrderDto source)
    {
        return new MapperBench.Order
        {
            CustomerName = source.CustomerName,
            Email = source.Email,
            OrderDate = source.OrderDate,
            Discount = source.Discount,
            Remark = source.Remark,
            ShippingAddress = source.ShippingAddress is null ? null : __Map(source.ShippingAddress),
            BillingAddress = source.BillingAddress is null ? null : __Map(source.BillingAddress),
            Lines = source.Lines is null ? null : __Map(source.Lines),
        };
    }

    private static MapperBench.Address __Map(MapperBench.AddressDto source)
    {
        return new MapperBench.Address
        {
            Country = source.Country,
            City = source.City,
            Street = source.Street,
            PostalCode = source.PostalCode,
        };
    }

    private static System.Collections.Generic.List<MapperBench.OrderLine> __Map(System.Collections.Generic.List<MapperBench.OrderLineDto> source)
    {
        var result = new System.Collections.Generic.List<MapperBench.OrderLine>(source.Count);
        foreach (var item in source)
        {
            result.Add(item is null ? null : __Map(item));
        }
        return result;
    }

    private static MapperBench.OrderLine __Map(MapperBench.OrderLineDto source)
    {
        return new MapperBench.OrderLine
        {
            ProductId = source.ProductId,
            ProductName = source.ProductName,
            Quantity = source.Quantity,
            UnitPrice = source.UnitPrice,
        };
    }
}

[MemoryDiagnoser]
[SimpleJob(RuntimeMoniker.Net10_0)]
public class OrderMapBenchmarks
{
    [Params(1, 10, 100)]
    public int LineCount;

    private CreateOrderDto _dto = null!;

    [GlobalSetup]
    public void Setup() => _dto = SampleData.CreateOrder(LineCount);

    [Benchmark(Baseline = true)]
    public Order HandWritten() => HandWrittenOrderMapper.Map(_dto);

    [Benchmark]
    public Order ReflectionCached() => DeepReflectionMapper.Map<CreateOrderDto, Order>(_dto);

    [Benchmark]
    public Order ExpressionCached() => DeepExpressionMapper.Map<CreateOrderDto, Order>(_dto);

    [Benchmark]
    public Order SourceGenerated() => OrderMapper.Map(_dto);
}