"""Conservative correction of escape drift before shared fuzzy matching.

Corrections require the corrected ``old_string`` to appear verbatim in the file.
That evidence cannot establish the intended escaping of newly added code: deliberate
double backslashes look the same as a serialization artifact. Backslash correction
therefore halves only ``old_string`` and requires a backslash-free ``new_string``.
An otherwise verified doubled anchor with replacement backslashes raises an explicit
error; callers must reject it before fuzzy matching can apply the ambiguous text.

Quote correction retains its separate consistency checks. Successful corrections
return a note for the tool result; already-exact anchors are left unchanged.
"""

from __future__ import annotations

import re
from typing import Optional

_BACKSLASH_RUN_RE = re.compile(r"\\+")


class AmbiguousEscapeDriftError(ValueError):
    """The replacement's intentional backslashes cannot be distinguished from drift."""


def _halve_backslash_runs(s: str) -> str:
    """Replace every maximal run of backslashes with half its length."""
    return _BACKSLASH_RUN_RE.sub(lambda m: "\\" * (len(m.group(0)) // 2), s)


def _all_backslash_runs_even(s: str) -> bool:
    return all(len(run) % 2 == 0 for run in _BACKSLASH_RUN_RE.findall(s))


def maybe_correct_backslash_doubling(old_string: str, new_string: str, content: str) -> tuple[str, str]:
    """Halve a verified doubled anchor only when the replacement has no backslashes.

    Every old_string run must be even and its halved form must occur in the file.
    Replacement backslashes are ambiguous regardless of run length, so raise
    ``AmbiguousEscapeDriftError`` rather than let fuzzy matching apply them.
    """
    if "\\" not in old_string or old_string in content:
        return old_string, new_string
    if not _all_backslash_runs_even(old_string):
        return old_string, new_string

    halved_old = _halve_backslash_runs(old_string)
    if halved_old not in content:
        return old_string, new_string

    if "\\" in new_string:
        raise AmbiguousEscapeDriftError(
            "Escape-drift detected: halving old_string's backslashes matches the file, "
            "but correcting new_string could remove intentional backslashes. "
            "Re-read the file and resend old_string/new_string with their intended escaping."
        )
    return halved_old, new_string


_QUOTE_WITH_BACKSLASHES_RE = {q: re.compile(r"(\\*)" + q) for q in ("'", '"')}


def _strip_spurious_quote_escapes(s: str) -> str:
    """Un-escape a spurious backslash before a quote character: ``\\'`` -> ``'``, ``\\"`` -> ``"``."""
    return s.replace("\\'", "'").replace('\\"', '"')


def _quote_escapes_all_spurious(*strings: str) -> bool:
    """True when every escaped quote in ``strings`` is attributable to the wire artifact.

    The artifact escapes quotes mechanically, so a quote kind it touched is escaped at EVERY
    occurrence across the whole call, by exactly one backslash. A backslash the model meant
    (``"say \\"hi\\""`` in new code) went through the same extra escape and therefore arrives
    as two or more backslashes before the quote, never one. So for each kind that appears as
    ``\\q`` anywhere: every ``q`` in every string must be preceded by exactly one backslash.
    A bare ``q`` beside a ``\\q`` (the kind was not drifted, so the ``\\q`` is real) or a longer
    run (an intended escape) cannot be told apart from the artifact, so it refuses.
    """
    for quote, pattern in _QUOTE_WITH_BACKSLASHES_RE.items():
        if not any("\\" + quote in s for s in strings):
            continue
        if any(len(m.group(1)) != 1 for s in strings for m in pattern.finditer(s)):
            return False
    return True


def maybe_correct_quote_escaping(old_string: str, new_string: str, content: str) -> tuple[str, str]:
    """Return a corrected ``(old_string, new_string)`` if a spurious backslash-before-quote wire
    artifact is detected AND verified against the file's actual content; otherwise unchanged.

    Mirrors ``_detect_escape_drift``'s quote-suspect check: ``\\'`` or ``\\"`` present in BOTH
    old_string and new_string is the signature of an apostrophe/quote that picked up a spurious
    backslash in transit, not a literal escape the model intended. The stripped old_string must
    appear verbatim in content, which verifies old_string (and rules out a file that really
    contains ``\\'``/``\\"``). new_string's added code is not in the file, so it is only
    stripped when ``_quote_escapes_all_spurious`` holds for the whole call; otherwise the call
    is left unchanged for the existing reject-and-ask guard. Raises ``AmbiguousEscapeDriftError``
    when new_string escapes a quote kind that old_string does not.
    """
    has_quote_suspect = (
        ("\\'" in old_string and "\\'" in new_string)
        or ('\\"' in old_string and '\\"' in new_string)
    )
    if not has_quote_suspect or old_string in content:
        return old_string, new_string
    if not _quote_escapes_all_spurious(old_string, new_string):
        return old_string, new_string

    stripped_old = _strip_spurious_quote_escapes(old_string)
    if stripped_old not in content:
        return old_string, new_string
    # Only old_string is checked against the file, so only the quote kinds it escapes are
    # proven drift. A kind escaped only in new_string may be an escape the model meant.
    unproven = [q for q in ("'", '"') if "\\" + q in new_string and "\\" + q not in old_string]
    if unproven:
        shown = " and ".join("\\" + q for q in unproven)
        raise AmbiguousEscapeDriftError(
            "Escape-drift detected: removing the spurious quote escapes in old_string matches "
            f"the file, but new_string also contains {shown}, which old_string gives no evidence "
            "for. Re-read the file and resend old_string/new_string with their intended escaping."
        )

    return stripped_old, _strip_spurious_quote_escapes(new_string)


def maybe_correct_escape_drift(old_string: str, new_string: str, content: str) -> tuple[str, str, Optional[str]]:
    """Apply whichever escape-drift auto-correction (if any) is verified against the file's
    actual content and report which one fired.

    Tries quote escaping, then backslash correction of the anchor only. Raises
    ``AmbiguousEscapeDriftError`` for a verified doubled anchor whose replacement
    contains backslashes, or a verified quote correction whose replacement escapes a
    quote kind the anchor does not; the caller must return an error without matching.

    Returns ``(corrected_old, corrected_new, note)``: ``note`` is a human-readable description
    of the correction that was applied, or ``None`` if neither fired. The caller attaches
    ``note`` to the successful result (e.g. ``PatchResult.note``) so a corrected call stays
    distinguishable from one whose arguments never needed correction.
    """
    corrected_old, corrected_new = maybe_correct_quote_escaping(old_string, new_string, content)
    if corrected_old != old_string:
        return corrected_old, corrected_new, (
            "escape-drift auto-corrected: stripped a spurious backslash before a quote/apostrophe "
            "in old_string/new_string (a JSON-double-escaping wire artifact) before matching."
        )

    corrected_old, corrected_new = maybe_correct_backslash_doubling(old_string, new_string, content)
    if corrected_old != old_string:
        return corrected_old, corrected_new, (
            "escape-drift auto-corrected: halved doubled backslash runs in old_string "
            "before matching; new_string has no backslashes and was left unchanged."
        )

    return old_string, new_string, None