import unittest

from logicbench.skeletons import generate_skeletons, resolve_length


class SkeletonTests(unittest.TestCase):
    def test_short_world_has_many_entities_and_realized_events(self):
        skeleton = generate_skeletons(1, "short", seed=42)[0]
        self.assertEqual(skeleton.entity_count, 128)
        self.assertEqual(skeleton.simulation_steps, 1000)
        self.assertGreater(len(skeleton.events), 300)
        self.assertGreaterEqual(len(skeleton.proof_event_ids), 4)
        self.assertLess(skeleton.generator_checks["proof_event_ratio"], 0.05)

    def test_generation_is_deterministic(self):
        first = [item.to_dict() for item in generate_skeletons(4, 4, seed=7)]
        second = [item.to_dict() for item in generate_skeletons(4, 4, seed=7)]
        self.assertEqual(first, second)

    def test_renderer_receives_realized_history_but_no_program_or_answer(self):
        skeleton = generate_skeletons(1, "short", seed=1)[0]
        payload = skeleton.renderer_payload()
        for secret in (
            "id",
            "hidden_program",
            "hidden_state",
            "final_state",
            "gold_answer",
            "proof_event_ids",
            "proof_facts",
            "generator_checks",
        ):
            self.assertNotIn(secret, payload)
        self.assertEqual(len(payload["events"]), len(skeleton.events))
        self.assertEqual(len(payload["entity_types"]), 128)

    def test_query_is_not_directly_stated_and_proof_events_exist(self):
        for skeleton in generate_skeletons(5, "short", seed=20260922):
            query_pair = skeleton.query.arguments
            direct = [
                event
                for event in skeleton.events
                if event.kind == "RELATE"
                and event.arguments.get("predicate") == skeleton.query.predicate
                and (event.arguments.get("subject"), event.arguments.get("object")) == query_pair
            ]
            self.assertFalse(direct)
            event_ids = {event.id for event in skeleton.events}
            self.assertTrue(set(skeleton.proof_event_ids) <= event_ids)
            self.assertGreaterEqual(len(skeleton.proof_event_ids), skeleton.complexity)

    def test_world_contains_multiple_logic_domains(self):
        skeleton = generate_skeletons(1, "short", seed=3)[0]
        predicates = {
            event.arguments.get("predicate")
            for event in skeleton.events
            if event.kind == "RELATE"
        }
        self.assertTrue({"ABOVE", "MEMBER", "SUBSET", "CONNECTED"} <= predicates)
        kinds = {event.kind for event in skeleton.events}
        self.assertTrue({"MOVE", "UPDATE_NUMBER", "SET_STATE"} <= kinds)

    def test_length_and_scale_validation(self):
        self.assertEqual(resolve_length("medium"), 6)
        self.assertEqual(resolve_length("5"), 5)
        with self.assertRaises(ValueError):
            resolve_length("huge")
        with self.assertRaises(ValueError):
            resolve_length(2)
        with self.assertRaises(ValueError):
            generate_skeletons(1, "short", entity_count=20)


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