"""Phase 2 TDD: Mist push validator — filename security gate.

Tests are written RED first.  Run before touching musehub_mist_push_validator.py
and musehub_wire.py to confirm they fail, then implement to make them green.

The validator is a pure service (no DB) — it takes a manifest dict of
``{path: object_id}`` and returns a ``MistValidationResult`` with errors and
warnings.  Hard errors → push rejected 422.  Warnings → push accepted with
non-empty warnings list.

The wire stream calls the validator for every snapshot in mist-domain pushes.
"""
from __future__ import annotations

import pytest

# ---------------------------------------------------------------------------
# 1. MistValidationResult shape
# ---------------------------------------------------------------------------

class TestMistValidationResult:
    def test_valid_result_has_no_errors(self) -> None:
        from musehub.services.musehub_mist_push_validator import MistValidationResult

        r = MistValidationResult(errors=[], warnings=[])
        assert r.valid is True

    def test_result_with_errors_is_invalid(self) -> None:
        from musehub.services.musehub_mist_push_validator import MistValidationResult

        r = MistValidationResult(errors=["bad filename: '../evil'"], warnings=[])
        assert r.valid is False

    def test_result_with_only_warnings_is_valid(self) -> None:
        from musehub.services.musehub_mist_push_validator import MistValidationResult

        r = MistValidationResult(errors=[], warnings=["unknown artifact type: 'blob.bin'"])
        assert r.valid is True


# ---------------------------------------------------------------------------
# 2. validate_mist_manifest — hard errors
# ---------------------------------------------------------------------------

class TestValidateMistManifestHardErrors:
    def test_path_traversal_dot_dot_slash(self) -> None:
        from musehub.services.musehub_mist_push_validator import validate_mist_manifest

        result = validate_mist_manifest({"../evil.py": "sha256:aaa"})
        assert not result.valid
        assert any("../evil.py" in e for e in result.errors)

    def test_path_traversal_dot_dot_only(self) -> None:
        from musehub.services.musehub_mist_push_validator import validate_mist_manifest

        result = validate_mist_manifest({"..": "sha256:aaa"})
        assert not result.valid

    def test_null_byte_in_filename(self) -> None:
        from musehub.services.musehub_mist_push_validator import validate_mist_manifest

        result = validate_mist_manifest({"evil\x00.py": "sha256:aaa"})
        assert not result.valid
        assert any("evil" in e for e in result.errors)

    def test_ansi_escape_in_filename(self) -> None:
        from musehub.services.musehub_mist_push_validator import validate_mist_manifest

        result = validate_mist_manifest({"\x1b[31mred\x1b[0m.py": "sha256:aaa"})
        assert not result.valid

    def test_control_character_in_filename(self) -> None:
        from musehub.services.musehub_mist_push_validator import validate_mist_manifest

        result = validate_mist_manifest({"bell\x07.py": "sha256:aaa"})
        assert not result.valid

    def test_forward_slash_path_separator(self) -> None:
        from musehub.services.musehub_mist_push_validator import validate_mist_manifest

        result = validate_mist_manifest({"subdir/file.py": "sha256:aaa"})
        assert not result.valid

    def test_backslash_path_separator(self) -> None:
        from musehub.services.musehub_mist_push_validator import validate_mist_manifest

        result = validate_mist_manifest({"subdir\\file.py": "sha256:aaa"})
        assert not result.valid

    def test_filename_exceeds_255_chars(self) -> None:
        from musehub.services.musehub_mist_push_validator import validate_mist_manifest

        long_name = "a" * 256 + ".py"
        result = validate_mist_manifest({long_name: "sha256:aaa"})
        assert not result.valid

    def test_errors_list_all_invalid_paths(self) -> None:
        """Multiple bad paths → multiple error entries, all listed."""
        from musehub.services.musehub_mist_push_validator import validate_mist_manifest

        result = validate_mist_manifest({
            "../a.py": "sha256:aaa",
            "evil\x00.py": "sha256:bbb",
            "good.py": "sha256:ccc",
        })
        assert not result.valid
        assert len(result.errors) == 2

    def test_empty_filename_is_rejected(self) -> None:
        from musehub.services.musehub_mist_push_validator import validate_mist_manifest

        result = validate_mist_manifest({"": "sha256:aaa"})
        assert not result.valid


# ---------------------------------------------------------------------------
# 3. validate_mist_manifest — valid inputs
# ---------------------------------------------------------------------------

class TestValidateMistManifestValid:
    def test_clean_python_filename(self) -> None:
        from musehub.services.musehub_mist_push_validator import validate_mist_manifest

        result = validate_mist_manifest({"utils.py": "sha256:abc123"})
        assert result.valid
        assert result.errors == []

    def test_clean_typescript_filename(self) -> None:
        from musehub.services.musehub_mist_push_validator import validate_mist_manifest

        result = validate_mist_manifest({"Component.tsx": "sha256:abc123"})
        assert result.valid

    def test_clean_solidity_filename(self) -> None:
        from musehub.services.musehub_mist_push_validator import validate_mist_manifest

        result = validate_mist_manifest({"Token.sol": "sha256:abc123"})
        assert result.valid

    def test_empty_manifest_is_valid(self) -> None:
        from musehub.services.musehub_mist_push_validator import validate_mist_manifest

        result = validate_mist_manifest({})
        assert result.valid
        assert result.errors == []
        assert result.warnings == []

    def test_multiple_clean_filenames(self) -> None:
        from musehub.services.musehub_mist_push_validator import validate_mist_manifest

        result = validate_mist_manifest({
            "main.py": "sha256:aaa",
            "README.md": "sha256:bbb",
            "schema.json": "sha256:ccc",
        })
        assert result.valid
        assert result.errors == []


# ---------------------------------------------------------------------------
# 4. validate_mist_manifest — warnings (recoverable)
# ---------------------------------------------------------------------------

class TestValidateMistManifestWarnings:
    def test_unknown_extension_produces_warning(self) -> None:
        from musehub.services.musehub_mist_push_validator import validate_mist_manifest

        result = validate_mist_manifest({"blob.xyz123": "sha256:aaa"})
        assert result.valid
        assert len(result.warnings) == 1
        assert "blob.xyz123" in result.warnings[0]

    def test_no_extension_produces_warning(self) -> None:
        from musehub.services.musehub_mist_push_validator import validate_mist_manifest

        result = validate_mist_manifest({"Makefile": "sha256:aaa"})
        assert result.valid
        assert len(result.warnings) >= 1

    def test_known_extension_produces_no_warning(self) -> None:
        from musehub.services.musehub_mist_push_validator import validate_mist_manifest

        result = validate_mist_manifest({"app.py": "sha256:aaa"})
        assert result.valid
        assert result.warnings == []

    def test_mix_valid_and_unknown_ext(self) -> None:
        """Known + unknown extension → valid, one warning for the unknown."""
        from musehub.services.musehub_mist_push_validator import validate_mist_manifest

        result = validate_mist_manifest({
            "main.py": "sha256:aaa",
            "data.unknown_ext": "sha256:bbb",
        })
        assert result.valid
        assert result.errors == []
        assert len(result.warnings) == 1


# ---------------------------------------------------------------------------
# 5. Wire integration: mist-domain push with bad filename → 422
# ---------------------------------------------------------------------------

class TestWirePushMistValidation:
    """Verify the wire push stream rejects bad mist filenames end-to-end.

    These tests call the wire service function directly rather than the HTTP
    handler to avoid the full push protocol overhead while still exercising
    the validation gate at its insertion point.
    """

    @pytest.mark.asyncio
    async def test_validate_manifest_called_for_mist_domain(
        self, db_session, test_user
    ) -> None:
        """wire_push_stream runs MistPushValidator for mist-domain repos."""
        from musehub.services.musehub_mist_push_validator import (
            validate_mist_manifest,
            MistValidationResult,
        )
        # The validator must be importable and the wire module must import it
        # for mist repos (tested via module-level import resolution).
        import musehub.services.musehub_wire as _wire
        src = open(_wire.__file__).read()
        assert "musehub_mist_push_validator" in src or "validate_mist_manifest" in src, (
            "musehub_wire.py must import and call the mist push validator"
        )

    @pytest.mark.asyncio
    async def test_domain_non_mist_skips_validator(self) -> None:
        """validate_mist_manifest is NOT called for non-mist repos (no false rejections)."""
        from musehub.services.musehub_mist_push_validator import validate_mist_manifest

        # A code-domain manifest with path-like keys is fine for a code repo —
        # but the validator function itself would reject them. The wire layer
        # must only invoke the validator for domain_id="mist".
        # We validate this by checking the function signature/module:
        import inspect
        sig = inspect.signature(validate_mist_manifest)
        params = list(sig.parameters.keys())
        assert "manifest" in params, "validate_mist_manifest must accept 'manifest' kwarg"