// Program.cs
var builder = WebApplication.CreateBuilder(args);

// ==========================================
// 1. 添加 Skywalker 核心服务 + ASP.NET Core 集成
// ==========================================
// AddSkywalker()  → 注册 UnitOfWork、拦截器等核心基础设施
// AddAspNetCore() → 注册异常处理、响应包装等 Web 特有服务
builder.Services.AddSkywalker()
    .AddAspNetCore();

// ==========================================
// 2. 添加 DbContext（自动注册 EF Core 仓储和领域服务）
// ==========================================
builder.Services.AddSkywalkerDbContext<AppDbContext>(options =>
{
    options.UseMySql(
        builder.Configuration.GetConnectionString("Default"),
        ServerVersion.AutoDetect(builder.Configuration.GetConnectionString("Default")));
});

// ==========================================
// 3. 添加事件总线（可选）
// ==========================================
builder.Services.AddEventBusLocal();

// ==========================================
// 4. 添加 Redis 缓存（可选）
// ==========================================
builder.Services.AddRedisCaching(options =>
{
    options.Configuration = builder.Configuration.GetConnectionString("Redis");
});

var app = builder.Build();

// ==========================================
// 5. 启用 Skywalker 中间件（异常处理 + 工作单元）
// ==========================================
app.UseSkywalker();

app.Run();

using Skywalker.Ddd.Domain.Entities;

/// <summary>
/// 订单聚合根
/// </summary>
public class Order : AggregateRoot<Guid>
{
    /// <summary>
    /// 订单编号
    /// </summary>
    public string OrderNo { get; private set; } = null!;

    /// <summary>
    /// 客户ID
    /// </summary>
    public Guid CustomerId { get; private set; }

    /// <summary>
    /// 订单总金额
    /// </summary>
    public decimal TotalAmount { get; private set; }

    /// <summary>
    /// 订单状态
    /// </summary>
    public OrderStatus Status { get; private set; }

    /// <summary>
    /// 订单项列表
    /// </summary>
    public ICollection<OrderItem> Items { get; private set; } = new List<OrderItem>();

    /// <summary>
    /// EF Core 需要的无参构造函数
    /// </summary>
    protected Order() { }

    /// <summary>
    /// 创建订单
    /// </summary>
    public Order(Guid id, string orderNo, Guid customerId) : base(id)
    {
        OrderNo = orderNo ?? throw new ArgumentNullException(nameof(orderNo));
        CustomerId = customerId;
        Status = OrderStatus.Pending;
        TotalAmount = 0;
    }

    /// <summary>
    /// 添加订单项
    /// </summary>
    public void AddItem(string productName, int quantity, decimal unitPrice)
    {
        if (Status != OrderStatus.Pending)
            throw new InvalidOperationException("只有待处理订单可以添加商品");

        var item = new OrderItem(Guid.NewGuid(), Id, productName, quantity, unitPrice);
        Items.Add(item);
        RecalculateTotal();
    }

    /// <summary>
    /// 确认订单
    /// </summary>
    public void Confirm()
    {
        if (Status != OrderStatus.Pending)
            throw new InvalidOperationException("只有待处理订单可以确认");
        if (!Items.Any())
            throw new InvalidOperationException("订单必须包含至少一个商品");

        Status = OrderStatus.Confirmed;

        // 添加领域事件
        AddDistributedEvent(new OrderConfirmedEvent { OrderId = Id, OrderNo = OrderNo });
    }

    private void RecalculateTotal()
    {
        TotalAmount = Items.Sum(x => x.Quantity * x.UnitPrice);
    }
}

/// <summary>
/// 订单项实体
/// </summary>
public class OrderItem : Entity<Guid>
{
    public Guid OrderId { get; private set; }
    public string ProductName { get; private set; } = null!;
    public int Quantity { get; private set; }
    public decimal UnitPrice { get; private set; }

    protected OrderItem() { }

    public OrderItem(Guid id, Guid orderId, string productName, int quantity, decimal unitPrice) : base(id)
    {
        OrderId = orderId;
        ProductName = productName;
        Quantity = quantity;
        UnitPrice = unitPrice;
    }
}

public enum OrderStatus
{
    Pending,    // 待处理
    Confirmed,  // 已确认
    Shipped,    // 已发货
    Completed,  // 已完成
    Cancelled   // 已取消
}

using Skywalker.Ddd.Domain.Repositories;

/// <summary>
/// 订单仓储接口
/// </summary>
public interface IOrderRepository : IRepository<Order, Guid>
{
    /// <summary>
    /// 根据订单编号获取订单
    /// </summary>
    Task<Order?> GetByOrderNoAsync(string orderNo, CancellationToken cancellationToken = default);

    /// <summary>
    /// 获取客户的所有订单
    /// </summary>
    Task<List<Order>> GetByCustomerIdAsync(Guid customerId, CancellationToken cancellationToken = default);
}

using Skywalker.Ddd.EntityFrameworkCore.Repositories;

/// <summary>
/// 订单仓储实现
/// </summary>
public class OrderRepository : EfCoreRepository<AppDbContext, Order, Guid>, IOrderRepository
{
    public OrderRepository(IDbContextProvider<AppDbContext> dbContextProvider)
        : base(dbContextProvider)
    {
    }

    public async Task<Order?> GetByOrderNoAsync(string orderNo, CancellationToken cancellationToken = default)
    {
        var dbContext = await GetDbContextAsync();
        return await dbContext.Orders
            .Include(o => o.Items)
            .FirstOrDefaultAsync(o => o.OrderNo == orderNo, cancellationToken);
    }

    public async Task<List<Order>> GetByCustomerIdAsync(Guid customerId, CancellationToken cancellationToken = default)
    {
        var dbContext = await GetDbContextAsync();
        return await dbContext.Orders
            .Include(o => o.Items)
            .Where(o => o.CustomerId == customerId)
            .OrderByDescending(o => o.CreationTime)
            .ToListAsync(cancellationToken);
    }
}

using Skywalker.Ddd.Application.Services;

/// <summary>
/// 订单应用服务
/// </summary>
public class OrderAppService : ApplicationService, IOrderAppService
{
    private readonly IOrderRepository _orderRepository;
    private readonly ILocalEventBus _eventBus;
    private readonly OrderMapper _mapper = new();

    public OrderAppService(
        IOrderRepository orderRepository,
        ILocalEventBus eventBus)
    {
        _orderRepository = orderRepository;
        _eventBus = eventBus;
    }

    /// <summary>
    /// 创建订单
    /// </summary>
    public async Task<OrderDto> CreateAsync(CreateOrderInput input)
    {
        var order = new Order(
            GuidGenerator.Create(),
            GenerateOrderNo(),
            input.CustomerId);

        foreach (var item in input.Items)
        {
            order.AddItem(item.ProductName, item.Quantity, item.UnitPrice);
        }

        await _orderRepository.InsertAsync(order);

        // 发布订单创建事件
        await _eventBus.PublishAsync(new OrderCreatedEvent
        {
            OrderId = order.Id,
            OrderNo = order.OrderNo,
            CustomerId = order.CustomerId
        });

        return _mapper.ToDto(order);
    }

    /// <summary>
    /// 获取订单详情
    /// </summary>
    public async Task<OrderDto> GetAsync(Guid id)
    {
        var order = await _orderRepository.GetAsync(id);
        return _mapper.ToDto(order);
    }

    /// <summary>
    /// 确认订单
    /// </summary>
    public async Task ConfirmAsync(Guid id)
    {
        var order = await _orderRepository.GetAsync(id);
        order.Confirm();
        await _orderRepository.UpdateAsync(order);
    }

    private string GenerateOrderNo()
    {
        return $"ORD{DateTime.Now:yyyyMMddHHmmss}{Random.Shared.Next(1000, 9999)}";
    }
}