"""Tests for script_apply_edits.py local helper functions.

Focuses on _apply_edits_locally, _find_best_closing_brace_match,
and _is_in_string_context — especially around C# string variants
(verbatim, interpolated, raw) that can fool brace/anchor matching.
"""
import re
import pytest

from services.tools.script_apply_edits import (
    _apply_edits_locally,
    _find_best_closing_brace_match,
    _find_best_anchor_match,
    _is_in_string_context,
)


# ── _is_in_string_context ────────────────────────────────────────────

class TestIsInStringContext:
    def test_plain_code_not_in_string(self):
        text = 'int x = 42;'
        assert not _is_in_string_context(text, 4)

    def test_inside_regular_string(self):
        text = 'string s = "hello world";'
        # Position inside "hello world"
        pos = text.index("hello")
        assert _is_in_string_context(text, pos)

    def test_inside_verbatim_string(self):
        text = 'string s = @"C:\\Users\\file";'
        pos = text.index("C:")
        assert _is_in_string_context(text, pos)

    def test_inside_interpolated_string(self):
        text = 'string s = $"Value: {x}";'
        # The "Value" part is inside the string
        pos = text.index("Value")
        assert _is_in_string_context(text, pos)

    def test_interpolation_hole_is_not_string(self):
        text = 'string s = $"Value: {x}";'
        # The x inside {x} is in an interpolation hole — it's code, not string
        brace_pos = text.index("{x}") + 1  # the 'x'
        assert not _is_in_string_context(text, brace_pos)

    def test_inside_single_line_comment(self):
        text = 'int x = 1; // this is a comment'
        pos = text.index("this")
        assert _is_in_string_context(text, pos)

    def test_inside_multi_line_comment(self):
        text = 'int x = 1; /* block { } */ int y = 2;'
        pos = text.index("block")
        assert _is_in_string_context(text, pos)

    def test_after_comment_is_code(self):
        text = '// comment\nint x = 1;'
        pos = text.index("int")
        assert not _is_in_string_context(text, pos)

    def test_verbatim_string_doubled_quotes(self):
        text = 'string s = @"He said ""hello""";'
        # The whole thing is one string ending at the final ";
        pos = text.index("hello")
        assert _is_in_string_context(text, pos)

    def test_interpolated_verbatim_combined(self):
        text = 'string s = $@"Path: {dir}\\file";'
        # "Path" is inside the string
        pos = text.index("Path")
        assert _is_in_string_context(text, pos)

    def test_raw_string_literal(self):
        text = 'string s = """\n{ }\n""";'
        pos = text.index("{ }")
        assert _is_in_string_context(text, pos)

    def test_interpolated_raw_string_content(self):
        text = 'string s = $"""\n    Hello {name}\n    """;'
        # "Hello" is string content (non-code)
        pos = text.index("Hello")
        assert _is_in_string_context(text, pos)

    def test_interpolated_raw_string_hole_is_code(self):
        text = 'string s = $"""\n    Hello {name}\n    """;'
        # "name" inside {name} is in an interpolation hole — code
        pos = text.index("name")
        assert not _is_in_string_context(text, pos)

    def test_multi_dollar_raw_string_content(self):
        text = 'string s = $$"""\n    {literal} {{interp}}\n    """;'
        # {literal} has only 1 brace — it's literal string content
        pos = text.index("literal")
        assert _is_in_string_context(text, pos)

    def test_multi_dollar_raw_string_hole_is_code(self):
        text = 'string s = $$"""\n    {literal} {{interp}}\n    """;'
        # {{interp}} has 2 braces matching $$ — it's an interpolation hole
        pos = text.index("interp")
        assert not _is_in_string_context(text, pos)

    def test_interpolated_raw_string_closing(self):
        text = 'string s = $"""\n    body\n    """; int x = 1;'
        # "x" after the closing """ is code
        pos = text.index("x = 1")
        assert not _is_in_string_context(text, pos)


# ── _find_best_closing_brace_match ───────────────────────────────────

class TestFindBestClosingBraceMatch:
    def test_skips_braces_in_interpolated_strings(self):
        """Braces inside $"...{x}..." should not be scored as class-end."""
        code = (
            'public class Foo {\n'
            '    void M() {\n'
            '        string s = $"Score: {score}";\n'
            '    }\n'
            '}\n'
        )
        pattern = r'^\s*}\s*$'
        matches = list(re.finditer(pattern, code, re.MULTILINE))
        # There should be matches for the method close and class close
        assert len(matches) >= 1
        best = _find_best_closing_brace_match(matches, code)
        # The best match should be the class-closing brace, not one inside a string
        assert best is not None
        line_num = code[:best.start()].count('\n')
        # Class close is the last "}" line
        assert line_num == 4  # 0-indexed, line 5 is "}"

    def test_skips_braces_in_verbatim_strings(self):
        """@"{ }" should not confuse the scorer."""
        code = (
            'public class Foo {\n'
            '    string s = @"{ }";\n'
            '}\n'
        )
        pattern = r'^\s*}\s*$'
        matches = list(re.finditer(pattern, code, re.MULTILINE))
        best = _find_best_closing_brace_match(matches, code)
        assert best is not None

    def test_prefers_class_brace_over_method_brace(self):
        """Should pick class-closing } (depth 1) over method-closing } (depth 2)."""
        code = (
            'public class Foo : MonoBehaviour\n'
            '{\n'
            '    private int score = 42;\n'
            '\n'
            '    void Start()\n'
            '    {\n'
            '        Debug.Log($"Score: {score}");\n'
            '    }\n'
            '\n'
            '    void OnGUI()\n'
            '    {\n'
            '        GUI.Label(new Rect(10, 10, 200, 20), $"Score: {score}");\n'
            '    }\n'
            '}\n'
        )
        pattern = r'^\s*}\s*$'
        matches = list(re.finditer(pattern, code, re.MULTILINE))
        # Should have 3 matches: Start close, OnGUI close, class close
        assert len(matches) == 3
        best = _find_best_closing_brace_match(matches, code)
        assert best is not None
        best_line = code[:best.start()].count('\n')
        # Class close is the last "}" — line 13 (0-indexed)
        assert best_line == 13

    def test_skips_braces_in_interpolated_raw_strings(self):
        """$\"\"\"{x}\"\"\" braces should not confuse the scorer."""
        code = (
            'public class Foo {\n'
            '    string s = $"""\n'
            '        { literal }\n'
            '        {interp}\n'
            '        """;\n'
            '}\n'
        )
        pattern = r'^\s*}\s*$'
        matches = list(re.finditer(pattern, code, re.MULTILINE))
        best = _find_best_closing_brace_match(matches, code)
        assert best is not None
        best_line = code[:best.start()].count('\n')
        assert best_line == 5  # class-closing brace

    def test_closing_brace_scorer_with_interpolated_code(self):
        """Realistic C# with multiple $"" strings should still find class-end."""
        code = (
            'using UnityEngine;\n'
            'public class HUD : MonoBehaviour {\n'
            '    void OnGUI() {\n'
            '        Debug.Log($"Score: {score}");\n'
            '        Debug.Log($@"Path: {path}\\save");\n'
            '    }\n'
            '}\n'
        )
        pattern = r'^\s*}\s*$'
        matches = list(re.finditer(pattern, code, re.MULTILINE))
        best = _find_best_closing_brace_match(matches, code)
        assert best is not None
        # Should pick the class-closing brace (last one)
        best_line = code[:best.start()].count('\n')
        assert best_line == 6  # 0-indexed


# ── _apply_edits_locally regression guards ───────────────────────────

class TestApplyEditsLocally:
    @pytest.mark.asyncio
    async def test_replace_range_basic(self):
        original = "line1\nline2\nline3\n"
        edits = [{
            "op": "replace_range",
            "startLine": 2,
            "startCol": 1,
            "endLine": 2,
            "endCol": 6,
            "text": "REPLACED",
        }]
        result = await _apply_edits_locally(original, edits)
        assert "REPLACED" in result
        assert "line1" in result
        assert "line3" in result

    @pytest.mark.asyncio
    async def test_prepend_and_append(self):
        original = "middle\n"
        edits = [
            {"op": "prepend", "text": "top\n"},
            {"op": "append", "text": "bottom\n"},
        ]
        result = await _apply_edits_locally(original, edits)
        assert result.startswith("top\n")
        assert "bottom" in result

    @pytest.mark.asyncio
    async def test_regex_replace_near_interpolated_strings(self):
        """regex_replace should work even when interpolated strings are in the code."""
        original = (
            'void M() {\n'
            '    Debug.Log($"x={x}");\n'
            '    int OLD = 1;\n'
            '}\n'
        )
        edits = [{
            "op": "regex_replace",
            "pattern": r"OLD",
            "replacement": "NEW",
            "text": "NEW",
        }]
        result = await _apply_edits_locally(original, edits)
        assert "NEW" in result
        assert "OLD" not in result


# ── _find_best_anchor_match with string-aware filtering ──────────────

class TestAnchorMatchFiltering:
    def test_anchor_skips_braces_in_interpolated_strings(self):
        """$"...{x}..." brace should not be picked as anchor match."""
        code = (
            'class Foo {\n'
            '    string s = $"val: {x}";\n'
            '    void M() { }\n'
            '}\n'
        )
        # Pattern looking for closing brace at end of line
        pattern = r'^\s*}\s*$'
        flags = re.MULTILINE
        match = _find_best_anchor_match(pattern, code, flags, prefer_last=True)
        assert match is not None
        # Should match the class-closing brace, not anything inside the string
        best_line = code[:match.start()].count('\n')
        assert best_line == 3  # 0-indexed, class close

    def test_anchor_skips_braces_in_verbatim_strings(self):
        """@"{ }" should not confuse anchor matching."""
        code = (
            'class Foo {\n'
            '    string s = @"{ }";\n'
            '}\n'
        )
        pattern = r'^\s*}\s*$'
        flags = re.MULTILINE
        match = _find_best_anchor_match(pattern, code, flags, prefer_last=True)
        assert match is not None