Aarkam.DDD.Domain

// Define a Value Object (immutable, equality-by-value)
public sealed class Money : ValueObject
{
    public decimal Amount { get; }
    public string Currency { get; }

    public Money(decimal amount, string currency)
    {
        DomainGuard.AgainstNegative(amount, nameof(amount));
        Amount = amount;
        Currency = currency;
    }

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

// Define an Entity (identity-based, mutable)
public class OrderItem : Entity<Guid>
{
    public string ProductSku { get; private set; } = null!;
    public Money Price { get; private set; } = null!;
    public int Quantity { get; private set; }

    protected OrderItem() { }  // For EF Core

    public OrderItem(Guid id, string sku, Money price, int quantity) : base(id)
    {
        DomainGuard.AgainstNullOrEmpty(sku, nameof(sku));
        DomainGuard.AgainstNegativeOrZero(quantity, nameof(quantity));
        
        ProductSku = sku;
        Price = price;
        Quantity = quantity;
    }
}

// Define an Aggregate Root with Domain Events
public sealed class OrderPlacedEvent : DomainEvent<Order>
{
    public string CustomerId { get; init; } = null!;
    public decimal TotalValue { get; init; }
}

public class Order : AggregateRoot<Guid>
{
    public string CustomerId { get; private set; } = null!;
    public decimal TotalAmount { get; private set; }
    public OrderStatus Status { get; private set; }

    protected Order() { }  // For EF Core

    public Order(Guid id, string customerId) : base(id)
    {
        DomainGuard.AgainstNullOrEmpty(customerId, nameof(customerId));
        RaiseEvent(new OrderPlacedEvent(id.ToString(), Version + 1, customerId, 0));
    }

    protected override void ApplyEvent(IDomainEvent domainEvent)
    {
        if (domainEvent is OrderPlacedEvent e)
        {
            Id = Guid.Parse(e.AggregateId);
            CustomerId = e.CustomerId;
            TotalAmount = e.TotalValue;
            Status = OrderStatus.Created;
        }
    }
}

public enum OrderStatus { Created, Processing, Shipped, Completed }

public abstract class Entity<TKey> : IEntity<TKey>, IEquatable<Entity<TKey>>
    where TKey : IEquatable<TKey>
{
    public virtual TKey Id { get; protected set; }
    
    public virtual bool IsTransient() => EqualityComparer<TKey>.Default.Equals(Id, default);
}

public abstract class ValueObject : IEquatable<ValueObject>
{
    protected abstract IEnumerable<object?> GetEqualityComponents();
    
    public override int GetHashCode()
    {
        var hashCode = new HashCode();
        foreach (var component in GetEqualityComponents())
            hashCode.Add(component);
        return hashCode.ToHashCode();
    }
}

public abstract class AggregateRoot<TKey> : Entity<TKey>, IAggregateRoot<TKey>
{
    private readonly List<IDomainEvent> _changes = [];
    
    public virtual int Version { get; protected set; } = -1;
    public virtual Dictionary<string, object?> ExtraProperties { get; protected set; }
    public virtual bool IsDeleted { get; protected set; }
    public virtual string? TenantId { get; protected set; }
    
    protected void RaiseEvent(IDomainEvent domainEvent) => _changes.Add(domainEvent);
    protected abstract void ApplyEvent(IDomainEvent domainEvent);
    public IReadOnlyCollection<IDomainEvent> GetChanges() => _changes.AsReadOnly();
}

public static class DomainGuard
{
    public static void AgainstNull([NotNull] object? value, string parameterName);
    public static void AgainstNullOrEmpty([NotNull] string? value, string parameterName);
    public static void AgainstNegative(long value, string parameterName);
    public static void AgainstNegativeOrZero(long value, string parameterName);
    public static void AgainstOutOfRange(int value, int min, int max, string parameterName);
    public static void CheckRule(IBusinessRule rule);
}

public interface IBusinessRule
{
    bool IsBroken();
    string Message { get; }
}

public sealed class CustomerMustHaveValidEmailRule : IBusinessRule
{
    private readonly string _email;
    public CustomerMustHaveValidEmailRule(string email) => _email = email;
    
    public bool IsBroken() => !_email.Contains("@");
    public string Message => "Email format is invalid.";
}

// Usage
public void UpdateEmail(string newEmail)
{
    DomainGuard.AgainstNullOrEmpty(newEmail, nameof(newEmail));
    DomainGuard.CheckRule(new CustomerMustHaveValidEmailRule(newEmail));
    Email = newEmail;
}

public interface IDomainEvent
{
    string AggregateId { get; }
    int Version { get; }
    DateTime OccurredAt { get; }
    Dictionary<string, object>? Metadata { get; }
}

public abstract class DomainEvent<TAggregate> : IDomainEvent
    where TAggregate : AggregateRoot<Guid>
{
    public string AggregateId { get; init; } = null!;
    public int Version { get; init; }
    public DateTime OccurredAt { get; init; } = DateTime.UtcNow;
    public Dictionary<string, object>? Metadata { get; init; }
}

public sealed class ActiveOrdersSpecification : SpecificationBase<Order>
{
    public ActiveOrdersSpecification(string customerId, int pageIndex = 0, int pageSize = 10)
    {
        AddInclude(o => o.Items);
        AddInclude(o => o.Payments);
        OrderByDescending = o => o.CreationTime;
        Skip = pageIndex * pageSize;
        Take = pageSize;
    }

    public override Expression<Func<Order, bool>> ToExpression()
    {
        return order => order.CustomerId == customerId 
            && !order.IsDeleted
            && order.Status != OrderStatus.Completed;
    }
}

// Usage in Repository
public async Task<List<Order>> GetActiveOrdersAsync(string customerId)
{
    var spec = new ActiveOrdersSpecification(customerId);
    return await _context.Orders
        .Where(spec.ToExpression())
        .ToListAsync();
}

namespace Ecommerce.Orders.Domain;

// Value Objects
public sealed class OrderNumber : ValueObject
{
    public string Value { get; }
    
    public OrderNumber(string value)
    {
        DomainGuard.AgainstNullOrEmpty(value, nameof(value));
        Value = value;
    }
    
    protected override IEnumerable<object?> GetEqualityComponents()
    {
        yield return Value;
    }
}

public sealed class OrderLineItem : ValueObject
{
    public string Sku { get; }
    public int Quantity { get; }
    public Money UnitPrice { get; }

    public OrderLineItem(string sku, int quantity, Money unitPrice)
    {
        DomainGuard.AgainstNullOrEmpty(sku, nameof(sku));
        DomainGuard.AgainstNegativeOrZero(quantity, nameof(quantity));
        DomainGuard.AgainstNull(unitPrice, nameof(unitPrice));
        
        Sku = sku;
        Quantity = quantity;
        UnitPrice = unitPrice;
    }

    public Money GetLineTotal() => new(UnitPrice.Amount * Quantity, UnitPrice.Currency);

    protected override IEnumerable<object?> GetEqualityComponents()
    {
        yield return Sku;
        yield return Quantity;
        yield return UnitPrice;
    }
}

// Domain Events
public sealed class OrderCreatedEvent : DomainEvent<Order>
{
    public string CustomerId { get; init; } = null!;
    public List<OrderLineItem> LineItems { get; init; } = [];
    public Money TotalAmount { get; init; } = null!;
}

public sealed class OrderConfirmedEvent : DomainEvent<Order>
{
    public string ConfirmedBy { get; init; } = null!;
    public DateTime ConfirmedAt { get; init; }
}

public sealed class OrderCancelledEvent : DomainEvent<Order>
{
    public string CancellationReason { get; init; } = null!;
}

// Aggregate Root
public class Order : AggregateRoot<Guid>
{
    private readonly List<OrderLineItem> _lineItems = [];

    public OrderNumber OrderNumber { get; private set; } = null!;
    public string CustomerId { get; private set; } = null!;
    public Money TotalAmount { get; private set; } = null!;
    public OrderStatus Status { get; private set; }
    public IReadOnlyList<OrderLineItem> LineItems => _lineItems.AsReadOnly();

    protected Order() { }  // For EF Core

    public Order(Guid id, OrderNumber orderNumber, string customerId) : base(id)
    {
        DomainGuard.AgainstNull(orderNumber, nameof(orderNumber));
        DomainGuard.AgainstNullOrEmpty(customerId, nameof(customerId));

        OrderNumber = orderNumber;
        CustomerId = customerId;
        Status = OrderStatus.Draft;

        RaiseEvent(new OrderCreatedEvent
        {
            AggregateId = id.ToString(),
            Version = Version + 1,
            CustomerId = customerId
        });
    }

    public void AddLineItem(OrderLineItem lineItem)
    {
        DomainGuard.Against<InvalidOperationException>(
            Status != OrderStatus.Draft,
            "Cannot add items to a confirmed order."
        );
        DomainGuard.AgainstNull(lineItem, nameof(lineItem));

        _lineItems.Add(lineItem);
        RecalculateTotal();
    }

    public void Confirm(string confirmedBy)
    {
        DomainGuard.AgainstNullOrEmpty(confirmedBy, nameof(confirmedBy));
        DomainGuard.Against<InvalidOperationException>(
            _lineItems.Count == 0,
            "Cannot confirm an empty order."
        );

        Status = OrderStatus.Confirmed;
        RaiseEvent(new OrderConfirmedEvent
        {
            AggregateId = Id.ToString(),
            Version = Version + 1,
            ConfirmedBy = confirmedBy,
            ConfirmedAt = DateTime.UtcNow
        });
    }

    public void Cancel(string reason)
    {
        DomainGuard.AgainstNullOrEmpty(reason, nameof(reason));
        DomainGuard.Against<InvalidOperationException>(
            Status == OrderStatus.Completed,
            "Cannot cancel a completed order."
        );

        Status = OrderStatus.Cancelled;
        RaiseEvent(new OrderCancelledEvent
        {
            AggregateId = Id.ToString(),
            Version = Version + 1,
            CancellationReason = reason
        });
    }

    protected override void ApplyEvent(IDomainEvent domainEvent)
    {
        switch (domainEvent)
        {
            case OrderCreatedEvent e:
                OrderNumber = new(e.AggregateId);
                CustomerId = e.CustomerId;
                TotalAmount = e.TotalAmount;
                Status = OrderStatus.Draft;
                break;

            case OrderConfirmedEvent:
                Status = OrderStatus.Confirmed;
                break;

            case OrderCancelledEvent:
                Status = OrderStatus.Cancelled;
                break;
        }
    }

    private void RecalculateTotal()
    {
        var total = _lineItems.Sum(li => li.GetLineTotal().Amount);
        TotalAmount = new(total, "USD");
    }
}

public enum OrderStatus { Draft, Confirmed, Processing, Shipped, Completed, Cancelled }

// Inject current tenant from authentication middleware
public class OrderService
{
    private readonly IOrderRepository _repository;
    private readonly ICurrentTenant _currentTenant;

    public OrderService(IOrderRepository repository, ICurrentTenant currentTenant)
    {
        _repository = repository;
        _currentTenant = currentTenant;
    }

    public async Task CreateOrderAsync(CreateOrderRequest request)
    {
        var order = new Order(Guid.NewGuid(), request.OrderNumber, request.CustomerId);
        order.TenantId = _currentTenant.Id;  // Automatically scoped to tenant

        await _repository.AddAsync(order);
        await _repository.SaveChangesAsync();
    }

    // Tenant context switching for background jobs
    public async Task ProcessCrossTenantSyncAsync(string targetTenantId, Guid orderId)
    {
        using (_currentTenant.Change(targetTenantId))
        {
            var order = await _repository.GetAsync(orderId);
            order.Confirm("system");
            await _repository.UpdateAsync(order);
        }
    }
}

// ✅ CORRECT: Inject TenantId from authenticated context
public void Create(CreateOrderRequest request)
{
    var order = new Order(Guid.NewGuid(), request.OrderNumber, request.CustomerId);
    order.TenantId = _currentTenant.Id;  // Set from middleware, not user input
    _repository.Add(order);
}

// ❌ WRONG: TenantId from user input
public void Create(CreateOrderRequest request)
{
    var order = new Order(Guid.NewGuid(), request.OrderNumber, request.CustomerId);
    order.TenantId = request.TenantId;  // SECURITY BUG: trusting user input!
}

public class Order : AggregateRoot<Guid>
{
    [JsonIgnore]
    public string? InternalNotes { get; private set; }

    [JsonIgnore]
    public Dictionary<string, object?> ExtraProperties { get; protected set; }
}

public void UpdatePrice(Money newPrice)
{
    DomainGuard.AgainstNull(newPrice, nameof(newPrice));
    DomainGuard.AgainstNegative(newPrice.Amount, nameof(newPrice.Amount));
    
    // Only here is the price safe to mutate
    Price = newPrice;
}