from __future__ import annotations

import pytest

from mdpolish import ModifierContractError, Pipeline, RunStatus
from mdpolish.modifiers import mapped_line_join

MAPPINGS = (
    ("exam-", "ple", "example"),
    ("rule-", "based", "rule-based"),
    ("value.", "ues", "values"),
)


def transform(markdown: str):  # type: ignore[no-untyped-def]
    return Pipeline([mapped_line_join(MAPPINGS)]).transform(markdown)


@pytest.mark.parametrize(
    ("markdown", "expected"),
    [
        ("an exam-\nple here", "an example here"),
        ("an exam-\n\nple here", "an example here"),
        ("a rule-\nbased method", "a rule-based method"),
        ("the value.\n\nues differ", "the values differ"),
        ("an exam-\r\n\r\nple here", "an example here"),
        ("an exam-\r\rple here", "an example here"),
    ],
)
def test_applies_exact_mapping_across_supported_line_shapes(markdown: str, expected: str) -> None:
    result = transform(markdown)
    assert result.status is RunStatus.SUCCESS
    assert result.output_markdown == expected
    assert len(result.changes) == 1


@pytest.mark.parametrize(
    "markdown",
    [
        "an unknown-\nword here",
        "an exam-\n\n\nple here",
        "an exam-\r\n\nple here",
        "an EXAM-\nple here",
        "an exam-\nplemore here",
        "an xrule-\nbased method",
    ],
)
def test_unknown_or_unsafe_boundaries_are_preserved(markdown: str) -> None:
    assert transform(markdown).output_markdown == markdown


def test_parameters_and_results_are_independent_of_mapping_order() -> None:
    first = mapped_line_join(MAPPINGS)
    second = mapped_line_join(reversed(MAPPINGS))
    markdown = "example becomes exam-\nple"

    first_result = Pipeline([first]).transform(markdown)
    second_result = Pipeline([second]).transform(markdown)

    assert first_result.modifiers == second_result.modifiers
    assert first_result.output_markdown == second_result.output_markdown


def test_library_contains_no_default_mapping() -> None:
    modifier = mapped_line_join(())
    result = Pipeline([modifier]).transform("an exam-\nple here")

    assert modifier.parameters == (("mappings", ()),)
    assert result.output_markdown == "an exam-\nple here"


@pytest.mark.parametrize(
    "mappings",
    [
        (("", "right", "word"),),
        (("left", "right", "two words"),),
        (("left", "right", "word"), ("left", "right", "other")),
        (("left", "right"),),
    ],
)
def test_invalid_mappings_raise_contract_error(mappings: object) -> None:
    with pytest.raises(ModifierContractError):
        mapped_line_join(mappings)  # type: ignore[arg-type]


def test_successful_output_is_idempotent() -> None:
    pipeline = Pipeline([mapped_line_join(MAPPINGS)])
    first = pipeline.transform("an exam-\n\nple here")
    assert first.output_markdown is not None
    assert pipeline.transform(first.output_markdown).changes == ()