"""Deterministic comparison and callback regressions; no remote parsing."""
import unittest
from unittest.mock import patch

import app
from core.conllu_utils import compare_trees


def token(form="word", token_id="1", upos="NOUN", head="0", relation="root"):
    return f"{token_id}\t{form}\t_\t{upos}\t_\t_\t{head}\t{relation}\t_\t_\n"


class ComparisonTests(unittest.TestCase):
    def compare(self, a, b):
        return compare_trees(a, "A", b, "B")

    def test_identical_and_annotation_differences(self):
        a = token()
        self.assertTrue(self.compare(a, a)["identical"])
        for b, expected in ((token(upos="VERB"), "POS"),
                            (token(head="2", relation="obj"), "Syntax Arc"),
                            (token(upos="VERB", relation="obj"), "POS & Syntax")):
            with self.subTest(expected=expected):
                result = self.compare(a, b)
                self.assertFalse(result["identical"])
                self.assertEqual(result["diff_table"].iloc[0]["Difference"], expected)

    def test_missing_data_never_establishes_identity(self):
        for a, b in ((token(), ""), ("", token()), ("", ""), (token(), "# comment\n")):
            with self.subTest(a=a, b=b):
                self.assertFalse(self.compare(a, b)["identical"])

    def test_tokenization_mismatch_prevents_arc_comparison(self):
        for b, expected in ((token("other", upos="VERB"), "Token Alignment Mismatch"),
                            (token(token_id="2"), "Token Alignment Mismatch"),
                            (token() + token("extra", "2"), "Token Count Mismatch")):
            with self.subTest(expected=expected):
                result = self.compare(token(), b)
                self.assertFalse(result["identical"])
                self.assertEqual(result["discrepancy_count"], 1)
                self.assertEqual(result["diff_table"].iloc[0]["Difference"], expected)
                self.assertIn("cannot be compared", result["diff_summary"])

    def test_multiword_headers_and_empty_nodes_are_skipped(self):
        extra = token("combined", "1-2") + token("empty", "1.1")
        self.assertTrue(self.compare(token(), extra + token())["identical"])


class CallbackTests(unittest.TestCase):
    def run_callback(self, responses):
        with patch.object(app.client, "parse_sentence", side_effect=responses):
            result = app.run_single_or_compare(
                "English", "word", "UDPipe · english-ewt-ud-2.17-251125", True, "UDPipe · english-gum-ud-2.17-251125"
            )
        self.assertEqual(len(result), 6)
        return result

    def test_result_freshness_tracks_every_parser_input(self):
        check = next(block.fn for block in app.demo.fns.values()
                     if block.fn and block.fn.__name__ == "check_result_freshness")
        original = ("English", "word", "model-a", True, "model-b", False)
        self.assertEqual(check(*original, original, "comparison summary"), "comparison summary")
        for position, replacement in enumerate(("German", "new text", "other", False, "other", True)):
            changed = list(original)
            changed[position] = replacement
            self.assertIn("Input changed", check(*changed, original, "comparison summary"))

    def test_example_noop_keeps_fourteen_outputs(self):
        callback = next(block.fn for block in app.demo.fns.values()
                        if block.fn and block.fn.__name__ == "on_example_input")
        self.assertEqual(len(callback(None, "English", "a", "b", False, None)), 14)

    def test_secondary_failure_preserves_primary_and_clears_differences(self):
        for response in ({"conllu": "", "error": "Timeout <unsafe>"},
                         {"conllu": "", "error": None},
                         {"conllu": "# comment\n", "error": None}):
            with self.subTest(response=response):
                result = self.run_callback([{"conllu": token(), "error": None}, response])
                self.assertIn("<iframe", result[0])
                self.assertEqual(result[2], token())
                self.assertIn("Comparison unavailable", result[3])
                self.assertNotIn("Matching analyses", result[3])
                self.assertNotIn("<unsafe>", result[3])
                self.assertFalse(result[4]["visible"])
                self.assertTrue(result[5].empty)

    def test_primary_failure_clears_outputs(self):
        for response in ({"conllu": "", "error": "Timeout <unsafe>"},
                         {"conllu": "", "error": None}):
            result = self.run_callback([response])
            self.assertIn("Error:", result[0])
            self.assertNotIn("<unsafe>", result[0])
            self.assertTrue(result[1].empty)
            self.assertEqual(result[2:4], ("", ""))
            self.assertFalse(result[4]["visible"])
            self.assertTrue(result[5].empty)

    def test_successful_comparison_status(self):
        for b, identical in ((token(), True), (token("different"), False), (token(upos="VERB"), False)):
            result = self.run_callback([{"conllu": token(), "error": None}, {"conllu": b, "error": None}])
            self.assertEqual("Matching analyses" in result[3], identical)
            self.assertEqual(result[4]["visible"], not identical)


if __name__ == "__main__":
    unittest.main()