"""Tests for checklist 2.1 — URL segment validation.

Covers:
- Unit tests for _SLUG_RE regex (owner/repo slugs)
- Unit tests for _BRANCH_RE regex (branch names)
- Integration tests verifying FastAPI enforces the patterns via 422
"""
from __future__ import annotations

import re

import pytest
from httpx import AsyncClient

from musehub.api.validation import _SLUG_RE, _BRANCH_RE, _FILE_PATH_RE


# ---------------------------------------------------------------------------
# Unit tests — _SLUG_RE
# ---------------------------------------------------------------------------

class TestSlugRegexRejects:
    """Characters and patterns that must be blocked by _SLUG_RE."""

    def test_rejects_dotdot(self) -> None:
        assert re.fullmatch(_SLUG_RE, "..") is None

    def test_rejects_traversal_path(self) -> None:
        assert re.fullmatch(_SLUG_RE, "../../etc/passwd") is None

    def test_rejects_null_byte(self) -> None:
        assert re.fullmatch(_SLUG_RE, "null\x00byte") is None

    def test_rejects_script_tag(self) -> None:
        assert re.fullmatch(_SLUG_RE, "<script>") is None

    def test_rejects_path_with_dotdot_component(self) -> None:
        # Slashes are not in the slug charset at all
        assert re.fullmatch(_SLUG_RE, "a/../b") is None

    def test_rejects_empty_string(self) -> None:
        assert re.fullmatch(_SLUG_RE, "") is None

    def test_rejects_101_char_string(self) -> None:
        # Pattern allows [a-zA-Z0-9][a-zA-Z0-9_.-]{0,99} — 101 chars total is too long
        long_slug = "a" * 101
        assert re.fullmatch(_SLUG_RE, long_slug) is None

    def test_rejects_leading_dot(self) -> None:
        # Dot-files / hidden names must start with alphanumeric
        assert re.fullmatch(_SLUG_RE, ".hidden") is None

    def test_rejects_leading_hyphen(self) -> None:
        assert re.fullmatch(_SLUG_RE, "-bad-start") is None

    def test_rejects_slash_in_slug(self) -> None:
        # Slashes are not permitted in slugs (only in branch names)
        assert re.fullmatch(_SLUG_RE, "owner/repo") is None

    def test_rejects_at_sign(self) -> None:
        assert re.fullmatch(_SLUG_RE, "@user") is None

    def test_rejects_space(self) -> None:
        assert re.fullmatch(_SLUG_RE, "my repo") is None


class TestSlugRegexAccepts:
    """Values that _SLUG_RE must accept."""

    def test_accepts_simple_name(self) -> None:
        assert re.fullmatch(_SLUG_RE, "valid-name-123") is not None

    def test_accepts_plain_username(self) -> None:
        assert re.fullmatch(_SLUG_RE, "gabriel") is not None

    def test_accepts_name_with_dot_and_underscore(self) -> None:
        assert re.fullmatch(_SLUG_RE, "my.repo_name") is not None

    def test_accepts_single_char(self) -> None:
        assert re.fullmatch(_SLUG_RE, "a") is not None

    def test_accepts_exactly_100_chars(self) -> None:
        # 100-char string: one leading alphanum + 99 more alphanums
        slug = "a" * 100
        assert re.fullmatch(_SLUG_RE, slug) is not None

    def test_accepts_numeric_start(self) -> None:
        assert re.fullmatch(_SLUG_RE, "1repo") is not None

    def test_accepts_uppercase(self) -> None:
        assert re.fullmatch(_SLUG_RE, "MyRepo") is not None


# ---------------------------------------------------------------------------
# Unit tests — _BRANCH_RE
# ---------------------------------------------------------------------------

class TestBranchRegexRejects:
    """Characters and patterns that must be blocked by _BRANCH_RE."""

    def test_rejects_dotdot_traversal_component(self) -> None:
        # "feat/../main" — the ".." component starts with "." not [a-zA-Z0-9_]
        assert re.fullmatch(_BRANCH_RE, "feat/../main") is None

    def test_rejects_leading_dot(self) -> None:
        assert re.fullmatch(_BRANCH_RE, ".hidden") is None

    def test_rejects_single_dot_component(self) -> None:
        # "feat/./foo" — the "." component is not valid
        assert re.fullmatch(_BRANCH_RE, "feat/./foo") is None

    def test_rejects_empty_string(self) -> None:
        assert re.fullmatch(_BRANCH_RE, "") is None

    def test_rejects_dotdot_standalone(self) -> None:
        assert re.fullmatch(_BRANCH_RE, "..") is None

    def test_rejects_leading_hyphen(self) -> None:
        assert re.fullmatch(_BRANCH_RE, "-bad") is None

    def test_rejects_trailing_slash(self) -> None:
        assert re.fullmatch(_BRANCH_RE, "feat/") is None

    def test_rejects_double_slash(self) -> None:
        assert re.fullmatch(_BRANCH_RE, "feat//foo") is None


class TestBranchRegexAccepts:
    """Values that _BRANCH_RE must accept."""

    def test_accepts_main(self) -> None:
        assert re.fullmatch(_BRANCH_RE, "main") is not None

    def test_accepts_namespaced_feature(self) -> None:
        assert re.fullmatch(_BRANCH_RE, "feat/my-feature") is not None

    def test_accepts_dev(self) -> None:
        assert re.fullmatch(_BRANCH_RE, "dev") is not None

    def test_accepts_deep_namespace(self) -> None:
        assert re.fullmatch(_BRANCH_RE, "feat/scope/my_feature") is not None

    def test_accepts_underscore_start(self) -> None:
        assert re.fullmatch(_BRANCH_RE, "_internal") is not None

    def test_accepts_numeric_start(self) -> None:
        assert re.fullmatch(_BRANCH_RE, "1fix") is not None

    def test_accepts_hotfix_namespace(self) -> None:
        assert re.fullmatch(_BRANCH_RE, "hotfix/urgent-patch-1.2.3") is not None


# ---------------------------------------------------------------------------
# Unit tests — _FILE_PATH_RE (bonus: covers the same structural invariants)
# ---------------------------------------------------------------------------

class TestFilePathRegex:
    """Structural sanity checks for _FILE_PATH_RE."""

    def test_rejects_dotdot_component(self) -> None:
        assert re.fullmatch(_FILE_PATH_RE, "src/../etc/passwd") is None

    def test_rejects_dotdot_standalone(self) -> None:
        assert re.fullmatch(_FILE_PATH_RE, "..") is None

    def test_rejects_dotdot_segment(self) -> None:
        assert re.fullmatch(_FILE_PATH_RE, "src/../etc/passwd") is None

    def test_rejects_dotdot_leading_segment(self) -> None:
        assert re.fullmatch(_FILE_PATH_RE, "../etc/passwd") is None

    def test_rejects_bare_dot(self) -> None:
        assert re.fullmatch(_FILE_PATH_RE, ".") is None

    def test_accepts_dotfile_root(self) -> None:
        assert re.fullmatch(_FILE_PATH_RE, ".museignore") is not None

    def test_accepts_dotfile_nested(self) -> None:
        assert re.fullmatch(_FILE_PATH_RE, "config/.museattributes") is not None

    def test_accepts_dotfile_muse_internal(self) -> None:
        assert re.fullmatch(_FILE_PATH_RE, ".muse/code_config.toml") is not None

    def test_accepts_simple_file(self) -> None:
        assert re.fullmatch(_FILE_PATH_RE, "README") is not None

    def test_accepts_nested_path(self) -> None:
        assert re.fullmatch(_FILE_PATH_RE, "src/main.py") is not None

    def test_accepts_deep_path(self) -> None:
        assert re.fullmatch(_FILE_PATH_RE, "musehub/api/routes/wire.py") is not None


# ---------------------------------------------------------------------------
# Integration tests — FastAPI enforces SlugParam / BranchParam at 422
# ---------------------------------------------------------------------------

async def test_dotdot_owner_returns_422(client: AsyncClient) -> None:
    """Path segment '..' must be rejected by FastAPI validation (422)."""
    response = await client.get("/..%2F../refs")
    assert response.status_code in {400, 404, 422}


async def test_valid_slug_does_not_return_422_on_validation(client: AsyncClient) -> None:
    """A syntactically valid slug should not be rejected with 422.

    The repo may not exist (404) but the slug itself must pass validation.
    """
    response = await client.get("/gabriel/valid-repo/refs")
    # 422 means the slug was rejected — we must NOT see that
    assert response.status_code != 422


async def test_url_encoded_slash_in_owner_returns_4xx(client: AsyncClient) -> None:
    """A URL-encoded slash in the owner segment should be blocked.

    FastAPI decodes %2F before routing, making 'gabriel%2Fetc' become two
    path segments ('gabriel' and 'etc/passwd/refs') which won't match the
    route pattern — yielding 404 or 422, never 200.
    """
    response = await client.get("/gabriel%2Fetc/passwd/refs")
    assert response.status_code in {400, 404, 422}


async def test_null_byte_in_owner_returns_4xx(client: AsyncClient) -> None:
    """Null byte encoded as %00 in owner must be blocked."""
    response = await client.get("/owner%00name/repo/refs")
    assert response.status_code in {400, 404, 422}


async def test_script_tag_in_owner_returns_4xx(client: AsyncClient) -> None:
    """HTML/script characters in owner slug must be blocked."""
    response = await client.get("/%3Cscript%3E/repo/refs")
    assert response.status_code in {400, 404, 422}


async def test_dot_only_owner_returns_422(client: AsyncClient) -> None:
    """Single dot as owner must fail slug validation."""
    response = await client.get("/./repo/refs")
    assert response.status_code in {400, 404, 422}