using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

public class Customer
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
    public DateTime CreatedAt { get; set; }
}

public class ShardDbContext : DbContext
{
    public ShardDbContext(DbContextOptions options) : base(options)
    {
    }

    public DbSet<Customer> Customers { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Customer>()
            .HasKey(c => c.Id);
    }
}

public class ShardingManager
{
    private readonly Dictionary<int, string> _shardMap = new Dictionary<int, string>
    {

        { 1, "Server=shard1.example.com;Database=Tenant1Db;User Id=user;Password=password;" },
        { 2, "Server=shard2.example.com;Database=Tenant2Db;User Id=user;Password=password;" },
        { 3, "Server=shard3.example.com;Database=Tenant3Db;User Id=user;Password=password;" }
    };

    public string GetConnectionString(int tenantId)
    {
        if (_shardMap.TryGetValue(tenantId, out string connectionString))
        {
            return connectionString;
        }
        
        throw new KeyNotFoundException($"No shard configured for tenant {tenantId}");
    }
}

public class ShardDbContextFactory
{
    private readonly ShardingManager _shardingManager;
    
    public ShardDbContextFactory(ShardingManager shardingManager)
    {
        _shardingManager = shardingManager;
    }
    
    public ShardDbContext CreateDbContext(int tenantId)
    {
        var connectionString = _shardingManager.GetConnectionString(tenantId);
        
        var optionsBuilder = new DbContextOptionsBuilder<ShardDbContext>();
        optionsBuilder.UseNpgsql(connectionString);
        
        return new ShardDbContext(optionsBuilder.Options);
    }
}

public class CustomerRepository
{
    private readonly ShardDbContextFactory _contextFactory;
    
    public CustomerRepository(ShardDbContextFactory contextFactory)
    {
        _contextFactory = contextFactory;
    }
    
    public async Task<Customer> GetCustomerAsync(int tenantId, int customerId)
    {
        using var dbContext = _contextFactory.CreateDbContext(tenantId);
        return await dbContext.Customers.FindAsync(customerId);
    }
    
    public async Task<List<Customer>> GetAllCustomersAsync(int tenantId)
    {
        using var dbContext = _contextFactory.CreateDbContext(tenantId);
        return await dbContext.Customers.ToListAsync();
    }
    
    public async Task AddCustomerAsync(int tenantId, Customer customer)
    {
        using var dbContext = _contextFactory.CreateDbContext(tenantId);
        dbContext.Customers.Add(customer);
        await dbContext.SaveChangesAsync();
    }
    
    public async Task<List<Customer>> GetCustomersFromAllShards()
    {
        var allCustomers = new List<Customer>();
  
        foreach (var tenantId in new[] { 1, 2, 3 }) // Hardcoded for simplicity
        {
            using var dbContext = _contextFactory.CreateDbContext(tenantId);
            var customers = await dbContext.Customers.ToListAsync();
            allCustomers.AddRange(customers);
        }
        
        return allCustomers;
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        var services = new ServiceCollection();        
        services.AddSingleton<ShardingManager>();
        services.AddSingleton<ShardDbContextFactory>();
        services.AddScoped<CustomerRepository>();
        
        var serviceProvider = services.BuildServiceProvider();
      
        var customerRepo = serviceProvider.GetRequiredService<CustomerRepository>();
      
        ExampleUsageAsync(customerRepo).Wait();
    }
    
    private static async Task ExampleUsageAsync(CustomerRepository repository)
    {
        int currentTenantId = 1;
        
        await repository.AddCustomerAsync(currentTenantId, new Customer
        {
            Name = "John Doe",
            Email = "john@example.com",
            CreatedAt = DateTime.UtcNow
        });
        
        var customers = await repository.GetAllCustomersAsync(currentTenantId);
        foreach (var customer in customers)
        {
            Console.WriteLine($"Customer: {customer.Name}, Email: {customer.Email}");
        }
        
        var allCustomers = await repository.GetCustomersFromAllShards();
        Console.WriteLine($"Total customers across all shards: {allCustomers.Count}");
    }
}