#!/usr/bin/env python3
"""First MCP verification task, Python 3.9+ standard library only.

--run: a deterministic client checks a local application's challenge over HTTP.
--serve: a local agent can use its own gecici.email MCP tools to solve the task.
Mail is inserted through authenticated simulation, NOT SMTP. No real account.
Only fixed stage/error names are printed. Credentials and codes stay in memory.
Review this source before running. Never expose this teaching server publicly.
"""
import argparse
import hashlib
import json
import secrets
import ssl
import threading
import time
from http.server import BaseHTTPRequestHandler, HTTPServer
from pathlib import Path
from urllib.error import HTTPError
from urllib.request import Request, urlopen

BASE = 'https://gecici.email'
TOOLS = {'gecici_create_inbox', 'gecici_wait_for_verification', 'gecici_delete_inbox'}


class TaskError(Exception):
    pass


def request(url, payload=None, token=None, method='POST'):
    tls = ssl.create_default_context()
    if not ssl.get_default_verify_paths().cafile and Path('/etc/ssl/cert.pem').exists():
        tls.load_verify_locations('/etc/ssl/cert.pem')
    headers = {'Content-Type': 'application/json', 'Accept': 'application/json, text/event-stream',
               'X-Gecici-Client': 'qa-test', 'X-QA-Fixture': '1'}
    if token:
        headers['Authorization'] = 'Bearer ' + token
    body = json.dumps(payload).encode() if payload is not None else None
    try:
        response = urlopen(Request(url, data=body, headers=headers, method=method),
                           context=tls, timeout=30)
    except HTTPError as error:
        response = error
    with response:
        raw = response.read(1000001)
        if len(raw) > 1000000:
            raise TaskError('response_too_large')
        return response.status, json.loads(raw or b'{}')


class MCP:
    def rpc(self, method, params=None):
        status, data = request(BASE + '/mcp', {'jsonrpc': '2.0', 'id': 1,
                                             'method': method, 'params': params or {}})
        if status != 200 or 'error' in data:
            raise TaskError('mcp_request_failed')
        return data['result']

    def connect(self):
        self.rpc('initialize', {'protocolVersion': '2025-06-18', 'capabilities': {},
                               'clientInfo': {'name': 'gecici-first-task-qa', 'version': '1.0.0'}})
        status, _ = request(BASE + '/mcp', {'jsonrpc': '2.0', 'method': 'notifications/initialized'})
        if status != 202 or not TOOLS.issubset({t['name'] for t in self.rpc('tools/list')['tools']}):
            raise TaskError('required_tools_unavailable')

    def call(self, name, arguments):
        result = self.rpc('tools/call', {'name': name, 'arguments': arguments})
        if result.get('isError'):
            raise TaskError('tool_error')
        data = result.get('structuredContent')
        if not isinstance(data, dict):
            raise TaskError('structured_result_missing')
        return data


class Application:
    """Independent, one-use challenge. No API read or extracted value here."""
    def __init__(self, mcp=None, transport=request, clock=time.monotonic):
        self.mcp = mcp or MCP()
        self.transport, self.clock = transport, clock
        self.inbox = None
        self.digest = None
        self.deadline = 0
        self.attempts = 0
        self.accepted = False
        self.steps = {'connection': False, 'inbox_created': False, 'mail_simulated': False,
                      'application_accepted': False, 'cleanup': False}

    def start(self):
        if self.inbox or self.steps['cleanup']:
            raise TaskError('already_started')
        self.mcp.connect()
        self.steps['connection'] = True
        self.inbox = self.mcp.call('gecici_create_inbox', {})['inbox']
        self.steps['inbox_created'] = True
        code = str(100000 + secrets.randbelow(900000))
        self.digest = hashlib.sha256(code.encode()).digest()
        self.deadline = self.clock() + 120
        status, _ = self.transport(BASE + '/api/v1/simulate', {
            'to': self.inbox['address'], 'from': 'qa@example.invalid',
            'subject': 'Owned first task', 'text': 'Verification code: ' + code
        }, self.inbox['token'])
        if status != 201:
            raise TaskError('simulation_failed')
        self.steps['mail_simulated'] = True
        # Tool context, not a printed prompt or stored report. Never include these in logs.
        return {'tool': 'gecici_wait_for_verification', 'arguments': {
            'address': self.inbox['address'], 'token': self.inbox['token'],
            'since': self.inbox['createdAt'], 'kind': 'otp', 'sender': 'qa@example.invalid',
            'subject_contains': 'Owned first task', 'timeout_seconds': 5}}

    def verify(self, code):
        if not self.digest or self.steps['cleanup']:
            return 409, {'state': 'not_active'}
        if self.accepted:
            return 409, {'state': 'already_used'}
        if self.clock() >= self.deadline:
            return 410, {'state': 'expired'}
        if self.attempts >= 5:
            return 429, {'state': 'attempt_limit'}
        self.attempts += 1
        if not isinstance(code, str) or len(code) != 6 or not secrets.compare_digest(
                self.digest, hashlib.sha256(code.encode()).digest()):
            return 400, {'state': 'wrong_code'}
        self.accepted = self.steps['application_accepted'] = True
        return 200, {'state': 'verified'}

    def close(self):
        if self.inbox:
            args = {k: self.inbox[k] for k in ['address', 'token']}
            # Bounded cleanup retry; credentials remain in memory if all attempts fail.
            for _ in range(3):
                try:
                    if self.mcp.call('gecici_delete_inbox', args).get('deleted') is True:
                        self.inbox = None
                        break
                except Exception:
                    pass
            if self.inbox:
                return False
        self.digest = None
        self.steps['cleanup'] = True
        return True


class Handler(BaseHTTPRequestHandler):
    def log_message(self, *_):
        pass

    def reply(self, status, data):
        raw = json.dumps(data).encode()
        self.send_response(status)
        self.send_header('Content-Type', 'application/json')
        self.send_header('Cache-Control', 'no-store')
        self.send_header('Content-Length', str(len(raw)))
        self.end_headers()
        self.wfile.write(raw)

    def do_POST(self):
        expected = '127.0.0.1:' + str(self.server.server_port)
        if self.headers.get('Host') != expected or self.headers.get('X-QA-Fixture') != '1' or self.headers.get('Origin'):
            return self.reply(403, {'state': 'local_agent_only'})
        try:
            length = int(self.headers.get('Content-Length', '0'))
            if not 0 <= length <= 4096:
                return self.reply(413, {'state': 'request_too_large'})
            data = json.loads(self.rfile.read(length) or b'{}')
            if not isinstance(data, dict):
                return self.reply(400, {'state': 'invalid_request'})
            app = self.server.application
            if self.path == '/start':
                return self.reply(200, app.start())
            if self.path == '/verify':
                return self.reply(*app.verify(data.get('code')))
            if self.path == '/cleanup':
                return self.reply(200 if app.close() else 502, dict(app.steps))
            if self.path == '/status':
                return self.reply(200, dict(app.steps))
            return self.reply(404, {'state': 'unknown_route'})
        except TaskError as error:
            return self.reply(409, {'state': str(error)})
        except Exception:
            return self.reply(502, {'state': 'request_failed'})


def server(application=None, port=0):
    instance = HTTPServer(('127.0.0.1', port), Handler)
    instance.application = application or Application()
    return instance


def run(application=None, reader=None):
    instance = server(application)
    thread = threading.Thread(target=instance.serve_forever, daemon=True)
    thread.start()
    base = 'http://127.0.0.1:' + str(instance.server_port)
    result = {'passed': False, 'transport': 'simulation', 'qa': True,
              'model_tested': False, 'external_smtp_tested': False, 'failed_step': None,
              'value_extracted': False, 'wrong_code_rejected': False, 'replay_rejected': False}
    step = 'start'
    try:
        status, context = request(base + '/start', {})
        if status != 200:
            raise TaskError('start_failed')
        step = 'extract'
        client = reader or MCP()
        client.connect()
        value = client.call(context['tool'], context['arguments'])
        if value.get('status') != 'ready' or not isinstance(value.get('otp'), str):
            raise TaskError('verification_not_ready')
        result['value_extracted'] = True
        step = 'wrong_code_control'
        status, body = request(base + '/verify', {'code': '000000'})
        if status != 400 or body.get('state') != 'wrong_code':
            raise TaskError('wrong_code_accepted')
        result['wrong_code_rejected'] = True
        step = 'application_acceptance'
        status, body = request(base + '/verify', {'code': value['otp']})
        if status != 200 or body.get('state') != 'verified':
            raise TaskError('application_rejected')
        step = 'replay_control'
        status, body = request(base + '/verify', {'code': value['otp']})
        if status != 409 or body.get('state') != 'already_used':
            raise TaskError('replay_accepted')
        result['replay_rejected'] = True
    except Exception:
        result['failed_step'] = step
    finally:
        instance.shutdown()
        instance.server_close()
        thread.join(timeout=2)
        cleaned = instance.application.close()
        result.update(instance.application.steps)
        if not cleaned and result['failed_step'] is None:
            result['failed_step'] = 'cleanup'
    result['passed'] = result['failed_step'] is None and result['application_accepted'] and result['cleanup']
    return result


if __name__ == '__main__':
    parser = argparse.ArgumentParser(description=__doc__)
    modes = parser.add_mutually_exclusive_group(required=True)
    modes.add_argument('--run', action='store_true')
    modes.add_argument('--serve', action='store_true')
    parser.add_argument('--port', type=int, default=8798)
    args = parser.parse_args()
    if args.run:
        outcome = run()
        print(json.dumps(outcome, sort_keys=True))
        raise SystemExit(0 if outcome['passed'] else 1)
    local = server(port=args.port)
    print(json.dumps({'fixture_url': 'http://127.0.0.1:' + str(local.server_port),
                      'transport': 'simulation', 'qa': True}), flush=True)
    try:
        local.serve_forever()
    except KeyboardInterrupt:
        pass
    finally:
        local.server_close()
        print(json.dumps({'cleanup': local.application.close()}), flush=True)
