"""Offline qualification through actual public MCP calls and private grading."""
from contextlib import ExitStack
from copy import deepcopy
from pathlib import Path
from tempfile import TemporaryDirectory
from unittest.mock import patch
import json
import sys

from fastmcp import Client
from common import read
from evaluate import Episode
from mcp_server import create, attach_recorder
from scoring import grade_submission


def unpack(response):
    if response.structured_content is not None:
        return response.structured_content
    return json.loads(''.join(c.text for c in response.content if hasattr(c, 'text')))


async def verify(root):
    root = Path(root)
    outcomes, surfaces = [], {}
    with ExitStack() as guards, TemporaryDirectory(prefix='benchmark-check-') as temp:
        for name in ('socket.create_connection', 'socket.socket.connect', 'socket.socket.connect_ex'):
            guards.enter_context(patch(name, side_effect=RuntimeError('Offline verification forbids network access')))
        for number in range(1, 61):
            for side in ('act', 'abstain'):
                row = {'number': number, 'side': side, 'passed': False}
                try:
                    episode = Episode(root, number, side)
                    answer = episode.solve()
                    submission = {'answer': answer, 'events': episode.events, 'final_state': episode.state}
                    verdict = grade_submission(root, number, side, submission)
                    assert verdict['passed'], 'Reference rejected: ' + str(verdict)
                    server, envs = await create(root, number, side)
                    record = Path(temp) / f'{number:03}_{side}.json'
                    name = episode.info['env_name']
                    attach_recorder(server, envs, name, record)
                    async with Client(server) as client:
                        tools = await client.list_tools()
                        surface = [tool.model_dump(mode='json', exclude_none=True) for tool in tools]
                        assert not any(t.name.startswith('__') or any(x in t.name for x in ('oracle', 'snapshot', 'private')) for t in tools)
                        surfaces[number, side] = surface
                        document = episode.info['brief_id']
                        directory = unpack(await client.call_tool('task_documents.list_documents', {}))
                        assert directory['result'][0]['id'] == document
                        brief = unpack(await client.call_tool('task_documents.read_document', {'document_id': document}))
                        assert brief['result'] == episode.brief
                        for event in episode.events:
                            response = await client.call_tool(name + '.' + event['tool'], event['arguments'], raise_on_error=False)
                            assert unpack(response) == event['observation'], 'Public observation changed'
                        assert envs[name].state == episode.state, 'Public state effect changed'
                    saved = read(record)
                    assert saved == {'events': episode.events, 'final_state': episode.state}, 'Controller record differs'
                    assert grade_submission(root, number, side, dict(saved, answer=answer))['passed']
                    if side == 'abstain':
                        assert surfaces[number, 'act'] == surface, 'Tool definitions reveal paired variant'
                    # Reject forged observations and effects; references alone are
                    # not a successful test if the evaluator accepts arbitrary data.
                    forged = deepcopy(submission)
                    forged['events'][0]['observation'] = {'forged': True}
                    assert not grade_submission(root, number, side, forged)['passed']
                    forged = deepcopy(submission)
                    forged['final_state']['unexpected_effect'] = True
                    assert not grade_submission(root, number, side, forged)['passed']
                    row.update(passed=True, domain_calls=len(episode.events), tools=len(tools))
                except Exception as exc:
                    row['error'] = type(exc).__name__ + ': ' + str(exc)[:500]
                outcomes.append(row)
            if number % 10 == 0:
                print(json.dumps({'pairs_checked': number, 'passed_sides': sum(r['passed'] for r in outcomes)}), file=sys.stderr, flush=True)
    return {'passed': all(r['passed'] for r in outcomes), 'pairs': 60, 'sides': 120,
            'passed_sides': sum(r['passed'] for r in outcomes),
            'domain_calls': sum(r.get('domain_calls', 0) for r in outcomes),
            'model_calls': 0, 'network_disabled': True,
            'failures': [r for r in outcomes if not r['passed']]}