namespace ECommerceApi.Models;

public class User
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public string Email { get; set; } = string.Empty;
    public string PasswordHash { get; set; } = string.Empty;
    public string Role { get; set; } = "Customer";
    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;

    public ICollection<Order> Orders { get; set; } = new List<Order>();
}

namespace ECommerceApi.Models;

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public string Description { get; set; } = string.Empty;
    public decimal Price { get; set; }
    public int Stock { get; set; }
    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;

    public ICollection<OrderItem> OrderItems { get; set; } = new List<OrderItem>();
}

namespace ECommerceApi.Models;

public class Order
{
    public int Id { get; set; }
    public int UserId { get; set; }
    public User User { get; set; } = null!;
    public string Status { get; set; } = "Pending";
    public decimal TotalAmount { get; set; }
    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;

    public ICollection<OrderItem> Items { get; set; } = new List<OrderItem>();
}

namespace ECommerceApi.Models;

public class OrderItem
{
    public int Id { get; set; }
    public int OrderId { get; set; }
    public Order Order { get; set; } = null!;
    public int ProductId { get; set; }
    public Product Product { get; set; } = null!;
    public int Quantity { get; set; }
    public decimal UnitPrice { get; set; }
}

using ECommerceApi.Models;
using Microsoft.EntityFrameworkCore;

namespace ECommerceApi.Data;

public class AppDbContext : DbContext
{
    public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { }

    public DbSet<User> Users => Set<User>();
    public DbSet<Product> Products => Set<Product>();
    public DbSet<Order> Orders => Set<Order>();
    public DbSet<OrderItem> OrderItems => Set<OrderItem>();

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<User>()
            .HasIndex(u => u.Email)
            .IsUnique();

        modelBuilder.Entity<Product>().Property(p => p.Price).HasPrecision(18, 2);
        modelBuilder.Entity<Order>().Property(o => o.TotalAmount).HasPrecision(18, 2);
        modelBuilder.Entity<OrderItem>().Property(oi => oi.UnitPrice).HasPrecision(18, 2);

        modelBuilder.Entity<OrderItem>()
            .HasOne(oi => oi.Order).WithMany(o => o.Items)
            .HasForeignKey(oi => oi.OrderId).OnDelete(DeleteBehavior.Cascade);

        modelBuilder.Entity<OrderItem>()
            .HasOne(oi => oi.Product).WithMany(p => p.OrderItems)
            .HasForeignKey(oi => oi.ProductId).OnDelete(DeleteBehavior.Restrict);
    }
}

using System.ComponentModel.DataAnnotations;

namespace ECommerceApi.DTOs.Auth;

public class RegisterDto
{
    [Required] public string Name { get; set; } = string.Empty;
    [Required, EmailAddress] public string Email { get; set; } = string.Empty;
    [Required, MinLength(6)] public string Password { get; set; } = string.Empty;
}

using System.ComponentModel.DataAnnotations;

namespace ECommerceApi.DTOs.Auth;

public class LoginDto
{
    [Required, EmailAddress] public string Email { get; set; } = string.Empty;
    [Required] public string Password { get; set; } = string.Empty;
}

namespace ECommerceApi.DTOs.Auth;

public class AuthResponseDto
{
    public string Token { get; set; } = string.Empty;
    public string Email { get; set; } = string.Empty;
    public string Name { get; set; } = string.Empty;
    public string Role { get; set; } = string.Empty;
}

namespace ECommerceApi.DTOs.Products;

public class ProductDto
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public string Description { get; set; } = string.Empty;
    public decimal Price { get; set; }
    public int Stock { get; set; }
}

using System.ComponentModel.DataAnnotations;

namespace ECommerceApi.DTOs.Products;

public class CreateProductDto
{
    [Required] public string Name { get; set; } = string.Empty;
    public string Description { get; set; } = string.Empty;
    [Range(0.01, double.MaxValue)] public decimal Price { get; set; }
    [Range(0, int.MaxValue)] public int Stock { get; set; }
}

using System.ComponentModel.DataAnnotations;

namespace ECommerceApi.DTOs.Orders;

public class CreateOrderDto
{
    [Required, MinLength(1)] public List<OrderItemRequestDto> Items { get; set; } = new();
}

public class OrderItemRequestDto
{
    [Required] public int ProductId { get; set; }
    [Range(1, int.MaxValue)] public int Quantity { get; set; }
}

namespace ECommerceApi.DTOs.Orders;

public class OrderResponseDto
{
    public int Id { get; set; }
    public string Status { get; set; } = string.Empty;
    public decimal TotalAmount { get; set; }
    public DateTime CreatedAt { get; set; }
    public List<OrderItemResponseDto> Items { get; set; } = new();
}

public class OrderItemResponseDto
{
    public int ProductId { get; set; }
    public string ProductName { get; set; } = string.Empty;
    public int Quantity { get; set; }
    public decimal UnitPrice { get; set; }
    public decimal Subtotal => Quantity * UnitPrice;
}

using System.ComponentModel.DataAnnotations;

namespace ECommerceApi.DTOs.Orders;

public class UpdateOrderStatusDto
{
    [Required] public string Status { get; set; } = string.Empty;
}

using ECommerceApi.Models;

namespace ECommerceApi.Services;

public interface ITokenService
{
    string CreateToken(User user);
}

using ECommerceApi.Models;
using Microsoft.IdentityModel.Tokens;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;

namespace ECommerceApi.Services;

public class TokenService : ITokenService
{
    private readonly IConfiguration _config;
    public TokenService(IConfiguration config) => _config = config;

    public string CreateToken(User user)
    {
        var secret = _config["Jwt:SigningSecret"]
            ?? throw new InvalidOperationException("JWT signing secret not configured.");

        var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(secret));
        var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);

        var claims = new[]
        {
            new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()),
            new Claim(ClaimTypes.Email, user.Email),
            new Claim(ClaimTypes.Name, user.Name),
            new Claim(ClaimTypes.Role, user.Role)
        };

        var token = new JwtSecurityToken(
            issuer: _config["Jwt:Issuer"],
            audience: _config["Jwt:Audience"],
            claims: claims,
            expires: DateTime.UtcNow.AddHours(24),
            signingCredentials: creds);

        return new JwtSecurityTokenHandler().WriteToken(token);
    }
}

namespace ECommerceApi.Services;

public interface IEmailService
{
    Task SendWelcomeEmailAsync(string toEmail, string name);
    Task SendOrderConfirmationAsync(string toEmail, string name, int orderId, decimal total);
}

using MailKit.Net.Smtp;
using MailKit.Security;
using MimeKit;

namespace ECommerceApi.Services;

public class EmailService : IEmailService
{
    private readonly IConfiguration _config;
    private readonly ILogger<EmailService> _logger;

    public EmailService(IConfiguration config, ILogger<EmailService> logger)
    {
        _config = config;
        _logger = logger;
    }

    public async Task SendWelcomeEmailAsync(string toEmail, string name) =>
        await SendEmailAsync(toEmail, name, "Welcome to ECommerce Store!",
            $"<h2>Welcome, {name}!</h2><p>Thank you for registering at our store.</p>");

    public async Task SendOrderConfirmationAsync(string toEmail, string name, int orderId, decimal total) =>
        await SendEmailAsync(toEmail, name, $"Order #{orderId} Confirmed",
            $"<h2>Order Confirmed, {name}!</h2><p>Order <strong>#{orderId}</strong> — Total: <strong>${total:F2}</strong></p>");

    private async Task SendEmailAsync(string toEmail, string toName, string subject, string htmlBody)
    {
        var host     = _config["Smtp:Host"]     ?? throw new InvalidOperationException("SMTP host not configured.");
        var port     = int.Parse(_config["Smtp:Port"] ?? "587");
        var username = _config["Smtp:Username"] ?? throw new InvalidOperationException("SMTP username not configured.");
        var password = _config["Smtp:Password"] ?? throw new InvalidOperationException("SMTP password not configured.");
        var fromEmail = _config["Smtp:FromEmail"] ?? username;
        var fromName  = _config["Smtp:FromName"]  ?? "ECommerce Store";

        var message = new MimeMessage();
        message.From.Add(new MailboxAddress(fromName, fromEmail));
        message.To.Add(new MailboxAddress(toName, toEmail));
        message.Subject = subject;
        message.Body = new TextPart("html") { Text = htmlBody };

        using var client = new SmtpClient();
        await client.ConnectAsync(host, port, SecureSocketOptions.StartTls);
        await client.AuthenticateAsync(username, password);
        await client.SendAsync(message);
        await client.DisconnectAsync(true);

        _logger.LogInformation("Email sent to {Email} — Subject: {Subject}", toEmail, subject);
    }
}

using ECommerceApi.Data;
using ECommerceApi.DTOs.Auth;
using ECommerceApi.Models;
using ECommerceApi.Services;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;

namespace ECommerceApi.Controllers;

[ApiController]
[Route("api/[controller]")]
public class AuthController : ControllerBase
{
    private readonly AppDbContext _db;
    private readonly ITokenService _tokenService;
    private readonly IEmailService _emailService;
    private readonly ILogger<AuthController> _logger;

    public AuthController(AppDbContext db, ITokenService tokenService,
        IEmailService emailService, ILogger<AuthController> logger)
    {
        _db = db; _tokenService = tokenService;
        _emailService = emailService; _logger = logger;
    }

    [HttpPost("register")]
    public async Task<ActionResult<AuthResponseDto>> Register(RegisterDto dto)
    {
        if (await _db.Users.AnyAsync(u => u.Email == dto.Email))
            return Conflict(new { message = "Email is already registered." });

        var user = new User
        {
            Name = dto.Name,
            Email = dto.Email,
            PasswordHash = BCrypt.Net.BCrypt.HashPassword(dto.Password)
        };
        _db.Users.Add(user);
        await _db.SaveChangesAsync();

        _ = _emailService.SendWelcomeEmailAsync(user.Email, user.Name)
            .ContinueWith(t => _logger.LogWarning(t.Exception,
                "Welcome email failed for {Email}", user.Email),
                TaskContinuationOptions.OnlyOnFaulted);

        var token = _tokenService.CreateToken(user);
        return Ok(new AuthResponseDto { Token = token, Email = user.Email, Name = user.Name, Role = user.Role });
    }

    [HttpPost("login")]
    public async Task<ActionResult<AuthResponseDto>> Login(LoginDto dto)
    {
        var user = await _db.Users.SingleOrDefaultAsync(u => u.Email == dto.Email);
        if (user is null || !BCrypt.Net.BCrypt.Verify(dto.Password, user.PasswordHash))
            return Unauthorized(new { message = "Invalid email or password." });

        var token = _tokenService.CreateToken(user);
        return Ok(new AuthResponseDto { Token = token, Email = user.Email, Name = user.Name, Role = user.Role });
    }
}

using ECommerceApi.Data;
using ECommerceApi.DTOs.Products;
using ECommerceApi.Models;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;

namespace ECommerceApi.Controllers;

[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
    private readonly AppDbContext _db;
    public ProductsController(AppDbContext db) => _db = db;

    [HttpGet]
    public async Task<ActionResult<List<ProductDto>>> GetAll() =>
        Ok(await _db.Products.Select(p => new ProductDto
        {
            Id = p.Id, Name = p.Name, Description = p.Description,
            Price = p.Price, Stock = p.Stock
        }).ToListAsync());

    [HttpGet("{id}")]
    public async Task<ActionResult<ProductDto>> GetById(int id)
    {
        var p = await _db.Products.FindAsync(id);
        if (p is null) return NotFound();
        return Ok(new ProductDto { Id = p.Id, Name = p.Name, Description = p.Description, Price = p.Price, Stock = p.Stock });
    }

    [HttpPost]
    public async Task<ActionResult<ProductDto>> Create(CreateProductDto dto)
    {
        var product = new Product { Name = dto.Name, Description = dto.Description, Price = dto.Price, Stock = dto.Stock };
        _db.Products.Add(product);
        await _db.SaveChangesAsync();
        var result = new ProductDto { Id = product.Id, Name = product.Name, Description = product.Description, Price = product.Price, Stock = product.Stock };
        return CreatedAtAction(nameof(GetById), new { id = product.Id }, result);
    }

    [HttpPut("{id}")]
    public async Task<IActionResult> Update(int id, CreateProductDto dto)
    {
        var product = await _db.Products.FindAsync(id);
        if (product is null) return NotFound();
        product.Name = dto.Name; product.Description = dto.Description;
        product.Price = dto.Price; product.Stock = dto.Stock;
        await _db.SaveChangesAsync();
        return NoContent();
    }

    [HttpDelete("{id}")]
    public async Task<IActionResult> Delete(int id)
    {
        var product = await _db.Products.FindAsync(id);
        if (product is null) return NotFound();
        _db.Products.Remove(product);
        await _db.SaveChangesAsync();
        return NoContent();
    }
}

using ECommerceApi.Data;
using ECommerceApi.DTOs.Orders;
using ECommerceApi.Models;
using ECommerceApi.Services;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using System.Security.Claims;

namespace ECommerceApi.Controllers;

[ApiController]
[Route("api/[controller]")]
public class OrdersController : ControllerBase
{
    private readonly AppDbContext _db;
    private readonly IEmailService _emailService;
    private readonly ILogger<OrdersController> _logger;

    public OrdersController(AppDbContext db, IEmailService emailService, ILogger<OrdersController> logger)
    {
        _db = db; _emailService = emailService; _logger = logger;
    }

    [HttpPost]
    public async Task<ActionResult<OrderResponseDto>> CreateOrder(CreateOrderDto dto)
    {
        var userId = int.Parse(User.FindFirstValue(ClaimTypes.NameIdentifier)!);
        var user = await _db.Users.FindAsync(userId);
        if (user is null) return Unauthorized();

        var productIds = dto.Items.Select(i => i.ProductId).Distinct().ToList();
        var products = await _db.Products.Where(p => productIds.Contains(p.Id)).ToDictionaryAsync(p => p.Id);

        var order = new Order { UserId = userId };
        foreach (var item in dto.Items)
        {
            if (!products.TryGetValue(item.ProductId, out var product))
                return BadRequest(new { message = $"Product ID {item.ProductId} not found." });
            if (product.Stock < item.Quantity)
                return BadRequest(new { message = $"Insufficient stock for '{product.Name}'." });

            product.Stock -= item.Quantity;
            order.Items.Add(new OrderItem { ProductId = product.Id, Quantity = item.Quantity, UnitPrice = product.Price });
            order.TotalAmount += item.Quantity * product.Price;
        }

        _db.Orders.Add(order);
        await _db.SaveChangesAsync();

        _ = _emailService.SendOrderConfirmationAsync(user.Email, user.Name, order.Id, order.TotalAmount)
            .ContinueWith(t => _logger.LogWarning(t.Exception,
                "Order confirmation email failed for order #{OrderId}", order.Id),
                TaskContinuationOptions.OnlyOnFaulted);

        return CreatedAtAction(nameof(GetById), new { id = order.Id }, MapToDto(order, products));
    }

    [HttpGet]
    public async Task<ActionResult<List<OrderResponseDto>>> GetMyOrders()
    {
        var userId = int.Parse(User.FindFirstValue(ClaimTypes.NameIdentifier)!);
        var orders = await _db.Orders
            .Include(o => o.Items).ThenInclude(i => i.Product)
            .Where(o => o.UserId == userId)
            .OrderByDescending(o => o.CreatedAt)
            .ToListAsync();
        return Ok(orders.Select(o => MapToDto(o)));
    }

    [HttpGet("{id}")]
    public async Task<ActionResult<OrderResponseDto>> GetById(int id)
    {
        var userId = int.Parse(User.FindFirstValue(ClaimTypes.NameIdentifier)!);
        var isAdmin = User.IsInRole("Admin");
        var order = await _db.Orders.Include(o => o.Items).ThenInclude(i => i.Product)
            .FirstOrDefaultAsync(o => o.Id == id);
        if (order is null) return NotFound();
        if (!isAdmin && order.UserId != userId) return Forbid();
        return Ok(MapToDto(order));
    }

    [HttpPatch("{id}/status")]
    public async Task<IActionResult> UpdateStatus(int id, UpdateOrderStatusDto dto)
    {
        var order = await _db.Orders.FindAsync(id);
        if (order is null) return NotFound();
        order.Status = dto.Status;
        await _db.SaveChangesAsync();
        return NoContent();
    }

    private static OrderResponseDto MapToDto(Order order, Dictionary<int, Product>? productMap = null) =>
        new()
        {
            Id = order.Id, Status = order.Status,
            TotalAmount = order.TotalAmount, CreatedAt = order.CreatedAt,
            Items = order.Items.Select(i => new OrderItemResponseDto
            {
                ProductId = i.ProductId,
                ProductName = productMap != null
                    ? (productMap.TryGetValue(i.ProductId, out var p) ? p.Name : string.Empty)
                    : i.Product?.Name ?? string.Empty,
                Quantity = i.Quantity, UnitPrice = i.UnitPrice
            }).ToList()
        };
}

using Microsoft.AspNetCore.Mvc;

namespace ECommerceApi.Controllers;

/// <summary>
/// Development-only endpoint to verify Azure Key Vault secrets are loaded correctly.
/// Remove or restrict this controller before deploying to production.
/// </summary>
[ApiController]
[Route("api/[controller]")]
public class ConfigController : ControllerBase
{
    private readonly IConfiguration _config;
    private readonly IWebHostEnvironment _env;

    // Keys expected to be loaded from Azure Key Vault
    private static readonly string[] SecretKeys =
    [
        "SqlServer:ConnectionString",
        "Jwt:SigningSecret",
        "Jwt:Issuer",
        "Jwt:Audience",
        "Smtp:Host",
        "Smtp:Port",
        "Smtp:Username",
        "Smtp:Password",
        "Smtp:FromEmail",
        "Smtp:FromName"
    ];

    // Keys whose values should be masked for safety
    private static readonly string[] SensitiveKeys =
    [
        "SqlServer:ConnectionString",
        "Jwt:SigningSecret",
        "Smtp:Password"
    ];

    public ConfigController(IConfiguration config, IWebHostEnvironment env)
    {
        _config = config;
        _env = env;
    }

    /// <summary>
    /// Returns all Azure Key Vault secret keys and their values.
    /// Sensitive values (passwords, secrets) are partially masked.
    /// Only available in Development environment.
    /// </summary>
    [HttpGet("keyvault-secrets")]
    public IActionResult GetKeyVaultSecrets()
    {
        if (!_env.IsDevelopment())
            return NotFound();

        var result = SecretKeys.Select(key =>
        {
            var value = _config[key];
            var isSensitive = SensitiveKeys.Contains(key);

            return new
            {
                Key = key,
                Value = value is null
                    ? "(not set)"
                    : isSensitive
                        ? MaskValue(value)
                        : value,
                IsSet = value is not null
            };
        });

        return Ok(result);
    }

    private static string MaskValue(string value)
    {
        if (value.Length <= 6)
            return new string('*', value.Length);

        return value[..3] + new string('*', value.Length - 6) + value[^3..];
    }
}

using Azure.Identity;
using ECommerceApi.Data;
using ECommerceApi.Services;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.EntityFrameworkCore;
using Microsoft.IdentityModel.Tokens;
using Microsoft.OpenApi;
using System.Text;

var builder = WebApplication.CreateBuilder(args);

// Azure Key Vault — loads all secrets into IConfiguration at startup
var keyVaultUri = builder.Configuration["KeyVaultUri"];
if (!string.IsNullOrWhiteSpace(keyVaultUri))
{
    builder.Configuration.AddAzureKeyVault(
        new Uri(keyVaultUri),
        new DefaultAzureCredential());
}

// Database (connection string comes from Key Vault secret: SqlServer--ConnectionString)
builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseSqlServer(
        builder.Configuration["SqlServer:ConnectionString"]
            ?? throw new InvalidOperationException("SqlServer:ConnectionString is not configured.")));

// JWT Authentication (signing secret comes from Key Vault secret: Jwt--SigningSecret)
var jwtSecret = builder.Configuration["Jwt:SigningSecret"]
    ?? throw new InvalidOperationException("Jwt:SigningSecret is not configured.");

builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true,
            ValidIssuer = builder.Configuration["Jwt:Issuer"],
            ValidAudience = builder.Configuration["Jwt:Audience"],
            IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(jwtSecret))
        };
    });

builder.Services.AddAuthorization();
builder.Services.AddScoped<ITokenService, TokenService>();
builder.Services.AddScoped<IEmailService, EmailService>();
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen(c =>
{
    c.SwaggerDoc("v1", new OpenApiInfo { Title = "ECommerce API", Version = "v1" });
    c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
    {
        Name = "Authorization",
        Type = SecuritySchemeType.ApiKey,
        In = ParameterLocation.Header,
        Description = "Enter: Bearer {your token}"
    });
    c.AddSecurityRequirement(_ => new OpenApiSecurityRequirement
    {
        { new OpenApiSecuritySchemeReference("Bearer"), new List<string>() }
    });
});

var app = builder.Build();

if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI(c => c.SwaggerEndpoint("/swagger/v1/swagger.json", "ECommerce API v1"));
}

app.UseHttpsRedirection();
app.UseAuthentication();
app.UseAuthorization();
app.MapControllers();

// Seed a default admin user on first run
// Credentials: admin@ecommerce.com / Admin1234!
using (var scope = app.Services.CreateScope())
{
    var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
    db.Database.EnsureCreated();

    if (!db.Users.Any(u => u.Email == "admin@ecommerce.com"))
    {
        db.Users.Add(new ECommerceApi.Models.User
        {
            Name = "Admin",
            Email = "admin@ecommerce.com",
            PasswordHash = BCrypt.Net.BCrypt.HashPassword("Admin1234!"),
            Role = "Admin",
            CreatedAt = DateTime.UtcNow
        });
        db.SaveChanges();
    }
}

app.Run();

using System.Threading.Tasks;

namespace EventBus
{
    public interface IEventBus
    {
        Task PublishAsync<T>(T @event) where T : class;
        Task SubscribeAsync<T>(Func<T, Task> handler) where T : class;
    }
}

using System;

namespace EventBus.Events
{
    public abstract class BaseEvent
    {
        public Guid Id { get; protected set; }
        public DateTime CreatedAt { get; protected set; }

        protected BaseEvent()
        {
            Id = Guid.NewGuid();
            CreatedAt = DateTime.UtcNow;
        }
    }
}

namespace EventBus.Events
{
    public class ProductCreatedEvent : BaseEvent
    {
        public int ProductId { get; set; }
        public string Name { get; set; }
        public decimal Price { get; set; }
        public int Stock { get; set; }
    }
}

namespace EventBus.Events
{
    public class OrderCreatedEvent : BaseEvent
    {
        public int OrderId { get; set; }
        public int ProductId { get; set; }
        public int Quantity { get; set; }
        public decimal TotalPrice { get; set; }
        public string CustomerEmail { get; set; }
    }
}

namespace EventBus.Events
{
    public class ProductUpdatedEvent : BaseEvent
    {
        public int ProductId { get; set; }
        public string Name { get; set; }
        public string Description { get; set; }
        public decimal Price { get; set; }
        public int Stock { get; set; }
        public decimal PreviousPrice { get; set; }
        public int PreviousStock { get; set; }
    }
}

using Confluent.Kafka;
using System.Text.Json;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Configuration;

namespace EventBus
{
    public class KafkaEventBus : IEventBus, IDisposable
    {
        private readonly IProducer<string, string> _producer;
        private readonly IConsumer<string, string> _consumer;
        private readonly ILogger<KafkaEventBus> _logger;
        private readonly string _topicPrefix;
        private readonly Dictionary<string, Func<string, Task>> _handlers = new();
        private readonly List<string> _subscribedTopics = new();
        private bool _isConsuming = false;

        public KafkaEventBus(IConfiguration configuration, ILogger<KafkaEventBus> logger)
        {
            _logger = logger;
            _topicPrefix = configuration["Kafka:TopicPrefix"] ?? "microservices";

            var producerConfig = new ProducerConfig
            {
                BootstrapServers = configuration["Kafka:BootstrapServers"]
            };

            var consumerConfig = new ConsumerConfig
            {
                BootstrapServers = configuration["Kafka:BootstrapServers"],
                GroupId = configuration["Kafka:GroupId"],
                AutoOffsetReset = AutoOffsetReset.Earliest
            };

            _producer = new ProducerBuilder<string, string>(producerConfig).Build();
            _consumer = new ConsumerBuilder<string, string>(consumerConfig).Build();
        }

        public async Task PublishAsync<T>(T @event) where T : class
        {
            var topic = $"{_topicPrefix}.{typeof(T).Name}";
            var message = JsonSerializer.Serialize(@event);

            try
            {
                var result = await _producer.ProduceAsync(topic, new Message<string, string>
                {
                    Key = Guid.NewGuid().ToString(),
                    Value = message
                });

                _logger.LogInformation($"Event published to topic {topic}: {result.Status}");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"Failed to publish event to topic {topic}");
                throw;
            }
        }

        public async Task SubscribeAsync<T>(Func<T, Task> handler) where T : class
        {
            var topic = $"{_topicPrefix}.{typeof(T).Name}";
            _logger.LogInformation($"Subscribing to topic: {topic}");
            
            try
            {
                // Store the handler for this topic
                _handlers[topic] = async (message) =>
                {
                    var @event = JsonSerializer.Deserialize<T>(message);
                    await handler(@event);
                };

                _subscribedTopics.Add(topic);
                _logger.LogInformation($"Added topic {topic} to subscription list");

                // Start the consumer if not already started
                if (!_isConsuming)
                {
                    await StartConsumerAsync();
                }
                else
                {
                    // Re-subscribe to all topics
                    _consumer.Subscribe(_subscribedTopics);
                    _logger.LogInformation($"Re-subscribed to all topics: {string.Join(", ", _subscribedTopics)}");
                }

                _logger.LogInformation($"Successfully subscribed to topic: {topic}");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"Failed to subscribe to topic: {topic}");
                throw;
            }
        }

        private async Task StartConsumerAsync()
        {
            _isConsuming = true;
            _consumer.Subscribe(_subscribedTopics);
            _logger.LogInformation($"Subscribed to topics: {string.Join(", ", _subscribedTopics)}");

            _ = Task.Run(async () =>
            {
                _logger.LogInformation($"Starting consumer task for topics: {string.Join(", ", _subscribedTopics)}");
                while (true)
                {
                    try
                    {
                        _logger.LogDebug($"Polling for messages on topics: {string.Join(", ", _subscribedTopics)}...");
                        var consumeResult = _consumer.Consume(TimeSpan.FromMilliseconds(1000));
                        if (consumeResult != null)
                        {
                            var topic = consumeResult.Topic;
                            _logger.LogInformation($"Received message from topic {topic}: {consumeResult.Message.Value}");
                            
                            if (_handlers.TryGetValue(topic, out var handler))
                            {
                                await handler(consumeResult.Message.Value);
                                _consumer.Commit(consumeResult);
                                _logger.LogInformation($"Successfully processed message from topic {topic}");
                            }
                            else
                            {
                                _logger.LogWarning($"No handler found for topic {topic}");
                            }
                        }
                        else
                        {
                            _logger.LogDebug($"No message received from any topic, continuing polling...");
                        }
                    }
                    catch (Exception ex)
                    {
                        _logger.LogError(ex, $"Error consuming message from topics");
                    }
                }
            });
        }

        public void Dispose()
        {
            _producer?.Dispose();
            _consumer?.Dispose();
        }
    }
}

using System.ComponentModel.DataAnnotations;

namespace ProductService.Models
{
    public class Product
    {
        public int Id { get; set; }
        
        [Required]
        [StringLength(100)]
        public string Name { get; set; } = string.Empty;
        
        [StringLength(500)]
        public string Description { get; set; } = string.Empty;
        
        [Required]
        [Range(0.01, double.MaxValue)]
        public decimal Price { get; set; }
        
        [Required]
        [Range(0, int.MaxValue)]
        public int Stock { get; set; }
        
        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
    }
}

using Microsoft.EntityFrameworkCore;
using ProductService.Models;

namespace ProductService.Data
{
    public class ProductContext : DbContext
    {
        public ProductContext(DbContextOptions<ProductContext> options) : base(options) { }

        public DbSet<Product> Products { get; set; }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Product>(entity =>
            {
                entity.HasKey(e => e.Id);
                entity.Property(e => e.Name).IsRequired().HasMaxLength(100);
                entity.Property(e => e.Description).HasMaxLength(500);
                entity.Property(e => e.Price).HasColumnType("decimal(18,2)");
                entity.HasIndex(e => e.Name);
            });
        }
    }
}

using EventBus.Events;
using ProductService.Data;
using Microsoft.EntityFrameworkCore;
using EventBus;

namespace ProductService.Services
{
    public class OrderEventHandler
    {
        private readonly ILogger<OrderEventHandler> _logger;
        private readonly IServiceScopeFactory _scopeFactory;

        public OrderEventHandler(ILogger<OrderEventHandler> logger, IServiceScopeFactory scopeFactory)
        {
            _logger = logger;
            _scopeFactory = scopeFactory;
        }

        public async Task Handle(OrderCreatedEvent @event)
        {
            _logger.LogInformation($"Order created event received: Order {@event.OrderId}, Product {@event.ProductId}, Quantity {@event.Quantity}");
            
            using var scope = _scopeFactory.CreateScope();
            var context = scope.ServiceProvider.GetRequiredService<ProductContext>();
            var eventBus = scope.ServiceProvider.GetRequiredService<IEventBus>();
            
            try
            {
                // Find the product
                var product = await context.Products.FindAsync(@event.ProductId);
                if (product != null)
                {
                    // Update product stock (reduce by order quantity)
                    if (product.Stock >= @event.Quantity)
                    {
                        var originalStock = product.Stock;
                        product.Stock -= @event.Quantity;
                        await context.SaveChangesAsync();
                        
                        _logger.LogInformation($"Product {product.Id} stock updated. Stock: {originalStock} → {product.Stock}");
                        
                        // Publish ProductUpdatedEvent to notify other services about stock change
                        var productUpdatedEvent = new ProductUpdatedEvent
                        {
                            ProductId = product.Id,
                            Name = product.Name,
                            Description = product.Description,
                            Price = product.Price,
                            Stock = product.Stock,
                            PreviousStock = originalStock,
                            PreviousPrice = product.Price  // Price didn't change
                        };

                        await eventBus.PublishAsync(productUpdatedEvent);
                        _logger.LogInformation($"ProductUpdatedEvent published for Product {product.Id} due to order {@event.OrderId}");
                        
                        // Check if stock is low
                        if (product.Stock <= 10)
                        {
                            _logger.LogWarning($"LOW STOCK ALERT: Product {product.Name} (ID: {product.Id}) has only {product.Stock} units remaining!");
                        }
                    }
                    else
                    {
                        _logger.LogWarning($"Insufficient stock for Product {product.Id}. Available: {product.Stock}, Requested: {@event.Quantity}");
                    }
                }
                else
                {
                    _logger.LogWarning($"Product with ID {@event.ProductId} not found when processing order {@event.OrderId}");
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"Error processing order created event for Order {@event.OrderId}");
            }
        }
    }
}

using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using ProductService.Data;
using ProductService.Models;
using EventBus;
using EventBus.Events;

namespace ProductService.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class ProductsController : ControllerBase
    {
        private readonly ProductContext _context;
        private readonly IEventBus _eventBus;
        private readonly ILogger<ProductsController> _logger;

        public ProductsController(ProductContext context, IEventBus eventBus, ILogger<ProductsController> logger)
        {
            _context = context;
            _eventBus = eventBus;
            _logger = logger;
        }

        [HttpGet]
        public async Task<ActionResult<IEnumerable<Product>>> GetProducts()
        {
            return await _context.Products.ToListAsync();
        }

        [HttpGet("{id}")]
        public async Task<ActionResult<Product>> GetProduct(int id)
        {
            var product = await _context.Products.FindAsync(id);
            if (product == null)
                return NotFound();

            return product;
        }

        [HttpPost]
        public async Task<ActionResult<Product>> CreateProduct(Product product)
        {
            _context.Products.Add(product);
            await _context.SaveChangesAsync();

            // Publish event
            var productCreatedEvent = new ProductCreatedEvent
            {
                ProductId = product.Id,
                Name = product.Name,
                Price = product.Price,
                Stock = product.Stock
            };

            await _eventBus.PublishAsync(productCreatedEvent);
            _logger.LogInformation($"Product created and event published: {product.Name}");

            return CreatedAtAction(nameof(GetProduct), new { id = product.Id }, product);
        }

        [HttpPut("{id}")]
        public async Task<IActionResult> UpdateProduct(int id, Product product)
        {
            if (id != product.Id)
                return BadRequest();

            // Get the original product to track changes
            var originalProduct = await _context.Products.AsNoTracking().FirstOrDefaultAsync(p => p.Id == id);
            if (originalProduct == null)
                return NotFound();

            _context.Entry(product).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
                
                // Publish product updated event
                var productUpdatedEvent = new ProductUpdatedEvent
                {
                    ProductId = product.Id,
                    Name = product.Name,
                    Description = product.Description,
                    Price = product.Price,
                    Stock = product.Stock,
                    PreviousPrice = originalProduct.Price,
                    PreviousStock = originalProduct.Stock
                };

                await _eventBus.PublishAsync(productUpdatedEvent);
                _logger.LogInformation($"Product updated and event published: {product.Name}. Price: ${originalProduct.Price} → ${product.Price}, Stock: {originalProduct.Stock} → {product.Stock}");
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!ProductExists(id))
                    return NotFound();
                throw;
            }

            return NoContent();
        }

        [HttpDelete("{id}")]
        public async Task<IActionResult> DeleteProduct(int id)
        {
            var product = await _context.Products.FindAsync(id);
            if (product == null)
                return NotFound();

            _context.Products.Remove(product);
            await _context.SaveChangesAsync();

            return NoContent();
        }

        [HttpGet("low-stock")]
        public async Task<ActionResult<IEnumerable<object>>> GetLowStockProducts([FromQuery] int threshold = 10)
        {
            var lowStockProducts = await _context.Products
                .Where(p => p.Stock <= threshold)
                .Select(p => new 
                {
                    p.Id,
                    p.Name,
                    p.Stock,
                    p.Price,
                    Status = p.Stock == 0 ? "Out of Stock" : "Low Stock"
                })
                .ToListAsync();

            return Ok(lowStockProducts);
        }

        [HttpPut("{id}/stock")]
        public async Task<IActionResult> UpdateStock(int id, [FromBody] UpdateStockRequest request)
        {
            var product = await _context.Products.FindAsync(id);
            if (product == null)
                return NotFound();

            var originalStock = product.Stock;
            product.Stock = request.NewStock;
            await _context.SaveChangesAsync();

            // Publish ProductUpdatedEvent for stock changes
            var productUpdatedEvent = new ProductUpdatedEvent
            {
                ProductId = product.Id,
                Name = product.Name,
                Description = product.Description,
                Price = product.Price,
                Stock = product.Stock,
                PreviousStock = originalStock,
                PreviousPrice = product.Price  // Price didn't change, so previous = current
            };

            await _eventBus.PublishAsync(productUpdatedEvent);
            _logger.LogInformation($"Stock updated for product {product.Name}: {originalStock} → {request.NewStock} and event published");
            
            return NoContent();
        }

        private bool ProductExists(int id)
        {
            return _context.Products.Any(e => e.Id == id);
        }
    }

    public record UpdateStockRequest(int NewStock);
}

using Microsoft.EntityFrameworkCore;
using ProductService.Data;
using ProductService.Services;
using EventBus;
using EventBus.Events;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen(c =>
{
    c.SwaggerDoc("v1", new Microsoft.OpenApi.Models.OpenApiInfo
    {
        Title = "Product Service API",
        Version = "v1",
        Description = "API for managing products in the microservices demo",
        Contact = new Microsoft.OpenApi.Models.OpenApiContact
        {
            Name = "Product Service Team",
            Email = "products@microservicesdemo.com"
        }
    });
});

// Add Entity Framework
builder.Services.AddDbContext<ProductContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

// Add EventBus
builder.Services.AddSingleton<IEventBus, KafkaEventBus>();

// Add Event Handlers
builder.Services.AddScoped<OrderEventHandler>();

var app = builder.Build();

// Configure the HTTP request pipeline
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI(c =>
    {
        c.SwaggerEndpoint("/swagger/v1/swagger.json", "Product Service API v1");
        c.RoutePrefix = "swagger";
        c.DocumentTitle = "Product Service API Documentation";
    });
}

app.UseAuthorization();
app.MapControllers();

// Ensure database is created with retry logic
using (var scope = app.Services.CreateScope())
{
    var context = scope.ServiceProvider.GetRequiredService<ProductContext>();
    var logger = scope.ServiceProvider.GetRequiredService<ILogger<Program>>();
    
    var retryCount = 0;
    var maxRetries = 30;
    
    while (retryCount < maxRetries)
    {
        try
        {
            logger.LogInformation("Attempting to connect to database, attempt {Attempt}", retryCount + 1);
            context.Database.EnsureCreated();
            logger.LogInformation("Database connection successful!");
            break;
        }
        catch (Exception ex)
        {
            retryCount++;
            logger.LogWarning("Database connection failed (attempt {Attempt}/{MaxAttempts}): {Error}", retryCount, maxRetries, ex.Message);
            
            if (retryCount >= maxRetries)
            {
                logger.LogError("Failed to connect to database after {MaxAttempts} attempts. Exiting.", maxRetries);
                throw;
            }
            
            await Task.Delay(2000);
        }
    }
}

// Subscribe to events
using (var scope = app.Services.CreateScope())
{
    var eventBus = scope.ServiceProvider.GetRequiredService<IEventBus>();
    var orderEventHandler = scope.ServiceProvider.GetRequiredService<OrderEventHandler>();
    var logger = scope.ServiceProvider.GetRequiredService<ILogger<Program>>();
    
    logger.LogInformation("Subscribing to OrderCreatedEvent...");
    await eventBus.SubscribeAsync<OrderCreatedEvent>(orderEventHandler.Handle);
    logger.LogInformation("Successfully subscribed to OrderCreatedEvent");
}

app.Run();

using System.ComponentModel.DataAnnotations;

namespace OrderService.Models
{
    public class Order
    {
        public int Id { get; set; }
        
        [Required]
        public int ProductId { get; set; }
        
        [Required]
        [StringLength(100)]
        public string ProductName { get; set; } = string.Empty;
        
        [Required]
        [Range(1, int.MaxValue)]
        public int Quantity { get; set; }
        
        [Required]
        [Range(0.01, double.MaxValue)]
        public decimal UnitPrice { get; set; }
        
        [Required]
        [Range(0.01, double.MaxValue)]
        public decimal TotalPrice { get; set; }
        
        [Required]
        [EmailAddress]
        [StringLength(100)]
        public string CustomerEmail { get; set; } = string.Empty;
        
        public OrderStatus Status { get; set; } = OrderStatus.Pending;
        
        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
    }

    public enum OrderStatus
    {
        Pending,
        Confirmed,
        Cancelled,
        Shipped,
        Delivered
    }
}