using System.Net;
using System.Net.Http.Headers;
using System.Net.Http.Json;
using ItWorx.KnowledgeHub.Application.Attachments;
using ItWorx.KnowledgeHub.Application.Audit;
using ItWorx.KnowledgeHub.Application.Automation;
using ItWorx.KnowledgeHub.Application.Ingestion;
using ItWorx.KnowledgeHub.Application.Ingestion.UseCases;
using ItWorx.KnowledgeHub.Application.Knowledge;
using ItWorx.KnowledgeHub.Contracts.Automation;
using ItWorx.KnowledgeHub.Contracts.Ingestion;
using ItWorx.KnowledgeHub.Domain.Attachments;
using ItWorx.KnowledgeHub.Domain.Automation;
using ItWorx.KnowledgeHub.Domain.Ingestion;
using ItWorx.KnowledgeHub.Domain.Knowledge;
using ItWorx.KnowledgeHub.IntegrationTests.Infrastructure;

namespace ItWorx.KnowledgeHub.IntegrationTests.Ingestion;

/// <summary>Atomic-publication use-case tests using ports that model one shared
/// DbContext. They are deliberately Docker-free; HTTP authorization stays covered by
/// the PostgreSQL API suite.</summary>
public sealed class IngestionPublicationTests
{
    private static readonly Guid WorkspaceId = Guid.Parse("11111111-1111-1111-1111-111111111111");
    private static readonly Guid ActorId = Guid.Parse("22222222-2222-2222-2222-222222222222");

    [Fact]
    public async Task Create_publication_stages_page_revision_attachment_audit_and_outbox_in_one_save()
    {
        var fixture = Fixture.Create();
        var result = await fixture.PublishAsync();

        Assert.Equal(IngestionProposalResultStatus.Success, result.Status);
        var page = Assert.Single(fixture.Pages.Added);
        Assert.Equal("Trusted article", page.TitleValue);
        Assert.Equal(DocumentStatus.Active, page.DocumentStatus);
        Assert.Equal(1, page.CurrentRevisionNumber);
        Assert.Equal(page.Id, Assert.Single(fixture.Pages.Revisions).PageId);
        Assert.Equal(page.Id, fixture.Attachments.TransferredPageId);
        Assert.Equal("ingestion-proposal.published", Assert.Single(fixture.Audits.Events).Action);
        Assert.Equal("ingestion-proposal.published.v1", Assert.Single(fixture.Outbox.Messages).EventType);
        Assert.Equal(IngestionProposalStatus.Published, fixture.Proposal.Status);
        Assert.Equal(page.Id, fixture.Proposal.PublishedPageId);
        Assert.Equal(1, fixture.Proposals.SaveCalls);
    }

    [Fact]
    public async Task Stale_update_returns_proposal_to_review_without_page_attachment_audit_or_outbox_side_effects()
    {
        var fixture = Fixture.Update("newer-target-etag");
        var result = await fixture.PublishAsync();

        Assert.Equal(IngestionProposalResultStatus.StaleTarget, result.Status);
        Assert.Equal(IngestionProposalStatus.ReadyForReview, fixture.Proposal.Status);
        Assert.Empty(fixture.Pages.Added);
        Assert.Empty(fixture.Pages.Revisions);
        Assert.Null(fixture.Attachments.TransferredPageId);
        Assert.Empty(fixture.Audits.Events);
        Assert.Empty(fixture.Outbox.Messages);
        Assert.Equal(1, fixture.Proposals.SaveCalls); // ReadyForReview only.
    }

    [Fact]
    public async Task Replay_with_same_key_is_exactly_once_even_when_original_etag_is_retried()
    {
        var fixture = Fixture.Create();
        var first = await fixture.PublishAsync();
        var replay = await fixture.PublishAsync();

        Assert.Equal(IngestionProposalResultStatus.Success, first.Status);
        Assert.Equal(IngestionProposalResultStatus.Success, replay.Status);
        Assert.Equal(first.PageId, replay.PageId);
        Assert.Single(fixture.Pages.Added);
        Assert.Single(fixture.Pages.Revisions);
        Assert.Single(fixture.Outbox.Messages);
        Assert.Equal(1, fixture.Proposals.SaveCalls);
    }

    [Fact]
    public async Task Shared_save_failure_rolls_back_every_staged_side_effect()
    {
        var fixture = Fixture.Create(failSave: true);
        await Assert.ThrowsAsync<InvalidOperationException>(() => fixture.PublishAsync());

        Assert.Empty(fixture.Pages.Added);
        Assert.Empty(fixture.Pages.Revisions);
        Assert.Null(fixture.Attachments.TransferredPageId);
        Assert.Empty(fixture.Audits.Events);
        Assert.Empty(fixture.Outbox.Messages);
    }

    private sealed class Fixture
    {
        private const string ProposalETag = "proposal-etag";
        private const string PublishKey = "publish-once";
        private Fixture(IngestionProposal proposal, Proposals proposals, Pages pages, Attachments attachments, Audits audits, Outbox outbox)
            => (Proposal, Proposals, Pages, Attachments, Audits, Outbox) = (proposal, proposals, pages, attachments, audits, outbox);
        public IngestionProposal Proposal { get; }
        public Proposals Proposals { get; }
        public Pages Pages { get; }
        public Attachments Attachments { get; }
        public Audits Audits { get; }
        public Outbox Outbox { get; }

        public static Fixture Create(bool failSave = false) => Build(Approved(IngestionMutationKind.CreatePage), new Pages(), failSave);

        public static Fixture Update(string targetEtag)
        {
            var target = Page.Create(WorkspaceId, null, SortKey.First(), PageTitle.Create("Existing"), DocumentType.WikiPage,
                "original", ActorId, DateTimeOffset.UtcNow);
            return Build(Approved(IngestionMutationKind.UpdatePage, target.Id), new Pages(target, targetEtag));
        }

        public Task<PublishIngestionProposalResult> PublishAsync() => new PublishIngestionProposalUseCase(
            Proposals, Pages, new LinkResolutionService(Pages), Attachments, Audits, Outbox, TimeProvider.System).ExecuteAsync(
            new(WorkspaceId, Proposal.Id, ProposalETag, PublishKey, ActorId, "publication-test"), CancellationToken.None);

        private static Fixture Build(IngestionProposal proposal, Pages pages, bool failSave = false)
        {
            var attachments = new Attachments(); var audits = new Audits(); var outbox = new Outbox();
            var proposals = new Proposals(proposal, failSave, () => { pages.RollBack(); attachments.RollBack(); audits.RollBack(); outbox.RollBack(); });
            return new Fixture(proposal, proposals, pages, attachments, audits, outbox);
        }

        private static IngestionProposal Approved(IngestionMutationKind kind, Guid? targetPageId = null)
        {
            var proposal = IngestionProposal.Create(WorkspaceId, ActorId, "publication", "safe manifest");
            proposal.SetPublication(IngestionPublication.Create(kind, "Trusted article", "# Published body", "WikiPage", "Active",
                targetPageId: targetPageId, expectedTargetETag: kind == IngestionMutationKind.UpdatePage ? "target-etag" : null), ActorId, DateTimeOffset.UtcNow);
            proposal.AddSource("evidence.txt", "text/plain", 1, "c8c86d360bfb7bb0d036b7352bf89714946fb527c4074340752259109371f429", "clean", Guid.NewGuid());
            proposal.BeginAnalysis(ActorId, DateTimeOffset.UtcNow);
            proposal.ApplyAnalysis("Reviewed analysis", ActorId, DateTimeOffset.UtcNow);
            proposal.Approve(ActorId, DateTimeOffset.UtcNow);
            return proposal;
        }
    }

    private sealed class Proposals(IngestionProposal proposal, bool failSave, Action rollback) : IIngestionProposalRepository
    {
        private string etag = "proposal-etag";
        public int SaveCalls { get; private set; }
        public Task<IngestionProposalPage> ListAsync(IngestionProposalQuery query, CancellationToken cancellationToken) => Task.FromResult(new IngestionProposalPage([], null));
        public Task<IngestionProposal?> FindAsync(Guid workspaceId, Guid proposalId, CancellationToken cancellationToken) => Task.FromResult<IngestionProposal?>(workspaceId == proposal.WorkspaceId && proposalId == proposal.Id ? proposal : null);
        public Task<IngestionProposal?> FindByIdempotencyKeyAsync(Guid workspaceId, string idempotencyKey, CancellationToken cancellationToken) => Task.FromResult<IngestionProposal?>(null);
        public Task<string?> GetETagAsync(Guid workspaceId, Guid proposalId, CancellationToken cancellationToken) => Task.FromResult<string?>(workspaceId == proposal.WorkspaceId && proposalId == proposal.Id ? etag : null);
        public Task<IngestionProposal?> FindForUpdateAsync(Guid workspaceId, Guid proposalId, string expectedETag, CancellationToken cancellationToken) => Task.FromResult<IngestionProposal?>(workspaceId == proposal.WorkspaceId && proposalId == proposal.Id && expectedETag == etag ? proposal : null);
        public void Add(IngestionProposal item) => throw new NotSupportedException();
        public Task<int> SaveChangesAsync(CancellationToken cancellationToken)
        {
            SaveCalls++;
            if (failSave) { rollback(); return Task.FromException<int>(new InvalidOperationException("Forced shared DbContext save failure.")); }
            etag = "proposal-published-etag";
            return Task.FromResult(1);
        }
    }

    private sealed class Pages(Page? target = null, string? targetEtag = null) : IPageRepository
    {
        public List<Page> Added { get; } = [];
        public List<PageRevision> Revisions { get; } = [];
        public Task<Page?> FindAsync(Guid pageId, CancellationToken cancellationToken) => Task.FromResult(target?.Id == pageId ? target : null);
        public Task<string?> GetETagAsync(Guid pageId, CancellationToken cancellationToken) => Task.FromResult(target?.Id == pageId ? targetEtag : null);
        public Task<Page?> FindForUpdateAsync(Guid pageId, string expectedETag, CancellationToken cancellationToken) => Task.FromResult(target?.Id == pageId && targetEtag == expectedETag ? target : null);
        public Task<PageChildrenPage> GetChildrenAsync(Guid workspaceId, Guid? parentPageId, bool includeTrashed, string? cursor, int limit, CancellationToken cancellationToken) => throw new NotSupportedException();
        public Task<RagPublicationManifestPage> GetPublicationManifestAsync(Guid workspaceId, string? spaceTag, string? cursor, int limit, CancellationToken cancellationToken) => throw new NotSupportedException();
        public Task<bool> HasChildrenAsync(Guid pageId, CancellationToken cancellationToken) => throw new NotSupportedException();
        public Task<IReadOnlyList<Page>> GetBreadcrumbAsync(Guid pageId, CancellationToken cancellationToken) => throw new NotSupportedException();
        public Task<IReadOnlyList<Page>> FindAllByNormalizedTitleAsync(Guid workspaceId, string normalizedTitle, CancellationToken cancellationToken) => Task.FromResult<IReadOnlyList<Page>>([]);
        public Task<bool> IsSameOrDescendantAsync(Guid pageId, Guid candidateId, CancellationToken cancellationToken) => throw new NotSupportedException();
        public Task<IReadOnlyList<Page>> GetSiblingsAsync(Guid workspaceId, Guid? parentPageId, bool includeTrashed, CancellationToken cancellationToken) => Task.FromResult<IReadOnlyList<Page>>([]);
        public Task<IReadOnlyList<PageLink>> GetLinksForPageAsync(Guid sourcePageId, CancellationToken cancellationToken) => throw new NotSupportedException();
        public Task<IReadOnlyList<Page>> GetBacklinkSourcesAsync(Guid targetPageId, CancellationToken cancellationToken) => throw new NotSupportedException();
        public Task<IReadOnlyList<PageRevision>> GetRevisionsAsync(Guid pageId, CancellationToken cancellationToken) => throw new NotSupportedException();
        public Task<PageRevision?> GetRevisionAsync(Guid pageId, long revisionNumber, CancellationToken cancellationToken) => throw new NotSupportedException();
        public Task<int> PurgeEligibleTrashedPagesAsync(Guid workspaceId, DateTimeOffset now, CancellationToken cancellationToken) => throw new NotSupportedException();
        public void Add(Page page) => Added.Add(page);
        public void ReplaceLinks(Guid sourcePageId, IReadOnlyList<PageLink> links) { }
        public void AddRevision(PageRevision revision) => Revisions.Add(revision);
        public Task SaveChangesAsync(CancellationToken cancellationToken) => Task.CompletedTask;
        public void RollBack() { Added.Clear(); Revisions.Clear(); }
    }

    private sealed class Attachments : IAttachmentRepository
    {
        public Guid? TransferredPageId { get; private set; }
        public Task<AttachmentBlob?> FindBlobAsync(string sha256, CancellationToken cancellationToken) => throw new NotSupportedException();
        public void AddBlob(AttachmentBlob blob) => throw new NotSupportedException();
        public Task<AttachmentReference?> FindReferenceAsync(Guid referenceId, CancellationToken cancellationToken) => throw new NotSupportedException();
        public void AddReference(AttachmentReference reference) => throw new NotSupportedException();
        public void AddUsage(AttachmentUsage usage) => throw new NotSupportedException();
        public Task<IReadOnlyList<AttachmentReference>> GetReferencesForPageAsync(Guid pageId, CancellationToken cancellationToken) => throw new NotSupportedException();
        public Task<IReadOnlyDictionary<string, AttachmentBlob>> FindBlobsAsync(IReadOnlyCollection<string> hashes, CancellationToken cancellationToken) => throw new NotSupportedException();
        public Task<AttachmentUsage?> FindUsageForReferenceAsync(Guid attachmentReferenceId, CancellationToken cancellationToken) => throw new NotSupportedException();
        public Task<IReadOnlyList<string>> FindUnreferencedBlobHashesAsync(IReadOnlyCollection<string> hashes, CancellationToken cancellationToken) => throw new NotSupportedException();
        public Task<int> RemoveBlobRecordsAsync(IReadOnlyCollection<string> hashes, CancellationToken cancellationToken) => throw new NotSupportedException();
        public Task<IReadOnlyList<AttachmentUsage>> GetUsagesForStagingSessionAsync(Guid stagingSessionId, CancellationToken cancellationToken) => throw new NotSupportedException();
        public Task TransferProposalUsagesToPageAsync(Guid ingestionProposalId, Guid pageId, CancellationToken cancellationToken) { TransferredPageId = pageId; return Task.CompletedTask; }
        public Task<StagingAttachmentCleanupResult> RemoveOrphanedStagingAttachmentsAsync(Guid stagingSessionId, CancellationToken cancellationToken) => throw new NotSupportedException();
        public Task SaveChangesAsync(CancellationToken cancellationToken) => Task.CompletedTask;
        public void RollBack() => TransferredPageId = null;
    }

    private sealed class Audits : IAuditEventRecorder
    {
        public List<AuditEventRecord> Events { get; } = [];
        public void Add(AuditEventRecord auditEvent) => Events.Add(auditEvent);
        public Task RecordAsync(AuditEventRecord auditEvent, CancellationToken cancellationToken) { Events.Add(auditEvent); return Task.CompletedTask; }
        public void RollBack() => Events.Clear();
    }

    private sealed class Outbox : IOutboxRepository
    {
        public List<OutboxMessage> Messages { get; } = [];
        public void Add(OutboxMessage message) => Messages.Add(message);
        public Task<IReadOnlyList<OutboxMessage>> GetUnprocessedAsync(int limit, CancellationToken cancellationToken) => Task.FromResult<IReadOnlyList<OutboxMessage>>([]);
        public void RollBack() => Messages.Clear();
    }
}

/// <summary>Route-level guard for the non-delegable human-review boundary. This is
/// fixture-backed because it intentionally exercises the real cookie and bearer auth
/// handlers.</summary>
[Collection(PostgresTestGroup.Name)]
public sealed class IngestionPublicationApiTests(PostgresContainerFixture postgres) : OwnerSetupTestBase(
    postgres, new Dictionary<string, string?> { ["IngestionProposal:Enabled"] = "true" })
{
    [Fact]
    public async Task Publish_rejects_a_service_account_and_accepts_the_human_reviewer()
    {
        using var owner = Factory.CreateClient();
        await SetupHelper.LoginAsync(owner, OwnerEmail, OwnerPassword);
        var serviceToken = await CreateServiceAccountAsync(owner, "publication-analyzer");
        using var service = Factory.CreateClient();
        service.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", serviceToken.RawToken);

        using var create = new HttpRequestMessage(HttpMethod.Post, "/api/v1/ingestion-proposals")
        {
            Content = JsonContent.Create(new CreateIngestionProposalRequest("safe manifest", "publication-api",
                new IngestionPublicationRequest("Published page", "# Body", "WikiPage", "Active", "CreatePage")))
        };
        create.Headers.Add("Idempotency-Key", "publication-api-create");
        var created = await service.SendAsync(create);
        created.EnsureSuccessStatusCode();
        var proposal = Assert.IsType<IngestionProposalDetail>(await created.Content.ReadFromJsonAsync<IngestionProposalDetail>());
        Assert.Equal("CreatePage", proposal.MutationKind);
        Assert.Null(proposal.Destination?.PageId);
        Assert.Equal("Published page", proposal.Destination?.Title);
        Assert.Equal("WikiPage", proposal.Metadata?.DocumentType);
        Assert.Equal("Active", proposal.Metadata?.DocumentStatus);
        Assert.Null(proposal.ExpectedTargetETag);
        Assert.Empty(proposal.Attachments);
        Assert.Empty(proposal.Citations);
        Assert.Empty(proposal.Warnings);
        Assert.Empty(proposal.DuplicateCandidates);
        Assert.Empty(proposal.ConflictCandidates);
        Assert.NotNull(proposal.Diff);
        Assert.Null(proposal.Diff.Before);
        Assert.Equal("# Body", proposal.Diff.After);

        using var analyze = new HttpRequestMessage(HttpMethod.Patch, $"/api/v1/ingestion-proposals/{proposal.Id}")
        {
            Content = JsonContent.Create(new PatchIngestionProposalRequest(null, null, "Safe review analysis."))
        };
        analyze.Headers.TryAddWithoutValidation("If-Match", created.Headers.ETag!.Tag);
        var analyzed = await service.SendAsync(analyze);
        analyzed.EnsureSuccessStatusCode();

        using var forbiddenPublish = new HttpRequestMessage(HttpMethod.Post, $"/api/v1/ingestion-proposals/{proposal.Id}/publish");
        forbiddenPublish.Headers.TryAddWithoutValidation("If-Match", analyzed.Headers.ETag!.Tag);
        forbiddenPublish.Headers.Add("Idempotency-Key", "service-cannot-publish");
        Assert.Equal(HttpStatusCode.Forbidden, (await service.SendAsync(forbiddenPublish)).StatusCode);

        var csrf = await SetupHelper.GetCsrfTokenAsync(owner);
        using var approve = new HttpRequestMessage(HttpMethod.Post, $"/api/v1/ingestion-proposals/{proposal.Id}/approve")
        {
            Content = JsonContent.Create(new IngestionProposalDecisionRequest(null))
        };
        approve.Headers.Add(csrf.HeaderName, csrf.Value);
        approve.Headers.TryAddWithoutValidation("If-Match", analyzed.Headers.ETag!.Tag);
        var approved = await owner.SendAsync(approve);
        approved.EnsureSuccessStatusCode();

        csrf = await SetupHelper.GetCsrfTokenAsync(owner);
        using var publish = new HttpRequestMessage(HttpMethod.Post, $"/api/v1/ingestion-proposals/{proposal.Id}/publish");
        publish.Headers.Add(csrf.HeaderName, csrf.Value);
        publish.Headers.TryAddWithoutValidation("If-Match", approved.Headers.ETag!.Tag);
        publish.Headers.Add("Idempotency-Key", "human-publish-once");
        var published = await owner.SendAsync(publish);

        Assert.Equal(HttpStatusCode.OK, published.StatusCode);
        var detail = await published.Content.ReadFromJsonAsync<IngestionProposalDetail>();
        Assert.Equal("Published", detail?.Status);
        Assert.NotNull(detail?.PublishedPageId);
    }

    private static async Task<CreatedServiceAccountToken> CreateServiceAccountAsync(HttpClient owner, string name)
    {
        var response = await SetupHelper.PostWithCsrfAsync(owner, "/api/v1/service-accounts",
            new CreateServiceAccountRequest(name, "trusted-intake publication test", [Scopes.IngestionWrite]));
        response.EnsureSuccessStatusCode();
        return Assert.IsType<CreatedServiceAccountToken>(await response.Content.ReadFromJsonAsync<CreatedServiceAccountToken>());
    }
}