using Cosmos.DynamicConfig;

// Register HTTP context accessor
builder.Services.AddHttpContextAccessor();

// Register memory cache
builder.Services.AddMemoryCache();

// Register dynamic configuration provider
builder.Services.AddScoped<IDynamicConfigurationProvider, DynamicConfigurationProvider>();

// Add domain middleware to capture request domain
app.UseMiddleware<DomainMiddleware>();

Note: The provider requires an active HTTP request context to infer the tenant domain. For background services or out-of-band operations, pass the domain explicitly to the API methods (see below).

using Cosmos.DynamicConfig;

public class TenantService
{
    private readonly IDynamicConfigurationProvider _configProvider;

    public TenantService(IDynamicConfigurationProvider configProvider)
    {
        _configProvider = configProvider;
    }

    public async Task<string> GetTenantData()
    {
        // Get current tenant's database connection
        var dbConnection = _configProvider.GetDatabaseConnectionString();
        
        // Get current tenant's storage connection
        var storageConnection = _configProvider.GetStorageConnectionString();
        
        // Get custom configuration value
        var customSetting = _configProvider.GetConfigurationValue("CustomSetting");
        
        return $"DB: {dbConnection}, Storage: {storageConnection}";
    }
}

var dbForFoo = _configProvider.GetDatabaseConnectionString("www.foo.com");
var storageForFoo = _configProvider.GetStorageConnectionString("www.foo.com");

public class TenantBackgroundService : BackgroundService
{
    private readonly IDynamicConfigurationProvider _configProvider;
    private readonly ILogger<TenantBackgroundService> _logger;
    
    public TenantBackgroundService(
        IDynamicConfigurationProvider configProvider,
        ILogger<TenantBackgroundService> logger)
    {
        _configProvider = configProvider;
        _logger = logger;
    }
    
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        var tenantDomains = new[] { "tenant1.example.com", "tenant2.example.com" };
        
        foreach (var domain in tenantDomains)
        {
            // Pass domain explicitly - no HTTP context needed
            var dbConnection = _configProvider.GetDatabaseConnectionString(domain);
            var storageConnection = _configProvider.GetStorageConnectionString(domain);
            
            _logger.LogInformation("Processing tenant: {Domain}", domain);
            
            // Process tenant data...
            await ProcessTenantDataAsync(domain, dbConnection, storageConnection);
        }
    }
}

class Program
{
    static async Task Main(string[] args)
    {
        var services = new ServiceCollection();
        
        // Configure services without HTTP context
        services.AddDbContext<DynamicConfigDbContext>(options =>
            options.UseCosmos(configConnectionString, "ConfigDb"));
        
        services.AddMemoryCache();
        services.AddSingleton<IDynamicConfigurationProvider, DynamicConfigurationProvider>();
        
        var provider = services.BuildServiceProvider();
        var configProvider = provider.GetRequiredService<IDynamicConfigurationProvider>();
        
        // Explicitly specify domain
        var domain = "client.example.com";
        var dbConn = configProvider.GetDatabaseConnectionString(domain);
        
        Console.WriteLine($"Database connection for {domain}: {dbConn}");
    }
}

[TestMethod]
public void GetDatabaseConnectionString_WithExplicitDomain_ReturnsCorrectConnection()
{
    // Arrange
    var mockCache = new MemoryCache(new MemoryCacheOptions());
    var configProvider = new DynamicConfigurationProvider(
        configuration: mockConfig,
        httpContextAccessor: null,  // No HTTP context
        memoryCache: mockCache,
        logger: mockLogger);
    
    // Act - Pass domain explicitly
    var result = configProvider.GetDatabaseConnectionString("test.example.com");
    
    // Assert
    Assert.IsNotNull(result);
    Assert.IsTrue(result.Contains("Database=TestDb"));
}

// All methods accept optional domain parameter
string GetDatabaseConnectionString(string? domain = null);
string GetStorageConnectionString(string? domain = null);
string GetConfigurationValue(string key, string? domain = null);
Task<bool> ValidateDomainName(string domain);
Task<Connection?> GetConnectionByDomainAsync(string domain);

public class MetricsService
{
    private readonly DynamicConfigDbContext _dbContext;
    
    public async Task RecordTenantMetricsAsync(
        Guid connectionId,
        double blobStorageBytes,
        double blobTransactions,
        double databaseRUs)
    {
        var metric = new Metric
        {
            Id = Guid.NewGuid(),
            ConnectionId = connectionId,
            TimeStamp = DateTimeOffset.UtcNow,
            BlobStorageBytes = blobStorageBytes,
            BlobStorageTransactions = blobTransactions,
            DatabaseRequestUnits = databaseRUs
        };
        
        _dbContext.Metrics.Add(metric);
        await _dbContext.SaveChangesAsync();
    }
}

public async Task<double> GetMonthlyStorageUsageAsync(Guid connectionId)
{
    var startOfMonth = new DateTimeOffset(
        DateTime.UtcNow.Year,
        DateTime.UtcNow.Month,
        1, 0, 0, 0, TimeSpan.Zero);
    
    var totalBytes = await _dbContext.Metrics
        .Where(m => m.ConnectionId == connectionId && m.TimeStamp >= startOfMonth)
        .SumAsync(m => m.BlobStorageBytes ?? 0);
    
    return totalBytes;
}

public class MetricsCollectorService : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            // Collect metrics for all tenants every hour
            await CollectAllTenantMetricsAsync();
            await Task.Delay(TimeSpan.FromHours(1), stoppingToken);
        }
    }
    
    private async Task CollectAllTenantMetricsAsync()
    {
        var connections = await _dbContext.Connections.ToListAsync();
        
        foreach (var connection in connections)
        {
            // Query Azure/AWS APIs for actual usage
            var metrics = await FetchTenantResourceMetricsAsync(connection);
            await RecordTenantMetricsAsync(connection.Id, metrics);
        }
    }
}

public class ConfigurationController : ControllerBase
{
    private readonly IDynamicConfigurationProvider _configProvider;

    public ConfigurationController(IDynamicConfigurationProvider configProvider)
    {
        _configProvider = configProvider;
    }

    [HttpGet("tenant-info")]
    public async Task<IActionResult> GetTenantInfo()
    {
        // Check if multi-tenant is configured (any tenant connection present)
        if (!_configProvider.IsMultiTenantConfigured)
        {
            return BadRequest("Multi-tenant not configured");
        }

        // Get configuration for current domain
        var dbConnection = _configProvider.GetDatabaseConnectionString();
        var storageConnection = _configProvider.GetStorageConnectionString();

        return Ok(new
        {
            DatabaseConfigured = !string.IsNullOrEmpty(dbConnection),
            StorageConfigured = !string.IsNullOrEmpty(storageConnection)
        });
    }

    [HttpGet("validate-domain/{domain}")]
    public async Task<IActionResult> ValidateDomain(string domain)
    {
        var isValid = await _configProvider.ValidateDomainName(domain);
        return Ok(new { IsValid = isValid });
    }
}

public class TenantManagementService
{
    private readonly IDynamicConfigurationProvider _configProvider;

    public TenantManagementService(IDynamicConfigurationProvider configProvider)
    {
        _configProvider = configProvider;
    }

    public async Task<Connection> CreateTenant(TenantRequest request)
    {
        var connection = new Connection
        {
            DomainNames = request.Domains,
            DbConn = request.DatabaseConnectionString,
            StorageConn = request.StorageConnectionString,
            Customer = request.CustomerName,
            ResourceGroup = request.ResourceGroup,
            PublisherMode = request.PublisherMode,
            WebsiteUrl = request.WebsiteUrl,
            OwnerEmail = request.OwnerEmail
        };

        // Save to configuration database
        using var context = new DynamicConfigDbContext(options);
        context.Connections.Add(connection);
        await context.SaveChangesAsync();

        return connection;
    }
}

public class MetricsService
{
    private readonly DynamicConfigDbContext _context;

    public MetricsService(DynamicConfigDbContext context)
    {
        _context = context;
    }

    public async Task RecordUsageMetrics(Guid connectionId, UsageData usage)
    {
        var metric = new Metric
        {
            ConnectionId = connectionId,
            TimeStamp = DateTimeOffset.UtcNow,
            BlobStorageBytes = usage.StorageBytes,
            BlobStorageEgressBytes = usage.EgressBytes,
            BlobStorageIngressBytes = usage.IngressBytes,
            BlobStorageTransactions = usage.Transactions,
            DatabaseDataUsageBytes = usage.DatabaseBytes,
            DatabaseRuUsage = usage.RequestUnits,
            FrontDoorRequestBytes = usage.RequestBytes,
            FrontDoorResponseBytes = usage.ResponseBytes
        };

        _context.Metrics.Add(metric);
        await _context.SaveChangesAsync();
    }
}