"""7F Forms file uploads. Platform file_id references; 7C stays pure."""
from __future__ import annotations

from datetime import UTC, datetime
from pathlib import Path

from src.domain.connectors.invoke_capabilities import (
    CAPABILITY_CONVERSION_PATTERN,
    FORMS_FAMILY_PLAN,
    INVOKE_CAPABILITIES,
)
from src.domain.forms.canonical import (
    FILE_RUNTIME_SUPPORT,
    FORBIDDEN_PROVIDER_TOKENS,
    FormDefinition,
    FormField,
    FormFileRef,
    FormSubmission,
    parse_form_file_ref,
    quote_request_block_compatible_definition,
)
from src.domain.forms.files import (
    FORMS_FILE_UPLOADS,
    RECORD_FILE_SEMANTIC,
    FormFileRecord,
    InMemoryFormFileDirectory,
    accept_form_submission_with_files,
    compiled_file_reference_field,
)
from src.domain.forms.persistence import (
    FormPersistenceContext,
    InMemoryFormSubmissionStore,
    get_form_submission,
    persist_form_submission,
)
from src.domain.forms.runtime import accept_form_submission
from src.domain.forms.validation import validate_form_values

_FIXED_AT = datetime(2026, 9, 13, 12, 0, tzinfo=UTC)
_FIXED_PERSISTED = datetime(2026, 9, 13, 12, 5, tzinfo=UTC)
_FSB_A = "fsb_" + ("a" * 32)
_FSB_B = "fsb_" + ("b" * 32)
_FILE_1 = "file_" + ("1" * 32)
_FILE_2 = "file_" + ("2" * 32)
_PROJECT_A = "prj_a"
_PROJECT_B = "prj_b"


def test_form_file_compiles_to_scalar_file_reference_semantic():
    assert compiled_file_reference_field("passport") == {
        "key": "passport",
        "type": "text",
        "semantic_type": RECORD_FILE_SEMANTIC,
    }


def _quote_base(**extra: object) -> dict:
    payload: dict = {
        "name": "Ada",
        "email": "ada@example.com",
        "message": "Quote please",
    }
    payload.update(extra)
    return payload


def _directory(*pairs: tuple[str, str]) -> InMemoryFormFileDirectory:
    store = InMemoryFormFileDirectory()
    for project_id, file_id in pairs:
        store.put(FormFileRecord(project_id=project_id, file_id=file_id))
    return store


def _ref_id(value: object) -> str:
    parsed = parse_form_file_ref(value)
    assert parsed is not None
    return parsed.file_id


def test_7f_file_runtime_frozen() -> None:
    assert FILE_RUNTIME_SUPPORT is True
    assert FORMS_FILE_UPLOADS["status"] == "frozen"
    assert FORMS_FILE_UPLOADS["bytes_in_form_submission"] is False
    assert FORMS_FILE_UPLOADS["customer_storage_file_star"] is False
    assert FORMS_FILE_UPLOADS["upload_execution_domain"] == "P"
    assert FORMS_FILE_UPLOADS["form_file_capability"] is False
    assert FORMS_FILE_UPLOADS["file_id_source"] == "platform_cloud_randomId_file"
    assert "form.submit" not in INVOKE_CAPABILITIES
    assert "form.file.upload" not in INVOKE_CAPABILITIES
    assert "storage.file.put" in INVOKE_CAPABILITIES
    assert CAPABILITY_CONVERSION_PATTERN["phase_7_status"] == "complete"
    assert CAPABILITY_CONVERSION_PATTERN["next_program_slice"] == "9_app_block_modernization"
    assert FORMS_FAMILY_PLAN["slices"][5] == "7f_file_uploads"
    assert FORMS_FAMILY_PLAN["file_runtime_frozen"] is True


def test_7c_accepts_form_file_ref_shape_only() -> None:
    definition = quote_request_block_compatible_definition()
    ok = validate_form_values(
        definition, _quote_base(attachment={"file_id": _FILE_1})
    )
    assert ok.ok is True
    assert isinstance(ok.values["attachment"], FormFileRef)
    assert ok.values["attachment"].file_id == _FILE_1
    omitted = validate_form_values(definition, _quote_base())
    assert omitted.ok is True
    assert "attachment" not in omitted.values
    bad = validate_form_values(definition, _quote_base(attachment="file-id"))
    assert any(error.code == "invalid_type" for error in bad.errors)
    nested = validate_form_values(
        definition,
        _quote_base(attachment={"file_id": _FILE_1, "bucket": "uploads"}),
    )
    assert any(error.code == "invalid_type" for error in nested.errors)
    url = validate_form_values(
        definition, _quote_base(attachment="https://cdn.example/x")
    )
    assert any(error.code == "invalid_type" for error in url.errors)


def test_7c_does_not_lookup_storage() -> None:
    definition = quote_request_block_compatible_definition()
    result = validate_form_values(
        definition, _quote_base(attachment={"file_id": _FILE_2})
    )
    assert result.ok is True


def test_fake_file_is_rejected_before_submission_id() -> None:
    definition = quote_request_block_compatible_definition()
    allocated: list[str] = []

    def factory() -> str:
        allocated.append("called")
        return _FSB_A

    result = accept_form_submission_with_files(
        definition,
        _quote_base(attachment={"file_id": _FILE_1}),
        project_id=_PROJECT_A,
        files=_directory(),
        submission_id_factory=factory,
        clock=lambda: _FIXED_AT,
    )
    assert result.accepted is False
    assert result.submission is None
    assert allocated == []
    assert any(error.code == "invalid_file" for error in result.errors)


def test_project_isolation_on_file_refs() -> None:
    definition = quote_request_block_compatible_definition()
    files = _directory((_PROJECT_A, _FILE_1))
    stolen = accept_form_submission_with_files(
        definition,
        _quote_base(attachment={"file_id": _FILE_1}),
        project_id=_PROJECT_B,
        files=files,
        submission_id_factory=lambda: _FSB_A,
        clock=lambda: _FIXED_AT,
    )
    assert stolen.accepted is False
    assert any(error.code == "invalid_file" for error in stolen.errors)
    ok = accept_form_submission_with_files(
        definition,
        _quote_base(attachment={"file_id": _FILE_1}),
        project_id=_PROJECT_A,
        files=files,
        submission_id_factory=lambda: _FSB_A,
        clock=lambda: _FIXED_AT,
    )
    assert ok.accepted is True
    assert ok.submission is not None
    assert ok.submission.submission.values["attachment"] == FormFileRef(
        file_id=_FILE_1
    )


def test_required_file_means_one_ref() -> None:
    definition = FormDefinition(
        key="sample",
        fields=[FormField(key="attachment", type="file", required=True)],
    )
    missing = validate_form_values(definition, {})
    assert missing.errors[0].code == "required"
    files = _directory((_PROJECT_A, _FILE_1))
    ok = accept_form_submission_with_files(
        definition,
        {"attachment": {"file_id": _FILE_1}},
        project_id=_PROJECT_A,
        files=files,
        submission_id_factory=lambda: _FSB_A,
        clock=lambda: _FIXED_AT,
    )
    assert ok.accepted is True


def test_persist_round_trip_keeps_file_id_not_url() -> None:
    definition = quote_request_block_compatible_definition()
    files = _directory((_PROJECT_A, _FILE_1))
    accepted = accept_form_submission_with_files(
        definition,
        _quote_base(attachment={"file_id": _FILE_1}),
        project_id=_PROJECT_A,
        files=files,
        submission_id_factory=lambda: _FSB_A,
        clock=lambda: _FIXED_AT,
    )
    assert accepted.submission is not None
    store = InMemoryFormSubmissionStore()
    persist_form_submission(
        store,
        FormPersistenceContext(project_id=_PROJECT_A),
        accepted.submission,
        clock=lambda: _FIXED_PERSISTED,
    )
    loaded = get_form_submission(
        store, FormPersistenceContext(project_id=_PROJECT_A), _FSB_A
    )
    assert loaded is not None
    assert _ref_id(loaded.accepted.submission.values["attachment"]) == _FILE_1
    blob = str(loaded.model_dump())
    assert "upload_url" not in blob
    assert "signed" not in blob.lower()


def test_deleted_file_does_not_invalidate_persisted_submission() -> None:
    definition = quote_request_block_compatible_definition()
    files = _directory((_PROJECT_A, _FILE_1))
    accepted = accept_form_submission_with_files(
        definition,
        _quote_base(attachment={"file_id": _FILE_1}),
        project_id=_PROJECT_A,
        files=files,
        submission_id_factory=lambda: _FSB_A,
        clock=lambda: _FIXED_AT,
    )
    assert accepted.submission is not None
    store = InMemoryFormSubmissionStore()
    persist_form_submission(
        store,
        FormPersistenceContext(project_id=_PROJECT_A),
        accepted.submission,
        clock=lambda: _FIXED_PERSISTED,
    )
    files.delete(_PROJECT_A, _FILE_1)
    loaded = get_form_submission(
        store, FormPersistenceContext(project_id=_PROJECT_A), _FSB_A
    )
    assert loaded is not None
    assert _ref_id(loaded.accepted.submission.values["attachment"]) == _FILE_1
    assert files.get(_PROJECT_A, _FILE_1) is None


def test_same_file_two_submissions_are_not_deduped() -> None:
    definition = quote_request_block_compatible_definition()
    files = _directory((_PROJECT_A, _FILE_1))
    first = accept_form_submission_with_files(
        definition,
        _quote_base(attachment={"file_id": _FILE_1}),
        project_id=_PROJECT_A,
        files=files,
        submission_id_factory=lambda: _FSB_A,
        clock=lambda: _FIXED_AT,
    )
    second = accept_form_submission_with_files(
        definition,
        _quote_base(attachment={"file_id": _FILE_1}),
        project_id=_PROJECT_A,
        files=files,
        submission_id_factory=lambda: _FSB_B,
        clock=lambda: _FIXED_AT,
    )
    assert first.accepted and second.accepted
    assert first.submission is not None and second.submission is not None
    assert first.submission.submission_id != second.submission.submission_id


def test_direct_7d_does_not_accept_bytes_or_storage_keys() -> None:
    definition = quote_request_block_compatible_definition()
    binary = accept_form_submission(
        definition,
        _quote_base(attachment=b"bytes"),
        submission_id_factory=lambda: _FSB_A,
        clock=lambda: _FIXED_AT,
    )
    assert binary.accepted is False
    customer = accept_form_submission(
        definition,
        _quote_base(attachment={"storage": "uploads", "key": "x.pdf"}),
        submission_id_factory=lambda: _FSB_A,
        clock=lambda: _FIXED_AT,
    )
    assert customer.accepted is False


def test_filename_is_not_a_canonical_file_value() -> None:
    definition = quote_request_block_compatible_definition()
    result = validate_form_values(
        definition,
        _quote_base(attachment={"file_id": _FILE_1, "filename": "../../x.php"}),
    )
    assert result.ok is False
    assert any(error.code == "invalid_type" for error in result.errors)
    allowed = FormSubmission(
        form_key="quote_request",
        values={"attachment": {"file_id": _FILE_1}},
    )
    assert parse_form_file_ref(allowed.values["attachment"]) is not None


def test_provider_tokens_not_in_file_ref() -> None:
    ref = FormFileRef(file_id=_FILE_1).model_dump()
    for token in FORBIDDEN_PROVIDER_TOKENS:
        assert token not in ref
    assert set(ref) == {"file_id"}


def test_files_module_has_no_infrastructure_imports() -> None:
    source = Path("src/domain/forms/files.py").read_text(encoding="utf-8")
    for token in (
        "sqlalchemy",
        "src.domain.connectors",
        "src.integrations",
        "src.domain.cloud",
        "turnstile",
    ):
        assert token not in source