using System.Net;
using System.Net.Http.Json;
using System.Security.Claims;
using System.Text.Encodings.Web;
using System.Text.Json;
using JobTrackerApi.Controllers;
using JobTrackerApi.Data;
using JobTrackerApi.Models;
using JobTrackerApi.Services;
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Hosting.Server;
using Microsoft.AspNetCore.Hosting.Server.Features;
using Microsoft.AspNetCore.RateLimiting;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Options;
using System.Threading.RateLimiting;
using Xunit;

namespace JobTrackerApi.Tests;

public sealed class AdminProcessingControllerTests
{
    [Theory]
    [InlineData("jobId=9999")]
    [InlineData("createdFrom=2099-01-01T00:00:00Z")]
    [InlineData("createdBefore=2000-01-01T00:00:00Z")]
    [InlineData("worker=untracked")]
    [InlineData("q=SECRET_CV_CONTENT")]
    public async Task Diagnostic_filters_are_applied_before_pagination(string query)
    {
        await using var host = await Host.Start();
        using var client = host.Client("admin");
        var result = await client.GetFromJsonAsync<JsonElement>("/api/admin/processing?" + query);
        Assert.Equal(0, result.GetProperty("total").GetInt32());
        Assert.Empty(result.GetProperty("items").EnumerateArray());
    }

    [Theory]
    [InlineData("jobId=-1")]
    [InlineData("worker=SECRET")]
    [InlineData("createdFrom=0001-01-01T00:00:00Z")]
    [InlineData("failureCode=SECRET")]
    [InlineData("createdFrom=2026-11-01T00:00:00Z&createdBefore=2026-10-01T00:00:00Z")]
    public async Task Invalid_diagnostic_filters_fail_closed(string query)
    {
        await using var host = await Host.Start();
        using var client = host.Client("admin");
        Assert.Equal(HttpStatusCode.BadRequest, (await client.GetAsync("/api/admin/processing?" + query)).StatusCode);
    }

    [Theory]
    [InlineData("jobId=2", 1)]
    [InlineData("q=Owned%20job%20title", 1)]
    [InlineData("q=owner%40example.test", 2)]
    [InlineData("worker=document", 1)]
    [InlineData("worker=ai", 2)]
    [InlineData("failureCode=timeout", 1)]
    [InlineData("failureCode=processing_failed", 1)]
    [InlineData("createdBefore=2026-10-16T00:00:00Z", 1)]
    public async Task Diagnostic_filters_preserve_actual_owner_relationships(string query, int expected)
    {
        await using var host = await Host.Start();
        using var client = host.Client("admin");
        var result = await client.GetFromJsonAsync<JsonElement>("/api/admin/processing?" + query + "&pageSize=1");
        Assert.Equal(expected, result.GetProperty("total").GetInt32());
        Assert.Single(result.GetProperty("items").EnumerateArray());
        Assert.DoesNotContain("SECRET", result.GetRawText());
    }

    [Fact]
    public async Task Detail_exposes_import_identity_and_links_only_the_administrators_own_application()
    {
        await using var host = await Host.Start();
        using var admin = host.Client("admin");
        var document = await admin.GetFromJsonAsync<JsonElement>($"/api/admin/processing/{host.OperationId}");
        Assert.Equal(1, document.GetProperty("document").GetProperty("importId").GetInt32());
        var job = await admin.GetFromJsonAsync<JsonElement>($"/api/admin/processing/{host.JobOperationId}");
        Assert.False(job.GetProperty("job").GetProperty("canOpen").GetBoolean());
        using var ownerAdmin = host.Client("owner-admin");
        job = await ownerAdmin.GetFromJsonAsync<JsonElement>($"/api/admin/processing/{host.JobOperationId}");
        Assert.True(job.GetProperty("job").GetProperty("canOpen").GetBoolean());
        var search = await admin.GetFromJsonAsync<JsonElement>($"/api/admin/processing?q={host.OperationId}");
        Assert.Equal(1, search.GetProperty("total").GetInt32());
    }

    [Fact]
    public async Task Processing_reads_share_a_bounded_account_rate_limit()
    {
        await using var host = await Host.Start(2);
        using var admin = host.Client("admin");
        Assert.Equal(HttpStatusCode.OK, (await admin.GetAsync("/api/admin/processing")).StatusCode);
        Assert.Equal(HttpStatusCode.OK, (await admin.GetAsync($"/api/admin/processing/{host.OperationId}")).StatusCode);
        Assert.Equal(HttpStatusCode.TooManyRequests, (await admin.GetAsync($"/api/admin/processing/{host.OperationId}/events")).StatusCode);
        using var other = host.Client("owner-admin");
        Assert.Equal(HttpStatusCode.OK, (await other.GetAsync("/api/admin/processing")).StatusCode);
    }

    [Theory]
    [InlineData("succeeded")]
    [InlineData("waiting_for_retry")]
    public async Task Failure_metadata_uses_the_recorded_failure_instead_of_later_success(string status)
    {
        await using var host = await Host.Start();
        var failedAt = DateTime.UtcNow.AddMinutes(-2);
        await using (var scope = host.Services.CreateAsyncScope())
        {
            var db = scope.ServiceProvider.GetRequiredService<JobTrackerContext>();
            var operation = await db.UserOperations.IgnoreQueryFilters().SingleAsync(item => item.Id == host.OperationId);
            operation.Status = status; operation.FailureCategory = "timeout";
            operation.CompletedAtUtc = status == "succeeded" ? failedAt.AddMinutes(1) : null;
            operation.ProgressStage = "cv_review_ready";
            db.UserOperationEvents.Add(new() { Id = 9007199254740995, OperationId = operation.Id, OwnerUserId = "owner", Kind = "RetryScheduled", Status = "waiting_for_retry", AtUtc = failedAt, Stage = "cv_extracting", FailureCode = "timeout" });
            await db.SaveChangesAsync();
        }
        using var client = host.Client("admin");
        var result = await client.GetFromJsonAsync<JsonElement>($"/api/admin/processing/{host.OperationId}");
        Assert.Equal(status, result.GetProperty("status").GetString());
        Assert.Equal(failedAt, result.GetProperty("lastFailureAtUtc").GetDateTime());
        Assert.Equal("cv_extracting", result.GetProperty("lastFailureStage").GetString());
    }

    [Fact]
    public async Task Missing_failure_history_does_not_turn_success_time_into_failure_evidence()
    {
        await using var host = await Host.Start();
        await using (var scope = host.Services.CreateAsyncScope())
        {
            var db = scope.ServiceProvider.GetRequiredService<JobTrackerContext>();
            var operation = await db.UserOperations.IgnoreQueryFilters().SingleAsync(item => item.Id == host.OperationId);
            operation.Status = "succeeded"; operation.FailureCategory = "timeout"; operation.CompletedAtUtc = DateTime.UtcNow;
            await db.SaveChangesAsync();
        }
        using var client = host.Client("admin");
        var result = await client.GetFromJsonAsync<JsonElement>($"/api/admin/processing/{host.OperationId}");
        Assert.Equal(JsonValueKind.Null, result.GetProperty("lastFailureAtUtc").ValueKind);
        Assert.Equal(JsonValueKind.Null, result.GetProperty("lastFailureStage").ValueKind);
    }

    [Fact]
    public async Task User_authored_identity_labels_are_bounded_before_admin_projection()
    {
        await using var host = await Host.Start();
        using var client = host.Client("admin");
        var detail = await client.GetFromJsonAsync<JsonElement>($"/api/admin/processing/{host.OperationId}");
        var name = detail.GetProperty("owner").GetProperty("name").GetString()!;
        Assert.True(name.Length <= 161);
        Assert.EndsWith("…", name);
    }

    [Theory]
    [InlineData(null, HttpStatusCode.Unauthorized)]
    [InlineData("ordinary", HttpStatusCode.Forbidden)]
    [InlineData("admin", HttpStatusCode.OK)]
    public async Task Processing_routes_require_the_server_administrator_role(string? identity, HttpStatusCode expected)
    {
        await using var host = await Host.Start();
        using var client = host.Client(identity);
        foreach (var route in new[] { "/api/admin/processing", $"/api/admin/processing/{host.OperationId}", $"/api/admin/processing/{host.OperationId}/events" })
            Assert.Equal(expected, (await client.GetAsync(route)).StatusCode);
    }

    [Fact]
    public async Task Admin_projection_filters_owners_and_never_returns_raw_processing_contents_or_lease_data()
    {
        await using var host = await Host.Start();
        using var client = host.Client("admin");
        var listing = await client.GetFromJsonAsync<JsonElement>("/api/admin/processing?owner=owner&status=running&pageSize=1");
        Assert.Equal(1, listing.GetProperty("total").GetInt32());
        Assert.Single(listing.GetProperty("items").EnumerateArray());
        var detail = await client.GetFromJsonAsync<JsonElement>($"/api/admin/processing/{host.OperationId}");
        Assert.Contains("owner@example.test", detail.GetRawText());
        Assert.Contains("CV.pdf", detail.GetRawText());
        Assert.Equal(2, detail.GetProperty("document").GetProperty("pages").GetInt32());
        Assert.DoesNotContain("folder", detail.GetProperty("document").GetProperty("name").GetString());
        Assert.DoesNotContain("SECRET", detail.GetRawText());
        Assert.DoesNotContain("SECRET", listing.GetRawText());
        var foreign = await client.GetFromJsonAsync<JsonElement>($"/api/admin/processing/{host.ForeignSubjectOperationId}");
        Assert.Equal(JsonValueKind.Null, foreign.GetProperty("job").ValueKind);
        Assert.DoesNotContain("Owned job title", foreign.GetRawText());
    }

    [Fact]
    public async Task Event_cursor_is_exact_ordered_bounded_retained_and_redacted()
    {
        await using var host = await Host.Start();
        using var client = host.Client("admin");
        var first = await client.GetFromJsonAsync<JsonElement>($"/api/admin/processing/{host.OperationId}/events?take=1");
        Assert.True(first.GetProperty("hasMore").GetBoolean());
        var item = Assert.Single(first.GetProperty("items").EnumerateArray());
        Assert.Equal("9007199254740994", item.GetProperty("id").GetString());
        Assert.DoesNotContain("SECRET", first.GetRawText());
        var after = await client.GetFromJsonAsync<JsonElement>($"/api/admin/processing/{host.OperationId}/events?after=9007199254740993");
        Assert.Single(after.GetProperty("items").EnumerateArray());
        var before = await client.GetFromJsonAsync<JsonElement>($"/api/admin/processing/{host.OperationId}/events?before=9007199254740994");
        Assert.Equal("9007199254740993", Assert.Single(before.GetProperty("items").EnumerateArray()).GetProperty("id").GetString());
        foreach (var query in new[] { "take=101", "after=-1", "after=1&before=2" })
            Assert.Equal(HttpStatusCode.BadRequest, (await client.GetAsync($"/api/admin/processing/{host.OperationId}/events?{query}")).StatusCode);
    }

    private sealed class Host(WebApplication app, string directory, Guid operationId, Guid foreignSubjectId) : IAsyncDisposable
    {
        public IServiceProvider Services => app.Services;
        public Guid OperationId => operationId;
        public Guid ForeignSubjectOperationId => foreignSubjectId;
        public Guid JobOperationId => Guid.Parse("22222222-2222-4222-8222-222222222222");
        public HttpClient Client(string? identity)
        {
            var client = new HttpClient { BaseAddress = new Uri(app.Services.GetRequiredService<IServer>().Features.Get<IServerAddressesFeature>()!.Addresses.Single()) };
            if (identity is not null) client.DefaultRequestHeaders.Add("X-Test-Identity", identity);
            return client;
        }
        public static async Task<Host> Start(int permits = 120)
        {
            var directory = Path.Combine(Path.GetTempPath(), "admin-processing-" + Guid.NewGuid().ToString("N"));
            Directory.CreateDirectory(directory);
            var builder = WebApplication.CreateBuilder();
            builder.Logging.ClearProviders(); builder.WebHost.UseUrls("http://127.0.0.1:0");
            builder.Services.AddControllers().AddApplicationPart(typeof(AuthController).Assembly);
            builder.Services.AddAuthentication("test").AddScheme<AuthenticationSchemeOptions, TestAuthentication>("test", _ => { });
            builder.Services.AddAuthorization(); builder.Services.AddHttpContextAccessor();
            builder.Services.AddRateLimiter(options =>
            {
                options.RejectionStatusCode = StatusCodes.Status429TooManyRequests;
                options.AddPolicy(AdminProcessingController.RateLimitPolicy, context => RateLimitPartition.GetFixedWindowLimiter(
                    RateLimitPartitionKeys.Account(context, AdminProcessingController.RateLimitPolicy),
                    _ => new FixedWindowRateLimiterOptions { PermitLimit = permits, Window = TimeSpan.FromMinutes(1), QueueLimit = 0 }));
            });
            builder.Services.AddScoped<ICurrentUserService, CurrentUserService>();
            builder.Services.AddSingleton(TimeProvider.System);
            builder.Services.AddDbContext<JobTrackerContext>(options => options.UseSqlite($"Data Source={Path.Combine(directory, "processing.db")};Pooling=False"));
            var app = builder.Build();
            app.UseAuthentication(); app.UseAuthorization(); app.UseRateLimiter(); app.MapControllers();
            var operationId = Guid.NewGuid(); var foreign = Guid.NewGuid();
            await using (var scope = app.Services.CreateAsyncScope())
            {
                var db = scope.ServiceProvider.GetRequiredService<JobTrackerContext>();
                await db.Database.EnsureCreatedAsync();
                db.Users.AddRange(new ApplicationUser { Id = "owner", Email = "owner@example.test", DisplayName = "Synthetic owner " + new string('n', 2000) }, new ApplicationUser { Id = "other", Email = "other@example.test" });
                var company = new Company { Id = 1, OwnerUserId = "owner", Name = "Synthetic company" };
                db.Companies.Add(company);
                db.JobApplications.Add(new() { Id = 2, OwnerUserId = "owner", CompanyId = 1, JobTitle = "Owned job title", Status = "Applied" });
                db.CvUploadArtifacts.Add(new() { Id = 1, OwnerUserId = "owner", OriginalFileName = "../folder/CV.pdf", MimeType = "application/pdf", ByteSize = 500, StoragePath = "SECRET_PATH" });
                db.CvExtractionRuns.Add(new() { Id = 1, ArtifactId = 1, OwnerUserId = "owner", Trigger = "document_import", ParserVersion = "docling-v1", DocumentJson = "{\"PageCount\":2,\"Text\":\"SECRET_CV_CONTENT\"}" });
                db.UserOperations.AddRange(new UserOperation { Id = operationId, OwnerUserId = "owner", IdempotencyKey = "one", TaskType = "cv.process", SubjectType = "cv_extraction_run", SubjectId = "1", Status = "running", CreatedAtUtc = DateTime.UtcNow, LeaseToken = "SECRET_TOKEN", FailureMessage = "SECRET_EXCEPTION", FailureCategory = "SECRET_CATEGORY", ResultReference = "SECRET_RESULT", ProgressStage = "SECRET_STAGE" },
                    new UserOperation { Id = foreign, OwnerUserId = "other", IdempotencyKey = "two", TaskType = "strategy.snapshot", SubjectType = "job_strategy", SubjectId = "2|", Status = "queued", CreatedAtUtc = DateTime.UtcNow },
                    new UserOperation { Id = Guid.Parse("22222222-2222-4222-8222-222222222222"), OwnerUserId = "owner", IdempotencyKey = "three", TaskType = "strategy.snapshot", SubjectType = "job_strategy", SubjectId = "2|", Status = "failed", FailureCategory = "timeout", CreatedAtUtc = new DateTime(2026, 10, 15, 12, 0, 0, DateTimeKind.Utc) });
                db.UserOperationEvents.AddRange(
                    new UserOperationEvent { Id = 100, OperationId = operationId, OwnerUserId = "owner", AtUtc = DateTime.UtcNow.AddDays(-31), Kind = "Created", Status = "queued" },
                    new UserOperationEvent { Id = 9007199254740993, OperationId = operationId, OwnerUserId = "owner", AtUtc = DateTime.UtcNow, Kind = "Created", Status = "running" },
                    new UserOperationEvent { Id = 9007199254740994, OperationId = operationId, OwnerUserId = "owner", AtUtc = DateTime.UtcNow, Kind = "SECRET_EVENT", Status = "SECRET_STATUS", Stage = "SECRET_STAGE", FailureCode = "SECRET_FAILURE" });
                await db.SaveChangesAsync();
            }
            await app.StartAsync(); return new(app, directory, operationId, foreign);
        }
        public async ValueTask DisposeAsync() { await app.DisposeAsync(); Directory.Delete(directory, true); }
    }
    private sealed class TestAuthentication(IOptionsMonitor<AuthenticationSchemeOptions> options, ILoggerFactory logger, UrlEncoder encoder) : AuthenticationHandler<AuthenticationSchemeOptions>(options, logger, encoder)
    {
        protected override Task<AuthenticateResult> HandleAuthenticateAsync()
        {
            if (!Request.Headers.TryGetValue("X-Test-Identity", out var identity)) return Task.FromResult(AuthenticateResult.NoResult());
            var claims = new List<Claim> { new(ClaimTypes.NameIdentifier, identity == "owner-admin" ? "owner" : identity.ToString()) };
            if (identity == "admin" || identity == "owner-admin") claims.Add(new(ClaimTypes.Role, "Admin"));
            return Task.FromResult(AuthenticateResult.Success(new AuthenticationTicket(new ClaimsPrincipal(new ClaimsIdentity(claims, "test")), "test")));
        }
    }
}