using EntKube.Web.Data;
using EntKube.Web.Services;
using FluentAssertions;
using Microsoft.Data.Sqlite;
using Microsoft.EntityFrameworkCore;

namespace EntKube.Web.Tests;

/// <summary>
/// Tests for the DeploymentService which manages app deployments — creating
/// deployments (Manual, Yaml, Helm), managing manifests, and tracking status.
/// Uses SQLite in-memory for fast, isolated database tests.
/// </summary>
public class DeploymentServiceTests : IDisposable
{
    private readonly SqliteConnection connection;
    private readonly ApplicationDbContext db;
    private readonly TestDbContextFactory dbFactory;
    private readonly DeploymentService sut;

    public DeploymentServiceTests()
    {
        // Stand up a fresh in-memory SQLite database for each test.
        // This gives us real EF Core behavior without touching disk.

        connection = new SqliteConnection("DataSource=:memory:");
        connection.Open();

        DbContextOptions<ApplicationDbContext> options = new DbContextOptionsBuilder<ApplicationDbContext>()
            .UseSqlite(connection)
            .Options;

        db = new ApplicationDbContext(options);
        dbFactory = new TestDbContextFactory(connection);
        db.Database.EnsureCreated();

        sut = new DeploymentService(dbFactory);
    }

    public void Dispose()
    {
        db.Dispose();
        connection.Dispose();
    }

    // ── Helpers ──

    /// <summary>
    /// Sets up a tenant with an environment, cluster, customer, and app — the
    /// minimum scaffolding needed to create a deployment.
    /// </summary>
    private (App app, Data.Environment env, KubernetesCluster cluster) CreateTestApp()
    {
        Tenant tenant = new() { Id = Guid.NewGuid(), Name = "TestCo", Slug = "testco" };
        db.Tenants.Add(tenant);

        Data.Environment env = new() { Id = Guid.NewGuid(), TenantId = tenant.Id, Name = "production" };
        db.Environments.Add(env);

        KubernetesCluster cluster = new()
        {
            Id = Guid.NewGuid(),
            TenantId = tenant.Id,
            EnvironmentId = env.Id,
            Name = "prod-cluster",
            ApiServerUrl = "https://k8s.example.com"
        };
        db.KubernetesClusters.Add(cluster);

        Customer customer = new() { Id = Guid.NewGuid(), TenantId = tenant.Id, Name = "Contoso" };
        db.Customers.Add(customer);

        App app = new() { Id = Guid.NewGuid(), CustomerId = customer.Id, Name = "billing-api" };
        db.Apps.Add(app);

        db.SaveChanges();
        return (app, env, cluster);
    }

    // ════════════════════════════════════════════════════════════════
    //  CreateDeploymentAsync
    // ════════════════════════════════════════════════════════════════

    [Fact]
    public async Task CreateDeploymentAsync_ManualType_CreatesWithUnknownStatus()
    {
        // Arrange — we need an app, environment, and cluster to target.
        (App app, Data.Environment env, KubernetesCluster cluster) = CreateTestApp();

        // Act — create a manual deployment targeting the prod cluster.
        AppDeployment deployment = await sut.CreateDeploymentAsync(
            app.Id, "billing-deploy", DeploymentType.Manual,
            env.Id, cluster.Id, "billing-ns");

        // Assert — the deployment exists with the right defaults.
        deployment.Id.Should().NotBeEmpty();
        deployment.Name.Should().Be("billing-deploy");
        deployment.Type.Should().Be(DeploymentType.Manual);
        deployment.Namespace.Should().Be("billing-ns");
        deployment.SyncStatus.Should().Be(SyncStatus.Unknown);
        deployment.HealthStatus.Should().Be(HealthStatus.Unknown);
    }

    [Fact]
    public async Task CreateDeploymentAsync_HelmType_StoresChartInfo()
    {
        // Arrange
        (App app, Data.Environment env, KubernetesCluster cluster) = CreateTestApp();

        // Act — create a Helm deployment with chart details.
        AppDeployment deployment = await sut.CreateDeploymentAsync(
            app.Id, "minio-deploy", DeploymentType.HelmChart,
            env.Id, cluster.Id, "minio-ns",
            helmRepoUrl: "https://charts.min.io",
            helmChartName: "minio",
            helmChartVersion: "5.0.0");

        // Assert
        deployment.Type.Should().Be(DeploymentType.HelmChart);
        deployment.HelmRepoUrl.Should().Be("https://charts.min.io");
        deployment.HelmChartName.Should().Be("minio");
        deployment.HelmChartVersion.Should().Be("5.0.0");
    }

    [Fact]
    public async Task CreateDeploymentAsync_DuplicateName_Throws()
    {
        // Arrange — create a deployment, then try to create another with the same name.
        (App app, Data.Environment env, KubernetesCluster cluster) = CreateTestApp();

        await sut.CreateDeploymentAsync(
            app.Id, "billing-deploy", DeploymentType.Manual,
            env.Id, cluster.Id, "billing-ns");

        // Act & Assert
        Func<Task> act = () => sut.CreateDeploymentAsync(
            app.Id, "billing-deploy", DeploymentType.Manual,
            env.Id, cluster.Id, "other-ns");

        await act.Should().ThrowAsync<DbUpdateException>();
    }

    // ════════════════════════════════════════════════════════════════
    //  GetDeploymentsAsync
    // ════════════════════════════════════════════════════════════════

    [Fact]
    public async Task GetDeploymentsAsync_ReturnsDeploymentsForApp()
    {
        // Arrange
        (App app, Data.Environment env, KubernetesCluster cluster) = CreateTestApp();

        await sut.CreateDeploymentAsync(app.Id, "deploy-1", DeploymentType.Manual, env.Id, cluster.Id, "ns1");
        await sut.CreateDeploymentAsync(app.Id, "deploy-2", DeploymentType.HelmChart, env.Id, cluster.Id, "ns2");

        // Act
        List<AppDeployment> deployments = await sut.GetDeploymentsAsync(app.Id);

        // Assert — both deployments returned with related data loaded.
        deployments.Should().HaveCount(2);
        deployments.Should().Contain(d => d.Name == "deploy-1");
        deployments.Should().Contain(d => d.Name == "deploy-2");
    }

    [Fact]
    public async Task GetDeploymentsAsync_IncludesEnvironmentAndCluster()
    {
        // Arrange
        (App app, Data.Environment env, KubernetesCluster cluster) = CreateTestApp();

        await sut.CreateDeploymentAsync(app.Id, "deploy-1", DeploymentType.Manual, env.Id, cluster.Id, "ns1");

        // Act
        List<AppDeployment> deployments = await sut.GetDeploymentsAsync(app.Id);

        // Assert — navigation properties should be loaded.
        deployments[0].Environment.Name.Should().Be("production");
        deployments[0].Cluster.Name.Should().Be("prod-cluster");
    }

    // ════════════════════════════════════════════════════════════════
    //  DeleteDeploymentAsync
    // ════════════════════════════════════════════════════════════════

    [Fact]
    public async Task DeleteDeploymentAsync_RemovesDeployment()
    {
        // Arrange
        (App app, Data.Environment env, KubernetesCluster cluster) = CreateTestApp();

        AppDeployment deployment = await sut.CreateDeploymentAsync(
            app.Id, "to-delete", DeploymentType.Manual, env.Id, cluster.Id, "ns1");

        // Act
        await sut.DeleteDeploymentAsync(deployment.Id);

        // Assert
        List<AppDeployment> remaining = await sut.GetDeploymentsAsync(app.Id);
        remaining.Should().BeEmpty();
    }

    // ════════════════════════════════════════════════════════════════
    //  Manifest CRUD
    // ════════════════════════════════════════════════════════════════

    [Fact]
    public async Task AddManifestAsync_CreatesManifest()
    {
        // Arrange
        (App app, Data.Environment env, KubernetesCluster cluster) = CreateTestApp();

        AppDeployment deployment = await sut.CreateDeploymentAsync(
            app.Id, "yaml-deploy", DeploymentType.Yaml, env.Id, cluster.Id, "ns1");

        string yaml = "apiVersion: v1\nkind: Service\nmetadata:\n  name: billing-svc";

        // Act — add a manifest to the deployment.
        DeploymentManifest manifest = await sut.AddManifestAsync(
            deployment.Id, "Service", "billing-svc", yaml, sortOrder: 1);

        // Assert
        manifest.Id.Should().NotBeEmpty();
        manifest.Kind.Should().Be("Service");
        manifest.Name.Should().Be("billing-svc");
        manifest.YamlContent.Should().Be(yaml);
    }

    [Fact]
    public async Task GetManifestsAsync_ReturnsOrderedManifests()
    {
        // Arrange
        (App app, Data.Environment env, KubernetesCluster cluster) = CreateTestApp();

        AppDeployment deployment = await sut.CreateDeploymentAsync(
            app.Id, "ordered-deploy", DeploymentType.Yaml, env.Id, cluster.Id, "ns1");

        await sut.AddManifestAsync(deployment.Id, "Service", "svc", "svc-yaml", sortOrder: 2);
        await sut.AddManifestAsync(deployment.Id, "Deployment", "dep", "dep-yaml", sortOrder: 1);
        await sut.AddManifestAsync(deployment.Id, "PersistentVolumeClaim", "pvc", "pvc-yaml", sortOrder: 0);

        // Act
        List<DeploymentManifest> manifests = await sut.GetManifestsAsync(deployment.Id);

        // Assert — returned in SortOrder (PVC → Deployment → Service).
        manifests.Should().HaveCount(3);
        manifests[0].Kind.Should().Be("PersistentVolumeClaim");
        manifests[1].Kind.Should().Be("Deployment");
        manifests[2].Kind.Should().Be("Service");
    }

    [Fact]
    public async Task UpdateManifestAsync_UpdatesYamlContent()
    {
        // Arrange
        (App app, Data.Environment env, KubernetesCluster cluster) = CreateTestApp();

        AppDeployment deployment = await sut.CreateDeploymentAsync(
            app.Id, "update-test", DeploymentType.Yaml, env.Id, cluster.Id, "ns1");

        DeploymentManifest manifest = await sut.AddManifestAsync(
            deployment.Id, "Deployment", "billing", "old-yaml", sortOrder: 0);

        // Act
        await sut.UpdateManifestAsync(manifest.Id, "new-yaml-content");

        // Assert
        List<DeploymentManifest> manifests = await sut.GetManifestsAsync(deployment.Id);
        manifests[0].YamlContent.Should().Be("new-yaml-content");
    }

    [Fact]
    public async Task DeleteManifestAsync_RemovesManifest()
    {
        // Arrange
        (App app, Data.Environment env, KubernetesCluster cluster) = CreateTestApp();

        AppDeployment deployment = await sut.CreateDeploymentAsync(
            app.Id, "del-manifest", DeploymentType.Yaml, env.Id, cluster.Id, "ns1");

        DeploymentManifest manifest = await sut.AddManifestAsync(
            deployment.Id, "Service", "svc", "yaml", sortOrder: 0);

        // Act
        await sut.DeleteManifestAsync(manifest.Id);

        // Assert
        List<DeploymentManifest> remaining = await sut.GetManifestsAsync(deployment.Id);
        remaining.Should().BeEmpty();
    }

    // ════════════════════════════════════════════════════════════════
    //  Helm Values
    // ════════════════════════════════════════════════════════════════

    [Fact]
    public async Task UpdateHelmValuesAsync_StoresYaml()
    {
        // Arrange
        (App app, Data.Environment env, KubernetesCluster cluster) = CreateTestApp();

        AppDeployment deployment = await sut.CreateDeploymentAsync(
            app.Id, "helm-deploy", DeploymentType.HelmChart, env.Id, cluster.Id, "minio-ns",
            helmRepoUrl: "https://charts.min.io", helmChartName: "minio", helmChartVersion: "5.0.0");

        string values = "replicas: 3\npersistence:\n  size: 10Gi";

        // Act
        await sut.UpdateHelmValuesAsync(deployment.Id, values);

        // Assert — reload from DB to verify persistence.
        List<AppDeployment> deployments = await sut.GetDeploymentsAsync(app.Id);
        deployments[0].HelmValues.Should().Be(values);
    }

    // ════════════════════════════════════════════════════════════════
    //  Deployment Resources (ArgoCD-style tree)
    // ════════════════════════════════════════════════════════════════

    [Fact]
    public async Task UpsertResourceAsync_CreatesNewResource()
    {
        // Arrange
        (App app, Data.Environment env, KubernetesCluster cluster) = CreateTestApp();

        AppDeployment deployment = await sut.CreateDeploymentAsync(
            app.Id, "res-test", DeploymentType.Manual, env.Id, cluster.Id, "ns1");

        // Act — the cluster watcher reports a Deployment resource.
        DeploymentResource resource = await sut.UpsertResourceAsync(
            deployment.Id, "apps", "v1", "Deployment", "billing-api", "ns1",
            SyncStatus.Synced, HealthStatus.Healthy, "Running 3/3 replicas");

        // Assert
        resource.Id.Should().NotBeEmpty();
        resource.Kind.Should().Be("Deployment");
        resource.SyncStatus.Should().Be(SyncStatus.Synced);
        resource.HealthStatus.Should().Be(HealthStatus.Healthy);
    }

    [Fact]
    public async Task UpsertResourceAsync_UpdatesExistingResource()
    {
        // Arrange — create a resource, then update its health.
        (App app, Data.Environment env, KubernetesCluster cluster) = CreateTestApp();

        AppDeployment deployment = await sut.CreateDeploymentAsync(
            app.Id, "upsert-test", DeploymentType.Manual, env.Id, cluster.Id, "ns1");

        await sut.UpsertResourceAsync(
            deployment.Id, "apps", "v1", "Deployment", "billing-api", "ns1",
            SyncStatus.Synced, HealthStatus.Progressing, "Rolling update");

        // Act — same resource, updated status.
        await sut.UpsertResourceAsync(
            deployment.Id, "apps", "v1", "Deployment", "billing-api", "ns1",
            SyncStatus.Synced, HealthStatus.Healthy, "Running 3/3");

        // Assert — only one resource, with the updated health.
        List<DeploymentResource> resources = await sut.GetResourceTreeAsync(deployment.Id);
        resources.Should().HaveCount(1);
        resources[0].HealthStatus.Should().Be(HealthStatus.Healthy);
        resources[0].StatusMessage.Should().Be("Running 3/3");
    }

    [Fact]
    public async Task GetResourceTreeAsync_ReturnsOnlyRootResources()
    {
        // Arrange — build a two-level tree: Deployment → ReplicaSet.
        (App app, Data.Environment env, KubernetesCluster cluster) = CreateTestApp();

        AppDeployment deployment = await sut.CreateDeploymentAsync(
            app.Id, "tree-test", DeploymentType.Manual, env.Id, cluster.Id, "ns1");

        DeploymentResource parent = await sut.UpsertResourceAsync(
            deployment.Id, "apps", "v1", "Deployment", "billing-api", "ns1",
            SyncStatus.Synced, HealthStatus.Healthy, null);

        await sut.UpsertResourceAsync(
            deployment.Id, "apps", "v1", "ReplicaSet", "billing-api-abc123", "ns1",
            SyncStatus.Synced, HealthStatus.Healthy, null,
            parentResourceId: parent.Id);

        // Act — get the tree roots.
        List<DeploymentResource> roots = await sut.GetResourceTreeAsync(deployment.Id);

        // Assert — only the Deployment root, with the ReplicaSet as a child.
        roots.Should().HaveCount(1);
        roots[0].Kind.Should().Be("Deployment");
        roots[0].ChildResources.Should().HaveCount(1);
        roots[0].ChildResources.First().Kind.Should().Be("ReplicaSet");
    }

    // ════════════════════════════════════════════════════════════════
    //  UpdateDeploymentStatusAsync
    // ════════════════════════════════════════════════════════════════

    [Fact]
    public async Task UpdateDeploymentStatusAsync_UpdatesStatusFields()
    {
        // Arrange
        (App app, Data.Environment env, KubernetesCluster cluster) = CreateTestApp();

        AppDeployment deployment = await sut.CreateDeploymentAsync(
            app.Id, "status-test", DeploymentType.Manual, env.Id, cluster.Id, "ns1");

        // Act — simulate a sync completion.
        await sut.UpdateDeploymentStatusAsync(
            deployment.Id, SyncStatus.Synced, HealthStatus.Healthy, "All resources healthy");

        // Assert
        List<AppDeployment> deployments = await sut.GetDeploymentsAsync(app.Id);
        deployments[0].SyncStatus.Should().Be(SyncStatus.Synced);
        deployments[0].HealthStatus.Should().Be(HealthStatus.Healthy);
        deployments[0].StatusMessage.Should().Be("All resources healthy");
        deployments[0].LastSyncedAt.Should().NotBeNull();
    }
}