"""End-to-end integration tests."""

from __future__ import annotations

from quantumshield.identity.agent import AgentIdentity

from pqc_content_provenance import (
    AIGeneratedAssertion,
    ContentManifest,
    GenerationContext,
    ManifestSigner,
    ModelAttribution,
    ProvenanceChain,
    UsageAssertion,
    embed_manifest,
    extract_manifest,
)


def test_full_lifecycle_text_content() -> None:
    identity = AgentIdentity.create("lifecycle-signer")
    signer = ManifestSigner(identity)

    content = b"An AI-generated article about post-quantum cryptography."
    manifest = ContentManifest.create(
        content=content,
        content_type="text/plain",
        model_attribution=ModelAttribution(
            model_did=identity.did,
            model_name="Llama-3-8B-Instruct",
            model_version="1.0",
        ),
        generation_context=GenerationContext(
            prompt_hash="a" * 64,
            parameters={"temperature": 0.7},
            generated_at="2026-04-20T10:00:00Z",
        ),
        assertions=[
            AIGeneratedAssertion(
                model_name="Llama-3-8B-Instruct",
                model_version="1.0",
                generator_type="text",
            ),
            UsageAssertion(
                license="cc-by-4.0",
                commercial_use=True,
                attribution_required=True,
                attribution_text="Generated by Llama-3",
            ),
        ],
    )

    signed = signer.sign(manifest)
    envelope = embed_manifest(content, signed, mode="sidecar")

    # Consumer receives envelope and verifies
    recovered_manifest, recovered_content = extract_manifest(envelope, mode="sidecar")
    result = ManifestSigner.verify(recovered_manifest, recovered_content)
    assert result.valid is True
    assert result.content_hash_match is True
    assert result.signature_match is True


def test_derived_content_chain_verifies() -> None:
    model_identity = AgentIdentity.create("model-signer")
    editor_identity = AgentIdentity.create("editor-signer")
    model_signer = ManifestSigner(model_identity)
    editor_signer = ManifestSigner(editor_identity)

    attribution = ModelAttribution(
        model_did=model_identity.did,
        model_name="Llama-3-8B-Instruct",
        model_version="1.0",
    )
    ctx = GenerationContext(
        prompt_hash="a" * 64,
        parameters={"temperature": 0.6},
        generated_at="2026-04-20T10:00:00Z",
    )

    original_content = b"Draft press release."
    original = ContentManifest.create(
        content=original_content,
        content_type="text/plain",
        model_attribution=attribution,
        generation_context=ctx,
        assertions=[AIGeneratedAssertion(model_name="Llama-3-8B-Instruct")],
    )
    original_signed = model_signer.sign(original)

    edited_content = b"Final press release (human-edited)."
    edited = ContentManifest.create(
        content=edited_content,
        content_type="text/plain",
        model_attribution=attribution,
        generation_context=ctx,
        assertions=[
            AIGeneratedAssertion(model_name="Llama-3-8B-Instruct", human_edited=True)
        ],
        previous_manifest_id=original_signed.manifest_id,
    )
    edited_signed = editor_signer.sign(edited)

    chain = ProvenanceChain()
    chain.add(original_signed)
    chain.add(edited_signed)

    ok, errors = chain.verify_chain()
    assert ok is True, errors
    assert len(chain.links) == 2


def test_tampered_content_detected() -> None:
    identity = AgentIdentity.create("tamper-signer")
    signer = ManifestSigner(identity)

    original = b"The patient has low risk."
    manifest = ContentManifest.create(
        content=original,
        content_type="text/plain",
        model_attribution=ModelAttribution(
            model_did=identity.did,
            model_name="Medical-AI",
            model_version="1.0",
        ),
        generation_context=GenerationContext(
            prompt_hash="c" * 64,
            generated_at="2026-04-20T10:00:00Z",
        ),
    )
    signed = signer.sign(manifest)

    # Tamper with the actual content bytes
    tampered = b"The patient has high risk."
    result = ManifestSigner.verify(signed, tampered)
    assert result.valid is False
    assert result.content_hash_match is False
    # Signature over the (untampered) manifest is still valid
    assert result.signature_match is True