"""Tests for tool name validation utilities (SEP-986)."""

import logging

import pytest

from mcp.shared.tool_name_validation import (
    issue_tool_name_warning,
    validate_and_warn_tool_name,
    validate_tool_name,
)

# Tests for validate_tool_name function - valid names


@pytest.mark.parametrize(
    "tool_name",
    [
        "getUser",
        "get_user_profile",
        "user-profile-update",
        "admin.tools.list",
        "DATA_EXPORT_v2.1",
        "a",
        "a" * 128,
    ],
    ids=[
        "simple_alphanumeric",
        "with_underscores",
        "with_dashes",
        "with_dots",
        "mixed_characters",
        "single_character",
        "max_length_128",
    ],
)
def test_validate_tool_name_accepts_valid_names(tool_name: str) -> None:
    """Valid tool names should pass validation with no warnings."""
    result = validate_tool_name(tool_name)
    assert result.is_valid is True
    assert result.warnings == []


# Tests for validate_tool_name function - invalid names


def test_validate_tool_name_rejects_empty_name() -> None:
    """Empty names should be rejected."""
    result = validate_tool_name("")
    assert result.is_valid is False
    assert "Tool name cannot be empty" in result.warnings


def test_validate_tool_name_rejects_name_exceeding_max_length() -> None:
    """Names exceeding 128 characters should be rejected."""
    result = validate_tool_name("a" * 129)
    assert result.is_valid is False
    assert any("exceeds maximum length of 128 characters (current: 129)" in w for w in result.warnings)


@pytest.mark.parametrize(
    "tool_name,expected_char",
    [
        ("get user profile", "' '"),
        ("get,user,profile", "','"),
        ("user/profile/update", "'/'"),
        ("user@domain.com", "'@'"),
        # a single trailing newline slipped past `$` with re.match
        ("valid_name\n", "'\\n'"),
        ("a" * 127 + "\n", "'\\n'"),
    ],
    ids=[
        "with_spaces",
        "with_commas",
        "with_slashes",
        "with_at_symbol",
        "with_trailing_newline",
        "max_length_with_trailing_newline",
    ],
)
def test_validate_tool_name_rejects_invalid_characters(tool_name: str, expected_char: str) -> None:
    """Names with invalid characters should be rejected."""
    result = validate_tool_name(tool_name)
    assert result.is_valid is False
    assert any("invalid characters" in w and expected_char in w for w in result.warnings)


def test_validate_tool_name_rejects_multiple_invalid_chars() -> None:
    """Names with multiple invalid chars should list all of them."""
    result = validate_tool_name("user name@domain,com")
    assert result.is_valid is False
    warning = next(w for w in result.warnings if "invalid characters" in w)
    assert "' '" in warning
    assert "'@'" in warning
    assert "','" in warning


def test_validate_tool_name_rejects_unicode_characters() -> None:
    """Names with unicode characters should be rejected."""
    result = validate_tool_name("user-\u00f1ame")  # n with tilde
    assert result.is_valid is False


# Tests for validate_tool_name function - warnings for problematic patterns


def test_validate_tool_name_warns_on_leading_dash() -> None:
    """Names starting with dash should generate warning but be valid."""
    result = validate_tool_name("-get-user")
    assert result.is_valid is True
    assert any("starts or ends with a dash" in w for w in result.warnings)


def test_validate_tool_name_warns_on_trailing_dash() -> None:
    """Names ending with dash should generate warning but be valid."""
    result = validate_tool_name("get-user-")
    assert result.is_valid is True
    assert any("starts or ends with a dash" in w for w in result.warnings)


def test_validate_tool_name_warns_on_leading_dot() -> None:
    """Names starting with dot should generate warning but be valid."""
    result = validate_tool_name(".get.user")
    assert result.is_valid is True
    assert any("starts or ends with a dot" in w for w in result.warnings)


def test_validate_tool_name_warns_on_trailing_dot() -> None:
    """Names ending with dot should generate warning but be valid."""
    result = validate_tool_name("get.user.")
    assert result.is_valid is True
    assert any("starts or ends with a dot" in w for w in result.warnings)


# Tests for issue_tool_name_warning function


def test_issue_tool_name_warning_logs_warnings(caplog: pytest.LogCaptureFixture) -> None:
    """Warnings should be logged at WARNING level."""
    warnings = ["Warning 1", "Warning 2"]
    with caplog.at_level(logging.WARNING):
        issue_tool_name_warning("test-tool", warnings)

    assert 'Tool name validation warning for "test-tool"' in caplog.text
    assert "- Warning 1" in caplog.text
    assert "- Warning 2" in caplog.text
    assert "Tool registration will proceed" in caplog.text
    assert "SEP-986" in caplog.text


def test_issue_tool_name_warning_no_logging_for_empty_warnings(caplog: pytest.LogCaptureFixture) -> None:
    """Empty warnings list should not produce any log output."""
    with caplog.at_level(logging.WARNING):
        issue_tool_name_warning("test-tool", [])

    assert caplog.text == ""


# Tests for validate_and_warn_tool_name function


def test_validate_and_warn_tool_name_returns_true_for_valid_name() -> None:
    """Valid names should return True."""
    assert validate_and_warn_tool_name("valid-tool-name") is True


def test_validate_and_warn_tool_name_returns_false_for_invalid_name() -> None:
    """Invalid names should return False."""
    assert validate_and_warn_tool_name("") is False
    assert validate_and_warn_tool_name("a" * 129) is False
    assert validate_and_warn_tool_name("invalid name") is False


def test_validate_and_warn_tool_name_logs_warnings_for_invalid_name(caplog: pytest.LogCaptureFixture) -> None:
    """Invalid names should trigger warning logs."""
    with caplog.at_level(logging.WARNING):
        validate_and_warn_tool_name("invalid name")

    assert "Tool name validation warning" in caplog.text


def test_validate_and_warn_tool_name_no_warnings_for_clean_valid_name(caplog: pytest.LogCaptureFixture) -> None:
    """Clean valid names should not produce any log output."""
    with caplog.at_level(logging.WARNING):
        result = validate_and_warn_tool_name("clean-tool-name")

    assert result is True
    assert caplog.text == ""


# Tests for edge cases


@pytest.mark.parametrize(
    "tool_name,is_valid,expected_warning_fragment",
    [
        ("...", True, "starts or ends with a dot"),
        ("---", True, "starts or ends with a dash"),
        ("///", False, "invalid characters"),
        ("user@name123", False, "invalid characters"),
    ],
    ids=[
        "only_dots",
        "only_dashes",
        "only_slashes",
        "mixed_valid_invalid",
    ],
)
def test_edge_cases(tool_name: str, is_valid: bool, expected_warning_fragment: str) -> None:
    """Various edge cases should be handled correctly."""
    result = validate_tool_name(tool_name)
    assert result.is_valid is is_valid
    assert any(expected_warning_fragment in w for w in result.warnings)