import hashlib
import json
import os
import subprocess
import sys
from pathlib import Path

import pytest


APP = Path("/app")
SOURCE_ROOT = APP / "vendor" / "lark"
FIXTURES = Path("/tests/fixtures")

sys.path.insert(0, str(SOURCE_ROOT))

from lark import Lark, Token, Transformer


def sha256(path):
    return hashlib.sha256(path.read_bytes()).hexdigest()


def token_values(tree):
    return [(value.type, str(value)) for value in tree.scan_values(lambda value: isinstance(value, Token))]


def advance(interactive, count):
    stream = interactive.lexer_thread.lex(interactive.parser_state)
    for _ in range(count):
        token = next(stream)
        interactive.feed_token(token)


def assert_clone_identity(original, clone):
    assert clone is not original
    assert clone.parser_state is not original.parser_state
    assert clone.parser_state.state_stack is not original.parser_state.state_stack
    assert clone.lexer_thread is not original.lexer_thread
    assert clone.parser_state.lexer is clone.lexer_thread
    assert clone.parser_state.lexer is not original.parser_state.lexer
    if original.lexer_thread.state is None:
        assert clone.lexer_thread.state is None
    else:
        assert clone.lexer_thread.state is not original.lexer_thread.state
        assert clone.lexer_thread.state.line_ctr is not original.lexer_thread.state.line_ctr


def test_gate_artifact_schema_and_source_integrity():
    report_path = APP / "repair_report.json"
    assert report_path.is_file()
    report = json.loads(report_path.read_text())
    assert report["output_schema_version"] == "lark-clone-repair-v1"
    assert report["source_root"] == "vendor/lark"
    assert report["summary"] == {"all_cases_pass": True, "case_count": 3, "passed_count": 3}
    assert {case["id"] for case in report["cases"]} == {"clone_first_short", "original_first_multiline", "value_copy_policy"}
    assert all(case["passed"] is True for case in report["cases"])

    trusted = json.loads((FIXTURES / "trusted_hashes.json").read_text())
    for relative, expected in trusted["protected"].items():
        path = SOURCE_ROOT / relative
        assert path.is_file(), relative
        assert sha256(path) == expected, relative
    for relative, pristine in trusted["mutable_pristine"].items():
        path = SOURCE_ROOT / relative
        assert path.is_file(), relative
        assert sha256(path) != pristine, f"{relative} was not repaired"


def test_gate_build_and_upstream_compatibility():
    env = {**os.environ, "PYTHONPATH": str(SOURCE_ROOT), "PYTHONDONTWRITEBYTECODE": "1"}
    compile_result = subprocess.run(
        [sys.executable, "-m", "compileall", "-q", "lark"],
        cwd=SOURCE_ROOT,
        env=env,
        capture_output=True,
        text=True,
        timeout=30,
    )
    assert compile_result.returncode == 0, compile_result.stderr
    upstream_result = subprocess.run(
        [sys.executable, "tests/test_parser.py", "TestLalrBasic.test_parser_interactive_parser", "-q"],
        cwd=SOURCE_ROOT,
        env=env,
        capture_output=True,
        text=True,
        timeout=45,
    )
    assert upstream_result.returncode == 0, upstream_result.stdout + upstream_result.stderr
    assert "OK" in upstream_result.stderr + upstream_result.stdout


@pytest.mark.parametrize("clone_first", [True, False])
def test_core_private_resume_is_independent_in_both_orders(clone_first):
    fixture = json.loads((FIXTURES / "private_cases.json").read_text())
    assert fixture["output_schema_version"] == "lark-clone-repair-v1"
    for case in fixture["resume_cases"]:
        parser = Lark(case["grammar"], parser="lalr")
        expected = token_values(parser.parse(case["text"]))
        original = parser.parse_interactive(case["text"])
        advance(original, case["advance"])
        clone = original.copy()
        assert_clone_identity(original, clone)
        original_position = original.lexer_thread.state.line_ctr.char_pos
        clone_position = clone.lexer_thread.state.line_ctr.char_pos
        assert original_position == clone_position
        first, second = (clone, original) if clone_first else (original, clone)
        first_tree = first.resume_parse()
        assert token_values(first_tree) == expected, case["id"]
        assert second.lexer_thread.state.line_ctr.char_pos == original_position
        second_tree = second.resume_parse()
        assert token_values(second_tree) == expected, case["id"]
        assert first_tree == second_tree


class MutableTransformer(Transformer):
    def ITEM(self, value):
        return {"token": str(value), "notes": []}


def test_core_value_copy_policy_and_manual_continuation():
    parser = Lark("start: ITEM ITEM ITEM\nITEM: /[a-z]+/\n%ignore \" \"", parser="lalr", transformer=MutableTransformer())
    original = parser.parse_interactive("one two three")
    advance(original, 1)
    shallow = original.copy(deepcopy_values=False)
    deep = original.copy(deepcopy_values=True)
    assert_clone_identity(original, shallow)
    assert_clone_identity(original, deep)
    original_value = original.parser_state.value_stack[-1]
    assert shallow.parser_state.value_stack[-1] is original_value
    assert deep.parser_state.value_stack[-1] is not original_value
    assert deep.parser_state.value_stack[-1] == original_value
    shallow.parser_state.value_stack[-1]["notes"].append("shared")
    assert original_value["notes"] == ["shared"]
    assert deep.parser_state.value_stack[-1]["notes"] == []

    plain = Lark("start: WORD+\nWORD: /[a-z]+/\n%ignore \" \"", parser="lalr")
    manual_original = plain.parse_interactive("north south east west")
    advance(manual_original, 1)
    manual_clone = manual_original.copy()
    assert_clone_identity(manual_original, manual_clone)
    clone_tokens = manual_clone.exhaust_lexer()
    clone_tree = manual_clone.feed_eof(clone_tokens[-1])
    original_tokens = manual_original.exhaust_lexer()
    original_tree = manual_original.feed_eof(original_tokens[-1])
    assert token_values(clone_tree) == token_values(plain.parse("north south east west"))
    assert clone_tree == original_tree


def test_edge_no_text_eof_and_multiline_cursor_isolation():
    parser = Lark("start: A+\nA: \"a\"", parser="lalr")
    original = parser.parse_interactive()
    clone = original.copy()
    assert_clone_identity(original, clone)
    original.feed_token(Token("A", "a"))
    clone.feed_token(Token("A", "a"))
    clone.feed_token(Token("A", "a"))
    assert token_values(original.feed_eof()) == [("A", "a")]
    assert token_values(clone.feed_eof()) == [("A", "a"), ("A", "a")]

    multiline = Lark("start: WORD+\nWORD: /[a-z]+/\n%ignore /[ \\t\\n]+/", parser="lalr", propagate_positions=True)
    source = "first\nsecond\nthird\nfourth"
    left = multiline.parse_interactive(source)
    advance(left, 1)
    right = left.copy()
    assert_clone_identity(left, right)
    right_tree = right.resume_parse()
    assert left.lexer_thread.state.line_ctr.line == 1
    left_tree = left.resume_parse()
    assert right_tree == left_tree == multiline.parse(source)
    assert right_tree.meta.end_line == 4