// ==================== VALUE OBJECTS ====================

// Shared value object - Money
public class Money : ValueObject
{
    public decimal Amount { get; }
    public string Currency { get; }

    public Money(decimal amount, string currency)
    {
        Amount = amount;
        Currency = currency;
    }

    protected override IEnumerable<object> GetEqualityComponents()
    {
        yield return Amount;
        yield return Currency;
    }
}

// Shared value object - Address
public class Address : ValueObject
{
    public string Street { get; }
    public string City { get; }
    public string PostalCode { get; }
    public string Country { get; }

    public Address(string street, string city, string postalCode, string country)
    {
        Street = street;
        City = city;
        PostalCode = postalCode;
        Country = country;
    }

    protected override IEnumerable<object> GetEqualityComponents()
    {
        yield return Street;
        yield return City;
        yield return PostalCode;
        yield return Country;
    }
}

// ==================== ORDER DOMAIN ====================

// Domain Events
public class OrderPlacedEvent : DomainEventBase
{
    public Guid OrderId { get; }
    public Guid CustomerId { get; }
    public IReadOnlyList<OrderItem> Items { get; }

    public OrderPlacedEvent(Guid orderId, Guid customerId, IReadOnlyList<OrderItem> items)
    {
        OrderId = orderId;
        CustomerId = customerId;
        Items = items;
    }
}

public class OrderShippedEvent : DomainEventBase
{
    public Guid OrderId { get; }
    public Address ShippingAddress { get; }
    public DateTime ShippedDate { get; }

    public OrderShippedEvent(Guid orderId, Address shippingAddress, DateTime shippedDate)
    {
        OrderId = orderId;
        ShippingAddress = shippingAddress;
        ShippedDate = shippedDate;
    }
}

// Order Aggregate Root
public class Order : EntityBase, IAggregateRoot
{
    private readonly List<OrderItem> _items = new();
    
    public Guid CustomerId { get; private set; }
    public OrderStatus Status { get; private set; }
    public Money TotalAmount { get; private set; }
    public Address ShippingAddress { get; private set; }
    public IReadOnlyList<OrderItem> Items => _items.AsReadOnly();

    private Order() { } // For EF Core

    public static Order Create(Guid customerId, Address shippingAddress)
    {
        var order = new Order
        {
            Id = Guid.NewGuid(),
            CustomerId = customerId,
            ShippingAddress = shippingAddress,
            Status = OrderStatus.Draft
        };
        return order;
    }

    public void AddItem(Guid productId, int quantity, Money unitPrice)
    {
        if (Status != OrderStatus.Draft)
            throw new InvalidOperationException("Cannot add items to a non-draft order");

        var item = new OrderItem(productId, quantity, unitPrice);
        _items.Add(item);
        RecalculateTotal();
    }

    public void PlaceOrder()
    {
        if (Status != OrderStatus.Draft)
            throw new InvalidOperationException("Order already placed");
        
        if (!_items.Any())
            throw new InvalidOperationException("Cannot place order without items");

        Status = OrderStatus.Placed;
        AddDomainEvent(new OrderPlacedEvent(Id, CustomerId, Items));
    }

    public void Ship()
    {
        if (Status != OrderStatus.Placed)
            throw new InvalidOperationException("Only placed orders can be shipped");

        Status = OrderStatus.Shipped;
        AddDomainEvent(new OrderShippedEvent(Id, ShippingAddress, DateTime.UtcNow));
    }

    private void RecalculateTotal()
    {
        var total = _items.Sum(i => i.TotalPrice.Amount);
        TotalAmount = new Money(total, "USD");
    }
}

// Entity within Order aggregate
public class OrderItem : EntityBase
{
    public Guid ProductId { get; private set; }
    public int Quantity { get; private set; }
    public Money UnitPrice { get; private set; }
    public Money TotalPrice => new Money(Quantity * UnitPrice.Amount, UnitPrice.Currency);

    internal OrderItem(Guid productId, int quantity, Money unitPrice)
    {
        Id = Guid.NewGuid();
        ProductId = productId;
        Quantity = quantity;
        UnitPrice = unitPrice;
    }
}

public enum OrderStatus { Draft, Placed, Shipped, Delivered, Cancelled }

// ==================== INVENTORY DOMAIN ====================

// Domain Events
public class InventoryReservedEvent : DomainEventBase
{
    public Guid ProductId { get; }
    public int Quantity { get; }
    public Guid OrderId { get; }

    public InventoryReservedEvent(Guid productId, int quantity, Guid orderId)
    {
        ProductId = productId;
        Quantity = quantity;
        OrderId = orderId;
    }
}

public class LowStockDetectedEvent : DomainEventBase
{
    public Guid ProductId { get; }
    public int CurrentStock { get; }
    public int ReorderThreshold { get; }

    public LowStockDetectedEvent(Guid productId, int currentStock, int reorderThreshold)
    {
        ProductId = productId;
        CurrentStock = currentStock;
        ReorderThreshold = reorderThreshold;
    }
}

// Product Aggregate Root
public class Product : EntityBase, IAggregateRoot
{
    public string Name { get; private set; }
    public int StockQuantity { get; private set; }
    public int ReorderThreshold { get; private set; }
    public Money Price { get; private set; }

    private Product() { } // For EF Core

    public static Product Create(string name, Money price, int initialStock, int reorderThreshold)
    {
        return new Product
        {
            Id = Guid.NewGuid(),
            Name = name,
            Price = price,
            StockQuantity = initialStock,
            ReorderThreshold = reorderThreshold
        };
    }

    public void ReserveStock(int quantity, Guid orderId)
    {
        if (StockQuantity < quantity)
            throw new InvalidOperationException($"Insufficient stock for {Name}");

        StockQuantity -= quantity;
        AddDomainEvent(new InventoryReservedEvent(Id, quantity, orderId));

        if (StockQuantity <= ReorderThreshold)
        {
            AddDomainEvent(new LowStockDetectedEvent(Id, StockQuantity, ReorderThreshold));
        }
    }

    public void RestockInventory(int quantity)
    {
        StockQuantity += quantity;
    }
}

// ==================== CUSTOMER DOMAIN ====================

// Domain Events
public class CustomerRewardPointsEarnedEvent : DomainEventBase
{
    public Guid CustomerId { get; }
    public int PointsEarned { get; }
    public Guid OrderId { get; }

    public CustomerRewardPointsEarnedEvent(Guid customerId, int pointsEarned, Guid orderId)
    {
        CustomerId = customerId;
        PointsEarned = pointsEarned;
        OrderId = orderId;
    }
}

// Customer Aggregate Root
public class Customer : EntityBase, IAggregateRoot
{
    public string Name { get; private set; }
    public string Email { get; private set; }
    public int RewardPoints { get; private set; }

    private Customer() { } // For EF Core

    public static Customer Create(string name, string email)
    {
        return new Customer
        {
            Id = Guid.NewGuid(),
            Name = name,
            Email = email,
            RewardPoints = 0
        };
    }

    public void AddRewardPoints(int points, Guid orderId)
    {
        RewardPoints += points;
        AddDomainEvent(new CustomerRewardPointsEarnedEvent(Id, points, orderId));
    }
}

// ==================== EVENT HANDLERS (Cross-Domain Coordination) ====================

// When an order is placed, reserve inventory for each item
public class OrderPlacedInventoryReservationHandler : IDomainEventHandler<OrderPlacedEvent>
{
    private readonly IRepository<Product> _productRepository;

    public OrderPlacedInventoryReservationHandler(IRepository<Product> productRepository)
    {
        _productRepository = productRepository;
    }

    public async Task Handle(OrderPlacedEvent domainEvent, CancellationToken cancellationToken)
    {
        foreach (var item in domainEvent.Items)
        {
            var product = await _productRepository.GetByIdAsync(item.ProductId, cancellationToken);
            product.ReserveStock(item.Quantity, domainEvent.OrderId);
            await _productRepository.UpdateAsync(product, cancellationToken);
        }
    }
}

// When an order is shipped, award reward points to the customer
public class OrderShippedRewardPointsHandler : IDomainEventHandler<OrderShippedEvent>
{
    private readonly IRepository<Customer> _customerRepository;
    private readonly IReadRepository<Order> _orderRepository;

    public OrderShippedRewardPointsHandler(
        IRepository<Customer> customerRepository,
        IReadRepository<Order> orderRepository)
    {
        _customerRepository = customerRepository;
        _orderRepository = orderRepository;
    }

    public async Task Handle(OrderShippedEvent domainEvent, CancellationToken cancellationToken)
    {
        var order = await _orderRepository.GetByIdAsync(domainEvent.OrderId, cancellationToken);
        var customer = await _customerRepository.GetByIdAsync(order.CustomerId, cancellationToken);
        
        // Award 1 point per $10 spent
        var points = (int)(order.TotalAmount.Amount / 10);
        customer.AddRewardPoints(points, order.Id);
        
        await _customerRepository.UpdateAsync(customer, cancellationToken);
    }
}

// When low stock is detected, notify purchasing team
public class LowStockNotificationHandler : IDomainEventHandler<LowStockDetectedEvent>
{
    private readonly IEmailService _emailService;

    public LowStockNotificationHandler(IEmailService emailService)
    {
        _emailService = emailService;
    }

    public async Task Handle(LowStockDetectedEvent domainEvent, CancellationToken cancellationToken)
    {
        await _emailService.SendAsync(
            to: "purchasing@company.com",
            subject: "Low Stock Alert",
            body: $"Product {domainEvent.ProductId} has only {domainEvent.CurrentStock} units remaining."
        );
    }
}

// ==================== USAGE IN APPLICATION LAYER ====================

public class PlaceOrderCommand
{
    public Guid CustomerId { get; set; }
    public Address ShippingAddress { get; set; }
    public List<OrderItemDto> Items { get; set; }
}

public class PlaceOrderCommandHandler
{
    private readonly IRepository<Order> _orderRepository;
    private readonly IDomainEventDispatcher _eventDispatcher;

    public PlaceOrderCommandHandler(
        IRepository<Order> orderRepository,
        IDomainEventDispatcher eventDispatcher)
    {
        _orderRepository = orderRepository;
        _eventDispatcher = eventDispatcher;
    }

    public async Task<Guid> Handle(PlaceOrderCommand command, CancellationToken cancellationToken)
    {
        // Create order aggregate
        var order = Order.Create(command.CustomerId, command.ShippingAddress);

        // Add items
        foreach (var item in command.Items)
        {
            order.AddItem(item.ProductId, item.Quantity, new Money(item.UnitPrice, "USD"));
        }

        // Place the order (raises OrderPlacedEvent)
        order.PlaceOrder();

        // Persist
        await _orderRepository.AddAsync(order, cancellationToken);

        // Dispatch domain events (triggers InventoryReservationHandler, etc.)
        await _eventDispatcher.DispatchAndClearEvents(order);

        return order.Id;
    }
}