"""Edge-case tests for json_utils — cleaning pipelines, bracket extraction, and type coercion."""


class TestEllipsisCleanup:
    """Tests for ellipsis removal in _clean_llm_json_artifacts."""

    def test_ellipsis_between_elements_eats_both_commas(self):
        """Regex removes ellipsis AND surrounding commas, potentially producing invalid JSON.

        The pattern `r',?\\s*"?\\.\\.\\.+"?\\s*,?'` consumes both the leading
        and trailing comma for input like `[1, ..., 2]`, producing `[1 2]`
        which is not valid JSON.  This test documents that behaviour.
        """
        from local_deep_research.utilities.json_utils import (
            _clean_llm_json_artifacts,
        )

        cleaned = _clean_llm_json_artifacts("[1, ..., 2]")
        # Both commas are consumed — the result lacks a separator between 1 and 2
        assert "..." not in cleaned
        # Document that the cleaned output cannot be parsed directly
        import json

        try:
            json.loads(cleaned)
            # If it parses, great — the regex was improved
        except json.JSONDecodeError:
            # Expected: cleaning produces `[1 2]` which isn't valid JSON
            pass

    def test_ellipsis_as_only_element(self):
        """[...] should yield [] after cleanup."""
        from local_deep_research.utilities.json_utils import (
            _clean_llm_json_artifacts,
        )

        cleaned = _clean_llm_json_artifacts("[...]")
        assert "..." not in cleaned
        # After removing ellipsis, should be parseable as empty list
        import json

        result = json.loads(cleaned)
        assert result == []

    def test_multiple_ellipses_in_array(self):
        """Multiple ellipsis entries are all removed."""
        from local_deep_research.utilities.json_utils import (
            _clean_llm_json_artifacts,
        )

        cleaned = _clean_llm_json_artifacts("[1, ..., ..., 2]")
        assert "..." not in cleaned

    def test_quoted_ellipsis_removed(self):
        """Quoted ellipsis like "..." is also removed."""
        from local_deep_research.utilities.json_utils import (
            _clean_llm_json_artifacts,
        )

        cleaned = _clean_llm_json_artifacts('[1, "...", 2]')
        assert "..." not in cleaned


class TestCommentRemoval:
    """Tests for // comment removal."""

    def test_comment_removal_mangles_urls(self):
        """Documents that // removal strips URL paths from malformed JSON.

        _clean_llm_json_artifacts is only called on already-invalid JSON, but
        this documents the behaviour when URLs appear inside values.
        """
        from local_deep_research.utilities.json_utils import (
            _clean_llm_json_artifacts,
        )

        text = '{"url": "https://example.com/api/v1/data"}'
        cleaned = _clean_llm_json_artifacts(text)
        # The regex `//[^\n]*` will strip everything after the //
        assert "example.com" not in cleaned or "/api/v1/data" not in cleaned

    def test_single_slash_preserved(self):
        """Single forward slashes are not treated as comments."""
        from local_deep_research.utilities.json_utils import (
            _clean_llm_json_artifacts,
        )

        text = '{"path": "/api/v1/data"}'
        cleaned = _clean_llm_json_artifacts(text)
        assert "/api/v1/data" in cleaned


class TestCodeFenceStripping:
    """Tests for _strip_code_fences edge cases."""

    def test_json_fence_without_closing(self):
        """Truncated LLM output: ```json\\n{} with no closing fence."""
        from local_deep_research.utilities.json_utils import (
            _strip_code_fences,
        )

        text = '```json\n{"key": "value"}'
        result = _strip_code_fences(text)
        # split("```json") gives ['', '\n{"key": "value"}']
        # then split("```")[0] returns the full inner text (no closing fence)
        assert '"key"' in result

    def test_multiple_bare_code_fences(self):
        """First-pair-wins behavior with 4+ fence delimiters."""
        from local_deep_research.utilities.json_utils import (
            _strip_code_fences,
        )

        text = '```\n{"first": 1}\n```\n```\n{"second": 2}\n```'
        result = _strip_code_fences(text)
        # With generic ``` handling, parts = split("```") gives 5 parts
        # parts[1] is '\n{"first": 1}\n' — first pair wins
        assert '"first"' in result


class TestExtractJsonTypeCoercion:
    """Tests for expected_type parameter in extract_json."""

    def test_pure_dict_expected_list_extracts_inner(self):
        """When expected_type=list and text contains dict with a list value,
        bracket extraction finds the inner list."""
        from local_deep_research.utilities.json_utils import extract_json

        result = extract_json('{"items": [1, 2, 3]}', expected_type=list)
        # With expected_type=list, bracket_pairs tries "[" first
        # _extract_by_brackets finds the inner [1, 2, 3]
        if result is not None:
            assert isinstance(result, list)

    def test_pure_list_expected_dict_returns_none(self):
        """When expected_type=dict and text is a plain list, returns None."""
        from local_deep_research.utilities.json_utils import extract_json

        result = extract_json("[1, 2, 3]", expected_type=dict)
        # Direct parse succeeds as list, but type mismatch -> fall through
        # Bracket extraction for "{" finds nothing -> None
        assert result is None

    def test_list_of_dicts_expected_dict_extracts_first(self):
        """Common LLM pattern: wrapping a dict in a list. With expected_type=dict,
        bracket extraction for '{' finds the inner dict."""
        from local_deep_research.utilities.json_utils import extract_json

        result = extract_json('[{"key": "value"}]', expected_type=dict)
        if result is not None:
            assert isinstance(result, dict)
            assert result.get("key") == "value"


class TestBracketExtractionEdgeCases:
    """Tests for _extract_by_brackets with prose around JSON."""

    def test_closing_brace_in_prose_after_json(self):
        """When prose after the JSON contains stray braces, rfind('}')
        latches onto the last brace (in the prose). The substring then
        spans valid JSON plus trailing junk, which fails to parse —
        so extract_json returns None. Pinning this behavior so a
        future change cannot silently regress it."""
        from local_deep_research.utilities.json_utils import extract_json

        text = (
            'Here is the result: {"answer": "yes"} and more text with } braces'
        )
        result = extract_json(text)

        assert result is None

    def test_think_tags_wrapping_json(self):
        """JSON sandwiched between think tag blocks is extracted after tag removal."""
        from local_deep_research.utilities.json_utils import extract_json

        text = '<think>reasoning here</think>{"key": "value"}<think>more thinking</think>'
        result = extract_json(text)
        assert result is not None
        assert result == {"key": "value"}