Dependency Injection

var builder = WebApplication.CreateBuilder(args);

// ─── Environment Detection ─────────────────────────────
var moduleName = Environment.GetEnvironmentVariable("MODULE_NAME") ?? "";
var isMonolith = string.IsNullOrEmpty(moduleName);
var isGateway = moduleName.Equals("Gateway", StringComparison.OrdinalIgnoreCase);

// ─── Core Infrastructure (always registered) ───────────
builder.Services.AddInfrastructureServices(builder.Configuration);
builder.Services.AddCorsConfiguration(builder.Configuration);
builder.Services.AddRateLimitingConfiguration();
builder.Services.AddCoreInfrastructure(builder.Configuration);

// ─── Module Registration (conditional) ──────────────────
var mediatorAssemblies = new List<Type>();

if (isMonolith || moduleName == "Identity")
{
    mediatorAssemblies.Add(typeof(Identity.Application.DependencyInjection));
    builder.Services.AddIdentityModule(builder.Configuration);
}

// Future modules follow same pattern:
// if (isMonolith || moduleName == "Inventory")
// {
//     mediatorAssemblies.Add(typeof(Inventory.Application.DependencyInjection));
//     builder.Services.AddInventoryModule(builder.Configuration);
// }

// ─── Application Layer (needs all module assemblies) ────
builder.Services.AddCoreApplication(mediatorAssemblies.ToArray());

/// <summary>
/// Custom controller feature provider that filters controllers
/// based on the MODULE_NAME environment variable.
/// In monolith mode: all controllers are loaded.
/// In microservice mode: only controllers with matching [BelongsToModule] are loaded.
/// </summary>
public class ModuleControllerFeatureProvider : ControllerFeatureProvider
{
    private readonly string? _moduleName;

    protected override bool IsController(TypeInfo typeInfo)
    {
        if (!base.IsController(typeInfo))
            return false;

        if (string.IsNullOrEmpty(_moduleName))
            return true; // Monolith: load all

        var attr = typeInfo.GetCustomAttribute<BelongsToModuleAttribute>();
        return attr?.ModuleName == _moduleName;
    }
}

/// <summary>
/// Attribute to tag controllers with their owning module.
/// </summary>
[AttributeUsage(AttributeTargets.Class)]
public class BelongsToModuleAttribute : Attribute
{
    public string ModuleName { get; }
    public BelongsToModuleAttribute(string moduleName)
        => ModuleName = moduleName;
}

// Usage on controllers:
// [BelongsToModule("Identity")]
// public class AdminsController : ControllerBase { }

/// <summary>
/// Discovers service URLs from appsettings.json configuration.
/// Used in microservice mode to route requests between services.
/// </summary>
public class ConfigServiceDiscovery : IServiceDiscovery
{
    private readonly ServiceDiscoveryOptions _options;

    public Task<string> GetServiceUrlAsync(string serviceName)
    {
        if (_options.Services.TryGetValue(serviceName, out var url))
            return Task.FromResult(url);

        throw new InvalidOperationException(
            $"Service '{serviceName}' not registered in ServiceDiscovery config");
    }
}

/// <summary>
/// Configuration for service discovery.
/// </summary>
public class ServiceDiscoveryOptions
{
    public const string SectionName = "ServiceDiscovery";
    public Dictionary<string, string> Services { get; set; } = new();
}

{
  "ServiceDiscovery": {
    "Services": {
      "Identity": "https://identity-service:5001",
      "Inventory": "https://inventory-service:5002",
      "Gateway": "https://gateway:5000"
    }
  }
}

/// <summary>
/// Configures YARP (Yet Another Reverse Proxy) for the API Gateway.
/// Routes requests to appropriate microservices based on path prefix.
/// Only active when MODULE_NAME=Gateway.
/// </summary>
public static class GatewayConfiguration
{
    public static IServiceCollection AddGatewayConfiguration(
        this IServiceCollection services,
        IConfiguration configuration)
    {
        services.AddReverseProxy()
            .LoadFromConfig(configuration.GetSection("ReverseProxy"));

        return services;
    }

    public static WebApplication UseGatewayConfiguration(
        this WebApplication app)
    {
        app.MapReverseProxy();
        return app;
    }
}

{
  "ReverseProxy": {
    "Routes": {
      "identity-route": {
        "ClusterId": "identity-cluster",
        "Match": { "Path": "/api/v1/auth/{**catch-all}" }
      },
      "admin-route": {
        "ClusterId": "identity-cluster",
        "Match": { "Path": "/api/v1/admins/{**catch-all}" }
      }
    },
    "Clusters": {
      "identity-cluster": {
        "Destinations": {
          "destination1": {
            "Address": "https://identity-service:5001"
          }
        }
      }
    }
  }
}