using System.Reflection;
using Morph.AiKit.Media;
using Xunit;

namespace Morph.AiKit.Tests;

/// <summary>
/// Canários da MARCAÇÃO — a quarta afirmação da rubrica `media-claims`, e a última que este
/// kit ainda prendia só por prosa.
/// </summary>
/// <remarks>
/// <para>
/// <b>A assimetria que estes testes fecham, medida:</b> a regra do turno de conversa estava
/// presa por TIPO (`internal` + id de job em vez de bytes) e provada por mutação; custo e
/// revisão humana, por ESTADO. A marcação — que é a obrigação legal, o art. 50 do AI Act que
/// motivou a issue — estava escrita em `MediaJobState.cs` ("publicado, com a marcacao
/// aplicada") e em `MediaRequest.cs` ("marcacao visivel obrigatoria"), e um `grep` por label,
/// watermark ou disclosure no kit inteiro voltava <b>vazio</b>. Zero mecanismo.
/// </para>
/// <para>
/// Uma rubrica que cobra de terceiros uma prova que o próprio exemplar não dá é o defeito que
/// esta epic catalogou. Estes testes são o inverso literal dele.
/// </para>
/// <para>
/// <b>Fronteira honesta:</b> nada aqui prova que o rótulo chegou aos olhos de alguém — a
/// renderização é do aplicativo consumidor, e nenhum tipo em C# alcança um pixel. O que se
/// prova é que a publicação <b>não acontece</b> sem a decisão registrada, com texto e
/// superfície nomeados.
/// </para>
/// </remarks>
public sealed class MediaDisclosureTests
{
    private static readonly DateTimeOffset T0 = new(2026, 9, 8, 12, 0, 0, TimeSpan.Zero);

    private static MediaDisclosure Label => MediaDisclosure.Create("Imagem gerada por IA", "legenda", T0);

    /// <summary>Um job aprovado, na finalidade pedida.</summary>
    private static MediaJob Approved(MediaPurpose purpose)
    {
        var job = MediaJob.Create(
            new MediaRequest("catalogo", "um sofa verde", purpose),
            new MediaIdempotencyKey("chave"),
            T0).StartGenerating().Value;

        job = job.MarkGenerated(
            new MediaHash("abc"),
            "ab/c/abc.png",
            new MediaProvenance("openai", "gpt-image-2", "p", null, [], "-", null, 0m, T0, true)).Value;

        return job.Approve(MediaReview.ApprovedBy("lucas", T0)).Value;
    }

    // ---------------------------------------------------------------------------------
    // A política, por finalidade — dado, não comentário
    // ---------------------------------------------------------------------------------

    /// <summary>Catálogo e marketing exigem marcação; rascunho não chega a publicar.</summary>
    [Theory]
    [InlineData(MediaPurpose.CatalogPhoto, true)]
    [InlineData(MediaPurpose.Marketing, true)]
    [InlineData(MediaPurpose.Draft, false)]
    public void RequiresDisclosureIsDeclaredPerPurpose(MediaPurpose purpose, bool expected)
        => Assert.Equal(expected, purpose.RequiresDisclosure());

    /// <summary>Rascunho é a única finalidade não publicável.</summary>
    [Theory]
    [InlineData(MediaPurpose.CatalogPhoto, true)]
    [InlineData(MediaPurpose.Marketing, true)]
    [InlineData(MediaPurpose.Draft, false)]
    public void OnlyDraftIsUnpublishable(MediaPurpose purpose, bool expected)
        => Assert.Equal(expected, purpose.IsPublishable());

    // ---------------------------------------------------------------------------------
    // A porta: publicar sem marcação NÃO é um caminho
    // ---------------------------------------------------------------------------------

    /// <summary>
    /// O caso central. Um job aprovado, de catálogo, sem marcação: <b>não publica</b>, e a
    /// razão nomeia o que falta.
    /// </summary>
    [Theory]
    [InlineData(MediaPurpose.CatalogPhoto)]
    [InlineData(MediaPurpose.Marketing)]
    public void PublishFailsWithoutADisclosureWhenThePurposeDemandsOne(MediaPurpose purpose)
    {
        var result = Approved(purpose).Publish(null, T0);

        Assert.False(
            result.IsSuccess,
            "publicar sem marcacao e o caminho que a obrigacao legal existe para fechar; " +
            "se ele existe, a afirmacao da rubrica media-claims esta presa so por prosa");
        Assert.Equal(MediaErrorCode.InvalidTransition, result.Error!.Code);
        Assert.Contains("marcacao", result.Error.Message, StringComparison.OrdinalIgnoreCase);
    }

    /// <summary>Com a marcação, publica — e ela fica GRAVADA no job, não descartada.</summary>
    [Fact]
    public void PublishSucceedsWithADisclosureAndRecordsIt()
    {
        var published = Approved(MediaPurpose.CatalogPhoto).Publish(Label, T0);

        Assert.True(published.IsSuccess);
        Assert.Equal(MediaJobState.Published, published.Value.State);
        Assert.Equal("Imagem gerada por IA", published.Value.Disclosure!.Text);
        Assert.Equal("legenda", published.Value.Disclosure.Surface);
        Assert.Equal(T0, published.Value.Disclosure.AppliedAt);
    }

    /// <summary>
    /// Rascunho não publica, <b>nem com marcação e nem estando aprovado</b>. Era uma frase
    /// num comentário XML; agora é uma recusa.
    /// </summary>
    [Fact]
    public void ADraftNeverPublishesEvenApprovedAndLabelled()
    {
        var result = Approved(MediaPurpose.Draft).Publish(Label, T0);

        Assert.False(result.IsSuccess);
        Assert.Contains("nao publica", result.Error!.Message, StringComparison.OrdinalIgnoreCase);
    }

    /// <summary>
    /// A ordem das portas importa: o estado vem antes da marcação. Um job NÃO aprovado, sem
    /// marcação, tem de reclamar da revisão humana — mandar consertar a marcação de algo que
    /// nem foi revisado manda consertar a coisa errada.
    /// </summary>
    [Fact]
    public void TheStateGateIsReportedBeforeTheDisclosureGate()
    {
        var generated = MediaJob.Create(
            new MediaRequest("catalogo", "p", MediaPurpose.CatalogPhoto),
            new MediaIdempotencyKey("k"),
            T0).StartGenerating().Value
            .MarkGenerated(
                new MediaHash("abc"), "ab/c/abc.png",
                new MediaProvenance("openai", "m", "p", null, [], "-", null, 0m, T0, true)).Value;

        var result = generated.Publish(null, T0);

        Assert.False(result.IsSuccess);
        Assert.Contains("Approved", result.Error!.Message, StringComparison.Ordinal);
        Assert.DoesNotContain("marcacao", result.Error.Message, StringComparison.OrdinalIgnoreCase);
    }

    // ---------------------------------------------------------------------------------
    // A marcação vazia é o campo preenchido "para passar"
    // ---------------------------------------------------------------------------------

    /// <summary>
    /// <b>A construção não tem outra porta.</b> Este é o teste que o nome do anterior prometia
    /// e não entregava.
    /// </summary>
    /// <remarks>
    /// <para>
    /// A primeira versão de <see cref="MediaDisclosure"/> era um record POSICIONAL, e record
    /// posicional gera construtor <b>público</b>. A validação vivia só em
    /// <see cref="MediaDisclosure.Create"/>, então um consumidor externo fazia
    /// <c>new MediaDisclosure("", "", at)</c> e publicava com rótulo vazio — medido:
    /// <c>IsSuccess=True State=Published</c>. O canário de então exercitava a FÁBRICA e passava
    /// verde o tempo todo: media a copia, nao o objeto.
    /// </para>
    /// <para>
    /// Por isso a asserção é por REFLEXÃO sobre o tipo. Ela não pode ser escrita como
    /// <c>new MediaDisclosure(...)</c> — hoje isso nem compila, e é esse o ponto: uma asserção
    /// que só existe enquanto o defeito existe não é canário.
    /// </para>
    /// </remarks>
    [Fact]
    public void TheTypeExposesNoPublicConstructor()
    {
        var publicCtors = typeof(MediaDisclosure)
            .GetConstructors(BindingFlags.Public | BindingFlags.Instance);

        Assert.True(
            publicCtors.Length == 0,
            "MediaDisclosure nao pode ter construtor publico: ele contorna Create e deixa " +
            "passar marcacao em branco — o campo preenchido 'para passar' que este tipo existe " +
            "para impedir. Record POSICIONAL gera um; use record com construtor privado, como " +
            "MediaReview. Encontrados: " + string.Join(" | ", publicCtors.Select(c => c.ToString())));
    }

    /// <summary>Texto ou superfície em branco é recusado pela única porta que existe.</summary>
    [Theory]
    [InlineData("", "legenda")]
    [InlineData("   ", "legenda")]
    [InlineData("Imagem gerada por IA", "")]
    [InlineData("Imagem gerada por IA", "   ")]
    public void ABlankDisclosureIsRefusedByTheOnlyFactory(string text, string surface)
        => Assert.Throws<ArgumentException>(() => MediaDisclosure.Create(text, surface, T0));

    /// <summary>
    /// A superfície é obrigatória junto do texto: "marcado" sem dizer ONDE não responde se
    /// alguém consegue ver.
    /// </summary>
    [Fact]
    public void TheDisclosureCarriesBothTheTextAndWhereItAppears()
    {
        var disclosure = MediaDisclosure.Create("Gerado por IA", "sobreposicao", T0);

        Assert.Equal("Gerado por IA", disclosure.Text);
        Assert.Equal("sobreposicao", disclosure.Surface);
    }

    /// <summary>Uma publicação recusada não muda o job — o registro continua imutável.</summary>
    [Fact]
    public void ARefusedPublishLeavesTheJobUntouched()
    {
        var job = Approved(MediaPurpose.Marketing);

        _ = job.Publish(null, T0);

        Assert.Equal(MediaJobState.Approved, job.State);
        Assert.Null(job.Disclosure);
        Assert.Null(job.PublishedAt);
    }
}