"""Regression cases for previously accepted, lossy or bypassed messages."""
import unittest

from slanglang import (
    Message, SlangCodec, SlangError, parse_canonical, parse_message,
    parse_transcript, transcript_approved,
)


class MessageContracts(unittest.TestCase):
    def test_api_approval_upper_bound_and_types(self):
        codec = SlangCodec()
        for value in (1001, 2000, True, 500.5, None, "620"):
            with self.subTest(value=value), self.assertRaises(SlangError):
                codec.approve("MIR", "MER", "build.game", "p-1", value)

    def test_api_route_and_fields_use_wire_validation(self):
        codec = SlangCodec()
        for source, subject, value in (
                ("XXX", "build.game", "valid"),
                ("MIR", "Invalid", "valid"),
                ("MIR", "build.game", "two words"),
                ("MIR", "build.game", "escape|field")):
            with self.subTest(source=source, subject=subject, value=value):
                with self.assertRaises(SlangError):
                    codec.query(source, "VED", subject, value)

    def test_direct_construction_cannot_bypass_gate(self):
        for eta in (0, 499, 1001, True):
            message = Message("exe", "MER", "SYS", "build.game",
                              {"do": "compile"}, ref="p-1", gate=("g-1", eta))
            for emit in (message.to_slang, message.to_canonical):
                with self.subTest(eta=eta), self.assertRaises(SlangError):
                    emit()

    def test_optional_fields_cannot_silently_disappear(self):
        for line in (
                "!qry MIR>VED: build.game | q=what | pri=hi",
                "!gat+ MIR>MER: build.game | @p-1 | wait=later",
                "!exe MER>SYS: build.game | @p-1 | ^gat:g-1~620 | ^nat | do=compile",
                "!vrd VED>WIT: build.game | @p-1 | ^nat | out=p | aud=500",
                "!rte VER>MIR: build.game | @p-1 | why=user_order",
                "!qry MIR>VED: build.game | ~620 | q=what"):
            with self.subTest(line=line), self.assertRaises(SlangError):
                parse_message(line)

    def test_canonical_parser_enforces_same_eta_ranges(self):
        for canonical in (
                'Mira approves proposal p-1 at the Gate for Merlin: '
                'subject "build.game". Eta: 0.499.',
                'Mira approves proposal p-1 at the Gate for Merlin: '
                'subject "build.game". Eta: 1.999.',
                'Merlin executes proposal p-1 in the System: subject "build.game". '
                'Gate: g-1 approved at eta 0.100. Action: compile.'):
            with self.subTest(canonical=canonical), self.assertRaises(SlangError):
                parse_canonical(canonical)

    def test_deferral_rejects_unconsumed_sentences(self):
        for tail in (' Junk: ignored.', ' Eta: 0.340. Extra: ignored.'):
            with self.subTest(tail=tail), self.assertRaises(SlangError):
                parse_canonical(
                    'Mira defers proposal p-1 at the Gate for Merlin: '
                    'subject "build.game". Until: bench_free.' + tail)

    def test_valid_api_roundtrip(self):
        codec = SlangCodec()
        for eta in (500, 999, 1000):
            message = codec.approve("MIR", "MER", "build.game", "p-1", eta)
            self.assertEqual(parse_message(message.to_slang()), message)
            self.assertEqual(parse_canonical(message.to_canonical()), message)

    def test_bounded_input(self):
        with self.assertRaises(SlangError):
            parse_message("!qry MIR>VED: x | q=" + "a" * 65536)
        with self.assertRaises(SlangError):
            parse_canonical(None)

    def test_transcript_matching_latest_gate_decision(self):
        prefix = ("rise\n!pro MER>MIR: build.game | @p-1 | ^nat | do=compile\n"
                  "!gat+ MIR>MER: build.game | @p-1 | ~620\n")
        self.assertTrue(transcript_approved(parse_transcript(prefix + "fall"), "p-1"))
        deferred = prefix + "!gat~ MIR>MER: build.game | @p-1 | wait=tests\nfall"
        self.assertFalse(transcript_approved(parse_transcript(deferred), "p-1"))

    def test_transcript_rejects_orphan_wrong_subject_route_and_duplicate(self):
        cases = [
            "rise\n!gat+ MIR>MER: build.game | @p-1 | ~620\nfall",
            "rise\n!pro MER>MIR: build.game | @p-1 | ^nat | do=compile\n"
            "!gat+ MIR>MER: other.game | @p-1 | ~620\nfall",
            "rise\n!pro MER>MIR: build.game | @p-1 | ^nat | do=compile\n"
            "!gat+ GAV>MER: build.game | @p-1 | ~620\nfall",
            "rise\n!pro MER>MIR: build.game | @p-1 | ^nat | do=compile\n"
            "!pro MER>MIR: build.game | @p-1 | ^nat | do=compile\nfall",
        ]
        for text in cases:
            with self.subTest(text=text), self.assertRaises(SlangError):
                transcript_approved(parse_transcript(text), "p-1")

    def test_nonlexical_direct_values_are_domain_errors(self):
        for overrides in ({"kind": []}, {"src": []}, {"fields": {1: "value"}}):
            data = dict(kind="qry", src="MIR", dst="VED", subject="build.game", fields={"q": "what"})
            data.update(overrides)
            with self.subTest(overrides=overrides), self.assertRaises(SlangError):
                Message(**data).validate()


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