"""Local asyncio failure-boundary fixture. Python 3.11+. No network calls.

Run: python3 agent-taskgroup.py [--test]
Events establish ordering; no wall-clock sleeps determine the outcomes.
The in-memory effects list represents an effect, not a remote service.
"""
import asyncio
import json
import sys
import unittest


async def gather_case(cancel_after_error=False):
    ready, release = asyncio.Event(), asyncio.Event()
    effects = []

    async def writer():
        ready.set()
        await release.wait()
        effects.append("write")

    async def failing():
        await ready.wait()
        raise RuntimeError("tool failed")

    child = asyncio.create_task(writer())
    batch = asyncio.gather(child, failing())
    pending_after_error, cancel_accepted = False, None
    try:
        await batch
    except RuntimeError:
        pending_after_error = not child.done()
        cancel_accepted = batch.cancel() if cancel_after_error else None
    finally:
        release.set()
        await child
    return {"pending_after_error": pending_after_error,
            "late_cancel_accepted": cancel_accepted, "effects": effects}


async def group_case(commit_before_failure=False, swallow_cancel=False):
    ready = asyncio.Event()
    never_released = asyncio.Event()
    effects, events = [], []

    async def writer():
        if commit_before_failure:
            effects.append("write")
        ready.set()
        try:
            await never_released.wait()
        except asyncio.CancelledError:
            events.append("cancel_seen")
            if swallow_cancel:
                effects.append("write_after_cancel")
                return
            raise
        finally:
            events.append("cleanup")

    async def failing():
        await ready.wait()
        raise RuntimeError("tool failed")

    errors = []
    child = None
    try:
        async with asyncio.TaskGroup() as group:
            child = group.create_task(writer())
            group.create_task(failing())
    except* RuntimeError as failures:
        errors.extend(str(e) for e in failures.exceptions)
    if child is None:
        raise RuntimeError("writer was not created")
    return {"effects": effects, "events": events, "errors": errors,
            "child_done": child.done(), "child_cancelled": child.cancelled()}


async def detached_case():
    ready, release = asyncio.Event(), asyncio.Event()
    effects = []

    async def detached_writer():
        ready.set()
        await release.wait()
        effects.append("detached_write")

    async def failing():
        await ready.wait()
        raise RuntimeError("tool failed")

    child = asyncio.create_task(detached_writer())
    try:
        try:
            async with asyncio.TaskGroup() as group:
                group.create_task(failing())
        except* RuntimeError:
            pass
        pending_at_group_exit = not child.done()
    finally:
        release.set()
        await child
    return {"pending_at_group_exit": pending_at_group_exit, "effects": effects}


class BoundaryTests(unittest.IsolatedAsyncioTestCase):
    async def test_gather_leaves_sibling_running(self):
        result = await gather_case()
        self.assertTrue(result["pending_after_error"])
        self.assertEqual(result["effects"], ["write"])

    async def test_late_gather_cancel_does_not_stop_sibling(self):
        result = await gather_case(True)
        self.assertIs(result["late_cancel_accepted"], False)
        self.assertEqual(result["effects"], ["write"])

    async def test_taskgroup_cancels_and_awaits_pending_child(self):
        result = await group_case()
        self.assertEqual(result["effects"], [])
        self.assertEqual(result["events"], ["cancel_seen", "cleanup"])
        self.assertEqual(result["errors"], ["tool failed"])
        self.assertTrue(result["child_done"])
        self.assertTrue(result["child_cancelled"])

    async def test_taskgroup_does_not_undo_prior_effect(self):
        result = await group_case(commit_before_failure=True)
        self.assertEqual(result["effects"], ["write"])
        self.assertTrue(result["child_cancelled"])

    async def test_swallowed_cancellation_can_continue_effects(self):
        result = await group_case(swallow_cancel=True)
        self.assertEqual(result["effects"], ["write_after_cancel"])
        self.assertTrue(result["child_done"])
        self.assertFalse(result["child_cancelled"])

    async def test_detached_task_is_outside_group(self):
        result = await detached_case()
        self.assertTrue(result["pending_at_group_exit"])
        self.assertEqual(result["effects"], ["detached_write"])


async def demo():
    print(json.dumps({"gather": await gather_case(True),
                      "taskgroup": await group_case(),
                      "prior_effect": await group_case(True),
                      "swallowed_cancel": await group_case(swallow_cancel=True),
                      "detached": await detached_case()}, indent=2))


if __name__ == "__main__":
    if sys.argv[1:] == ["--test"]:
        unittest.main(argv=[sys.argv[0]], verbosity=2)
    elif sys.argv[1:]:
        raise SystemExit("usage: agent-taskgroup.py [--test]")
    else:
        asyncio.run(demo())
