Business Logic & Domain Entities

public class Product : FullAuditedAggregateRoot<Guid>
{
    // Properties
    public string Name { get; set; }
    public string Slug { get; set; }
    public decimal? Price { get; set; }
    public decimal? DiscountPrice { get; set; }
    public int? StockQuantity { get; set; }
    public bool IsActive { get; set; }
    public bool IsFeatured { get; set; }
    public int ViewCount { get; set; }
    public decimal AverageRating { get; set; }
    public int RatingCount { get; set; }

    // Business Methods
    public void DecreaseStock(int quantity)
    {
        if (quantity <= 0)
            throw new BusinessException("Quantity must be positive");

        if (StockQuantity < quantity)
            throw new BusinessException("Insufficient stock");

        StockQuantity -= quantity;
    }

    public void IncreaseStock(int quantity)
    {
        if (quantity <= 0)
            throw new BusinessException("Quantity must be positive");

        StockQuantity += quantity;
    }

    public void UpdateRating(decimal newRating)
    {
        // Recalculate average rating
        var totalRating = (AverageRating * RatingCount) + newRating;
        RatingCount++;
        AverageRating = totalRating / RatingCount;
    }

    public bool IsInStock() => StockQuantity.HasValue && StockQuantity > 0;

    public decimal GetEffectivePrice()
    {
        return DiscountPrice.HasValue && DiscountPrice > 0
            ? DiscountPrice.Value
            : Price ?? 0;
    }

    public bool IsDiscounted() => DiscountPrice.HasValue && DiscountPrice < Price;

    public decimal GetDiscountPercentage()
    {
        if (!IsDiscounted() || !Price.HasValue || Price == 0)
            return 0;

        return ((Price.Value - DiscountPrice.Value) / Price.Value) * 100;
    }

    public bool IsLowStock()
    {
        return LowStockThreshold.HasValue &&
               StockQuantity.HasValue &&
               StockQuantity <= LowStockThreshold;
    }
}

public class Order : FullAuditedAggregateRoot<Guid>
{
    public string OrderNumber { get; set; }
    public Guid? UserId { get; set; }
    public OrderStatus Status { get; set; }
    public decimal Subtotal { get; set; }
    public decimal DiscountAmount { get; set; }
    public decimal TaxAmount { get; set; }
    public decimal ShippingCost { get; set; }
    public decimal Total { get; set; }

    public ICollection<OrderItem> Items { get; set; }
    public ICollection<OrderStatusHistory> StatusHistory { get; set; }

    // Business Methods
    public void UpdateStatus(OrderStatus newStatus, Guid? changedByUserId, string notes = null)
    {
        // Validate status transition
        if (!CanTransitionTo(newStatus))
        {
            throw new BusinessException($"Cannot change order status from {Status} to {newStatus}");
        }

        var oldStatus = Status;
        Status = newStatus;

        // Add to history
        var history = new OrderStatusHistory
        {
            OrderId = Id,
            FromStatus = oldStatus,
            ToStatus = newStatus,
            ChangedAt = DateTime.UtcNow,
            ChangedByUserId = changedByUserId,
            Notes = notes
        };

        StatusHistory.Add(history);
    }

    private bool CanTransitionTo(OrderStatus newStatus)
    {
        return (Status, newStatus) switch
        {
            (OrderStatus.Pending, OrderStatus.Processing) => true,
            (OrderStatus.Pending, OrderStatus.Cancelled) => true,
            (OrderStatus.Processing, OrderStatus.Shipped) => true,
            (OrderStatus.Processing, OrderStatus.Cancelled) => true,
            (OrderStatus.Shipped, OrderStatus.Delivered) => true,
            (OrderStatus.Delivered, OrderStatus.Returned) => true,
            _ => false
        };
    }

    public void CalculateTotals()
    {
        Subtotal = Items.Sum(i => i.LineTotal);
        Total = Subtotal - DiscountAmount + TaxAmount + ShippingCost;
    }

    public void ApplyDiscount(decimal amount)
    {
        if (amount < 0 || amount > Subtotal)
            throw new BusinessException("Invalid discount amount");

        DiscountAmount = amount;
        CalculateTotals();
    }

    public bool CanBeCancelled()
    {
        return Status == OrderStatus.Pending || Status == OrderStatus.Processing;
    }

    public void Cancel(string reason)
    {
        if (!CanBeCancelled())
            throw new BusinessException("Order cannot be cancelled");

        Status = OrderStatus.Cancelled;
        // Restore product stock
        foreach (var item in Items)
        {
            // This would be done in domain service
        }
    }
}

public class Cart : FullAuditedAggregateRoot<Guid>
{
    public Guid? UserId { get; set; }
    public string? SessionId { get; set; }
    public bool IsActive { get; set; }
    public DateTime ExpiresAt { get; set; }
    public decimal Subtotal { get; set; }
    public decimal DiscountAmount { get; set; }
    public decimal Total { get; set; }

    public ICollection<CartItem> Items { get; set; }

    public void AddItem(Guid productId, string productName, decimal price, int quantity)
    {
        if (quantity <= 0)
            throw new BusinessException("Quantity must be positive");

        // Check if item already exists
        var existingItem = Items.FirstOrDefault(i => i.ProductId == productId);
        if (existingItem != null)
        {
            existingItem.Quantity += quantity;
        }
        else
        {
            var newItem = new CartItem
            {
                CartId = Id,
                ProductId = productId,
                ProductName = productName,
                Price = price,
                Quantity = quantity
            };
            Items.Add(newItem);
        }

        CalculateTotals();
    }

    public void UpdateItemQuantity(Guid itemId, int quantity)
    {
        if (quantity <= 0)
            throw new BusinessException("Quantity must be positive");

        var item = Items.FirstOrDefault(i => i.Id == itemId);
        if (item == null)
            throw new BusinessException("Item not found in cart");

        item.Quantity = quantity;
        CalculateTotals();
    }

    public void RemoveItem(Guid itemId)
    {
        var item = Items.FirstOrDefault(i => i.Id == itemId);
        if (item != null)
        {
            Items.Remove(item);
            CalculateTotals();
        }
    }

    public void Clear()
    {
        Items.Clear();
        Subtotal = 0;
        Total = 0;
        DiscountAmount = 0;
    }

    public void CalculateTotals()
    {
        Subtotal = Items.Sum(i => i.Price * i.Quantity);
        Total = Subtotal - DiscountAmount;
    }

    public bool IsEmpty() => !Items.Any();

    public int GetTotalItems() => Items.Sum(i => i.Quantity);
}

// Example Domain Event
public class OrderCreatedEvent : IDistributedEvent
{
    public Guid OrderId { get; set; }
    public string OrderNumber { get; set; }
    public Guid? UserId { get; set; }
    public decimal Total { get; set; }
    public DateTime CreatedAt { get; set; }
}

// Example Event Handler
public class OrderCreatedEventHandler : IDistributedEventHandler<OrderCreatedEvent>
{
    private readonly IEmailService _emailService;
    private readonly INotificationService _notificationService;

    public async Task HandleEventAsync(OrderCreatedEvent eventData)
    {
        // Send confirmation email
        await _emailService.SendOrderConfirmationAsync(eventData.OrderId);

        // Create in-app notification
        await _notificationService.CreateNotificationAsync(
            eventData.UserId,
            NotificationType.OrderCreated,
            $"سفارش {eventData.OrderNumber} با موفقیت ثبت شد"
        );
    }
}

// Example Domain Service
public class OrderDomainService : DomainService
{
    private readonly IRepository<Product, Guid> _productRepository;
    private readonly IRepository<OrderStatusHistory, Guid> _historyRepository;

    public async Task<Order> CreateOrderFromCartAsync(Cart cart, UserAddress address)
    {
        // Validate cart
        if (cart.IsEmpty())
            throw new BusinessException("سبد خرید خالی است");

        // Check stock availability for all items
        foreach (var item in cart.Items)
        {
            var product = await _productRepository.GetAsync(item.ProductId);
            if (!product.IsInStock() || product.StockQuantity < item.Quantity)
            {
                throw new BusinessException($"محصول {product.Name} موجود نیست");
            }
        }

        // Create order
        var order = new Order(GuidGenerator.Create(), await GenerateOrderNumberAsync());
        order.UserId = cart.UserId;
        order.CustomerName = address.RecipientName;
        order.CustomerPhone = address.RecipientPhone;
        order.ShippingAddress = address.GetFullAddress();
        order.Status = OrderStatus.Pending;

        // Add items and decrease stock
        foreach (var cartItem in cart.Items)
        {
            var orderItem = new OrderItem(GuidGenerator.Create());
            orderItem.ProductId = cartItem.ProductId;
            orderItem.ProductName = cartItem.ProductName;
            orderItem.Quantity = cartItem.Quantity;
            orderItem.UnitPrice = cartItem.Price;
            orderItem.LineTotal = cartItem.Quantity * cartItem.Price;

            order.Items.Add(orderItem);

            // Decrease stock
            var product = await _productRepository.GetAsync(cartItem.ProductId);
            product.DecreaseStock(cartItem.Quantity);
        }

        order.CalculateTotals();

        return order;
    }

    public async Task CancelOrderAndRestoreStockAsync(Order order)
    {
        if (!order.CanBeCancelled())
            throw new BusinessException("این سفارش قابل لغو نیست");

        // Restore product stock
        foreach (var item in order.Items)
        {
            var product = await _productRepository.GetAsync(item.ProductId);
            product.IncreaseStock(item.Quantity);
        }

        // Update order status
        order.UpdateStatus(OrderStatus.Cancelled, null, "لغو شده توسط سیستم");
    }
}