using Microsoft.Extensions.Hosting;

var builder = DistributedApplication.CreateBuilder(args);

// Redis
var redis = builder.AddRedis("redis",
    password: builder.AddParameter("redis-password", "123456", secret: true))
    .WithContainerName("redis-aspire")
    .WithImageTag("8.0.2")
    .WithDataVolume("redis-dev")
    .WithEndpoint(6379, 6379, name: "redis-tcp", isProxied: false);

if (builder.Environment.IsDevelopment())
{
#pragma warning disable ASPIRECERTIFICATES001
    redis.WithoutHttpsCertificate();
#pragma warning restore ASPIRECERTIFICATES001
}

// Elasticsearch
var elasticsearch = builder.AddElasticsearch("elasticsearch", 
    password: builder.AddParameter("elasticsearch-password", "123456", secret: true))
    .WithContainerName("elasticsearch-aspire")
    .WithImageTag("8.17.3")
    .WithDataVolume("elasticsearch-dev")
    .WithEnvironment("ES_JAVA_OPTS", "-Xms2g -Xmx2g")
    // see: https://www.funkysi1701.com/posts/2025/adding-elasticsearch-with-aspire/
    .WithEnvironment("xpack.security.enabled", "false")
    .WithEndpoint(9200, 9200, name: "elasticsearch-http", isProxied: false);

// Kibana
builder.AddContainer("kibana", "kibana", "8.17.3")
    .WithContainerName("kibana-aspire")
    .WithReference(elasticsearch)
    .WithEndpoint(5601, 5601, name: "kibana-http", isProxied: false)
    .WaitFor(elasticsearch);

// Postgres
var postgres = builder.AddPostgres("postgres",
    userName: builder.AddParameter("postgres-username", "postgres", secret: true),
    password: builder.AddParameter("postgres-pwd", "123456", secret: true))
    .WithImage("postgres", "17-alpine")
    .WithContainerName("postgres-aspire")
    .WithDataVolume("postgres-dev")
    .WithEndpoint(5432, 5432, name: "postgres-tcp", isProxied: false);

var abpDb = postgres.AddDatabase("abp");

// RabbitMQ
var rabbitmq = builder.AddRabbitMQ("rabbitmq",
    userName: builder.AddParameter("rabbitmq-username", "admin", secret: true),
    password: builder.AddParameter("rabbitmq-password", "123456", secret: true))
    .WithContainerName("rabbitmq-aspire")
    .WithImageTag("3.13.1")
    .WithDataVolume("rabbitmq-dev")
    .WithManagementPlugin()
    .WithEndpoint(5672, 5672, name: "rabbitmq-amqp", isProxied: false)
    .WithEndpoint(15672, 15672, name: "rabbitmq-management", isProxied: false);

IResourceBuilder<ProjectResource> AddDotNetProject<TDbMigrator, TProject>(
    IDistributedApplicationBuilder builder, 
    string servicePrefix,
    int port,
    string portName,
    string serviceSuffix = "Service",
    string migratorSuffix = "Migrator",
    params IResourceBuilder<ProjectResource>[]? waitProjects) 
    where TDbMigrator : IProjectMetadata, new()
    where TProject : IProjectMetadata, new()
{
    IResourceBuilder<ProjectResource> service;
    if (builder.Environment.IsDevelopment())
    {
        var dbMigrator = builder
            .AddProject<TDbMigrator>($"{servicePrefix}{migratorSuffix}")
            .WithReference(abpDb, "Default")
            .WithReference(redis, "Redis")
            .WithReference(elasticsearch, "Elasticsearch")
            .WaitFor(elasticsearch)
            .WaitFor(redis)
            .WaitFor(abpDb)
            .WithReplicas(1);

        service = builder.AddProject<TProject>($"{servicePrefix}{serviceSuffix}")
            .WithHttpEndpoint(port: port, name: portName)
            .WithExternalHttpEndpoints()
            .WithReference(abpDb, "Default")
            .WithReference(redis, "Redis")
            .WithReference(rabbitmq, "Rabbitmq")
            .WithReference(elasticsearch, "Elasticsearch")
            .WaitFor(elasticsearch)
            .WaitFor(redis)
            .WaitFor(rabbitmq)
            .WaitFor(abpDb)
            .WaitForCompletion(dbMigrator);
    }
    else
    {
        service = builder.AddProject<TProject>($"{servicePrefix}{serviceSuffix}")
            .WithHttpEndpoint(port: port, name: portName)
            .WithExternalHttpEndpoints()
            .WithReference(abpDb, "Default")
            .WithReference(redis, "Redis")
            .WithReference(rabbitmq, "Rabbitmq")
            .WithReference(elasticsearch, "Elasticsearch")
            .WaitFor(elasticsearch)
            .WaitFor(redis)
            .WaitFor(rabbitmq)
            .WaitFor(abpDb);
    }

    if (waitProjects != null)
    {
        foreach (var waitProject in waitProjects)
        {
            service = service.WaitFor(waitProject);
        }
    }

    return service;
}

// LocalizationService
var localizationService = AddDotNetProject<
    Projects.LINGYUN_Abp_MicroService_LocalizationService_DbMigrator,
    Projects.LINGYUN_Abp_MicroService_LocalizationService>(
    builder:            builder, 
    servicePrefix:      "Localization",
    serviceSuffix:      "Service",
    migratorSuffix:     "Migrator",
    port:               30030,
    portName:           "localization")
    .WithHttpHealthCheck("/health/service");

// AuthServer
var authServer = AddDotNetProject<
    Projects.LINGYUN_Abp_MicroService_AuthServer_DbMigrator,
    Projects.LINGYUN_Abp_MicroService_AuthServer>(
    builder:            builder,
    servicePrefix:      "Auth",
    serviceSuffix:      "Server",
    migratorSuffix:     "Migrator",
    port:               44385,
    portName:           "auth", 
    waitProjects:        localizationService);

// AdminService
var adminService = AddDotNetProject<
    Projects.LINGYUN_Abp_MicroService_AdminService_DbMigrator,
    Projects.LINGYUN_Abp_MicroService_AdminService>(
    builder:            builder,
    servicePrefix:      "Admin",
    serviceSuffix:      "Service",
    migratorSuffix:     "Migrator",
    port:               30010,
    portName:           "admin",
    waitProjects:        authServer);

// IdentityService
AddDotNetProject<
    Projects.LINGYUN_Abp_MicroService_AuthServer_DbMigrator,
    Projects.LINGYUN_Abp_MicroService_IdentityService>(
    builder:            builder,
    servicePrefix:      "Identity",
    serviceSuffix:      "Service",
    migratorSuffix:     "Migrator",
    port:               30015,
    portName:           "identity",
    waitProjects:        authServer);

// TaskService
var taskService = AddDotNetProject<
    Projects.LINGYUN_Abp_MicroService_TaskService_DbMigrator,
    Projects.LINGYUN_Abp_MicroService_TaskService>(
    builder:            builder, 
    servicePrefix:      "Task", 
    serviceSuffix:      "Service",
    migratorSuffix:     "Migrator",
    port:               30040, 
    portName:           "task", 
    waitProjects:        adminService)
    .WithHttpHealthCheck("/health/service");

// MessageService
AddDotNetProject<
    Projects.LINGYUN_Abp_MicroService_MessageService_DbMigrator,
    Projects.LINGYUN_Abp_MicroService_MessageService>(
    builder:            builder, 
    servicePrefix:      "Message",
    serviceSuffix:      "Service",
    migratorSuffix:     "Migrator", 
    port:               30020, 
    portName:           "message", 
    waitProjects:        taskService);

// WebhookService
AddDotNetProject<
    Projects.LINGYUN_Abp_MicroService_WebhookService_DbMigrator,
    Projects.LINGYUN_Abp_MicroService_WebhookService>(
    builder:            builder, 
    servicePrefix:      "Webhook",
    serviceSuffix:      "Service",
    migratorSuffix:     "Migrator",
    port:               30045,
    portName:           "webhook", 
    waitProjects:        taskService);

// PlatformService
AddDotNetProject<
    Projects.LINGYUN_Abp_MicroService_PlatformService_DbMigrator,
    Projects.LINGYUN_Abp_MicroService_PlatformService>(
    builder:            builder, 
    servicePrefix:      "Platform", 
    serviceSuffix:      "Service",
    migratorSuffix:     "Migrator",
    port:               30025, 
    portName:           "platform",
    waitProjects:        adminService);

// WeChatService
builder.AddProject<Projects.LINGYUN_Abp_MicroService_WeChatService>("WeChatService")
    .WithHttpEndpoint(port: 30060, name: "wechat")
    .WithExternalHttpEndpoints()
    .WithReference(abpDb, "Default")
    .WithReference(redis, "Redis")
    .WithReference(rabbitmq, "Rabbitmq")
    .WithReference(elasticsearch, "Elasticsearch")
    .WaitFor(elasticsearch)
    .WaitFor(redis)
    .WaitFor(abpDb)
    .WaitFor(rabbitmq)
    .WaitFor(localizationService);

// WorkflowService
builder.AddProject<Projects.LINGYUN_Abp_MicroService_WorkflowService>("WorkflowService")
    .WithHttpEndpoint(port: 30050, name: "workflow")
    .WithExternalHttpEndpoints()
    .WithReference(abpDb, "Default")
    .WithReference(redis, "Redis")
    .WithReference(rabbitmq, "Rabbitmq")
    .WithReference(elasticsearch, "Elasticsearch")
    .WaitFor(elasticsearch)
    .WaitFor(redis)
    .WaitFor(abpDb)
    .WaitFor(rabbitmq)
    .WaitFor(taskService);

// AIService
AddDotNetProject<
    Projects.LINGYUN_Abp_MicroService_AIService_DbMigrator,
    Projects.LINGYUN_Abp_MicroService_AIService>(
    builder: builder,
    servicePrefix: "AI",
    serviceSuffix: "Service",
    migratorSuffix: "Migrator",
    port: 30070,
    portName: "ai",
    waitProjects: localizationService);

// ApiGateway
var apigateway = builder.AddProject<Projects.LINGYUN_Abp_MicroService_ApiGateway>("ApiGateway")
    .WithHttpEndpoint(port: 30000, name: "gateway")
    .WithExternalHttpEndpoints()
    .WithReference(redis, "Redis")
    .WithReference(elasticsearch, "Elasticsearch")
    .WaitFor(elasticsearch)
    .WaitFor(redis);

// vben5
builder.AddViteApp("Frontend", "../../../apps/vben5", "dev:app")
    .WithHttpEndpoint(port: 5666, targetPort: 5666, name: "frontend", env: "VITE_PORT", isProxied: false)
    .WithExternalHttpEndpoints()
    .WithEnvironment("BROWSER", "none")
    .WithArgs("--port", "5666")
    .WithPnpm()
    .WithReference(apigateway)
    .WaitFor(apigateway);

builder.Build().Run();