"""Audit reproductions, NOT acceptance tests: observed=True confirms an OPEN gap.
Run only with an explicitly selected, migrated disposable *_test PostgreSQL DB.
Uses synthetic identities and in-process HTTP; never certifies deployed E2E/SEB.
"""
import os
import json
import uuid
import base64
import plistlib
import threading
from concurrent.futures import ThreadPoolExecutor
from datetime import datetime, timedelta, timezone
from urllib.parse import urlparse

from app.core.config import settings
from app.core.test_safety import require_disposable_database
require_disposable_database(settings.DATABASE_URL)
assert settings.ENVIRONMENT == 'test' and settings.EVIDENCE_STORAGE_MODE == 'memory'
assert settings.DATABASE_URL == os.environ['TEST_DATABASE_URL']
from fastapi.testclient import TestClient
from sqlalchemy import event as sql_event
from app.main import app
from app.core.database import SessionLocal, engine
from app.core.security import hash_password, create_access_token
from app.core.seb_configuration import calculate_configuration_key
from app.api.v1.secure import calculate_seb_config_key_hash
from app.models.organizer import Organizer, User, Membership
from app.models.event import Event, ExamSession, CompetitionCategory, CompetitionRound
from app.models.participant import Participant, Enrollment
from app.models.secure import SEBConfiguration
from app.models.attempt import Attempt, Answer, GradeRevision, GradingTask

client = TestClient(app, raise_server_exceptions=False)
rows = []
def report(name, observed, **evidence):
    rows.append({'probe': name, 'gap_reproduced': bool(observed), 'evidence': evidence})

def call(method, path, headers=None, **kw):
    return client.request(method, '/api/v1' + path, headers=headers or {}, **kw)

def ok(res):
    assert res.status_code < 300, (res.status_code, res.text[:300])
    return res.json()

nonce = uuid.uuid4().hex[:10]
now = datetime.now(timezone.utc)
with SessionLocal() as db:
    org = Organizer(name='Synthetic audit', slug='audit-' + nonce, contact_email='audit@example.com')
    org_b = Organizer(name='Synthetic second tenant', slug='audit-b-' + nonce, contact_email='b@example.com')
    db.add_all([org, org_b]); db.flush()
    users = {}
    for role in ['exam_manager', 'organizer_owner', 'author', 'grader', 'reviewer']:
        user = User(email=f'{role}-{nonce}@example.com', full_name='Synthetic ' + role, password_hash=hash_password('SyntheticAuditOnly!'), mfa_enabled=False)
        db.add(user); db.flush()
        db.add(Membership(organizer_id=org.id, user_id=user.id, role=role))
        users[role] = user.id
    foreign_event = Event(organizer_id=org_b.id, title='Foreign', slug='foreign-' + nonce)
    db.add(foreign_event); db.flush()
    cat = CompetitionCategory(event_id=foreign_event.id, name='Foreign', code='F')
    db.add(cat); db.flush()
    foreign_round = CompetitionRound(category_id=cat.id, name='Foreign round', round_number=1)
    db.add(foreign_round); db.commit()
    org_id, foreign_round_id = org.id, foreign_round.id
headers = {role: {'Authorization': 'Bearer ' + create_access_token(uid, org_id, [role])} for role, uid in users.items()}
mgr = headers['exam_manager']
login = call('POST', '/auth/login', json={'email': f'exam_manager-{nonce}@example.com', 'password':'SyntheticAuditOnly!'})
report('privileged_login_without_mfa', login.status_code == 200 and not login.json().get('mfa_required'), http_status=login.status_code)
client.cookies.clear()
r = call('POST', '/secure/readiness-check', json={})
report('empty_readiness_passes', r.status_code == 200 and r.json().get('can_proceed'), http_status=r.status_code)
evt = ok(call('POST', '/events', mgr, json={'title':'Synthetic exam', 'slug':'exam-'+nonce}))
session_body = {'title':'Synthetic session', 'duration_minutes':120, 'window_starts_at':(now-timedelta(minutes=2)).isoformat(), 'window_ends_at':(now+timedelta(hours=3)).isoformat(), 'is_seb_required':False}
sess = ok(call('POST', f"/events/{evt['id']}/sessions", mgr, json=session_body))
r = call('POST', f"/events/{evt['id']}/sessions", mgr, json={**session_body, 'title':'Foreign round', 'round_id':foreign_round_id})
report('foreign_round_without_category_accepted', r.status_code == 201, http_status=r.status_code)
q = ok(call('POST', '/authoring/questions', mgr, json={'question_code':'q-'+nonce, 'question_type':'multiple_choice_single', 'content_html':'Synthetic question', 'options':[{'id':'A','text':'A','is_correct':True},{'id':'B','text':'B'}]}))
r = call('POST', '/authoring/questions', mgr, json={'question_code':'duplicate-'+nonce, 'question_type':'multiple_choice_single', 'content_html':'Synthetic', 'options':[{'id':'A','text':'A','is_correct':True},{'id':'A','text':'B'}]})
report('duplicate_option_ids_accepted', r.status_code == 201, http_status=r.status_code)
form = ok(call('POST', '/authoring/forms', mgr, json={'session_id':sess['id'], 'title':'Form', 'question_version_ids':[q['id']], 'max_score':100}))
r = call('POST', f"/authoring/forms/{form['id']}/freeze", headers['author'])
report('author_can_freeze_exam_form', r.status_code == 200, http_status=r.status_code)

def participant(label, event=evt):
    with SessionLocal() as db:
        p = Participant(organizer_id=org_id, participant_number=nonce+label, full_name='Synthetic '+label, email='participant@example.com')
        db.add(p); db.flush()
        enr = Enrollment(event_id=event['id'], participant_id=p.id, credential_slug='credential-'+nonce+label, access_code_hash=hash_password('SYNTH7'))
        db.add(enr); db.commit()
        enr_id, slug = enr.id, enr.credential_slug
    data = ok(call('POST', '/runner/auth/lookup', json={'event_slug':event['slug'], 'credential_slug':slug, 'access_code':'SYNTH7'}))
    return enr_id, slug, {'Authorization':'Bearer '+data['runner_token']}

enr, slug, runner = participant('first')
r = call('POST', f"/runner/sessions/{sess['id']}/start", runner)
att = ok(r)['attempt_id']
report('draft_event_unfrozen_session_can_start', r.status_code == 200, event_status=evt['status'], session_frozen=sess['is_frozen'], http_status=r.status_code)
regenerated = call('POST', f"/events/{evt['id']}/enrollments/{enr}/regenerate-credentials", mgr)
sync = call('GET', f'/runner/attempts/{att}/sync', runner)
report('old_runner_survives_credential_rotation', regenerated.status_code == 200 and sync.status_code == 200, rotate_status=regenerated.status_code, old_token_sync_status=sync.status_code)
payload = {'question_id':q['id'], 'revision_number':1, 'answer_data':{'selected_option_id':'A'}, 'client_timestamp':now.isoformat()}
save = call('POST', f'/runner/attempts/{att}/autosave', {**runner, 'Idempotency-Key':'audit-replay'}, json=payload)
ok(save)
ok(call('POST', f'/runner/attempts/{att}/submit', runner))
replay = call('POST', f'/runner/attempts/{att}/autosave', {**runner, 'Idempotency-Key':'audit-replay'}, json=payload)
report('accepted_save_retry_after_submit_rejected', replay.status_code == 400, original_status=save.status_code, replay_status=replay.status_code)
_, _, runner2 = participant('ongoing')
att2 = ok(call('POST', f"/runner/sessions/{sess['id']}/start", runner2))['attempt_id']
request = ok(call('POST', f"/results/sessions/{sess['id']}/publication-request", mgr))
ok(call('POST', f"/results/publication-requests/{request['approval_id']}/approve", headers['organizer_owner'], json={'notes':'Synthetic approval'}))
pub = call('POST', f"/results/sessions/{sess['id']}/publish", mgr, json={'snapshot_hash':request['snapshot_hash'], 'is_public':True})
public = call('GET', f"/results/sessions/{sess['id']}/public")
report('publication_while_attempt_active_and_visibility_not_approved', pub.status_code == 200 and public.status_code == 200, publish_status=pub.status_code, public_status=public.status_code, active_attempts_excluded=1)
paused = call('POST', f'/proctor/attempts/{att2}/actions', mgr, json={'action_type':'pause_attempt','reason':'Synthetic audit pause'})
report('pause_available_despite_D06', paused.status_code == 200, http_status=paused.status_code)
# Valid base64 but NOT a JPEG. No fixture-only invalid-base64 fallback is used.
image = 'data:image/jpeg;base64,' + base64.b64encode(b'not an image').decode()
uploads = [call('POST', f'/runner/attempts/{att2}/proctoring/upload-still', runner2, json={'image_base64':image,'challenge_token':'nonexistent','evidence_type':'arbitrary_type'}) for _ in range(7)]
report('invalid_challenge_nonjpeg_unbounded_captures', all(r.status_code == 200 for r in uploads), accepted=sum(r.status_code == 200 for r in uploads), supplied_challenge='nonexistent')
large = call('POST', f'/runner/attempts/{att2}/proctoring/upload-still', runner2, json={'image_base64':'data:image/jpeg;base64,'+base64.b64encode(b'x'*1_048_577).decode()})
report('over_one_mib_upload_accepted', large.status_code == 200, http_status=large.status_code, decoded_bytes=1_048_577)
# Standard HTTP client calculates ConfigKey solely from the downloaded XML plist.
with SessionLocal() as db:
    event = db.get(Event, evt['id']); event.status = 'published'
    session = db.get(ExamSession, sess['id']); session.is_seb_required = True; session.is_frozen = True
    db.add(SEBConfiguration(event_id=evt['id'], config_version='synthetic', config_key='synthetic-unused-key', is_active=True))
    db.commit()
_, secure_slug, _ = participant('secure')
launch = ok(call('POST', '/secure/launch-authorizations', json={'event_slug':evt['slug'], 'credential_slug':secure_slug,'access_code':'SYNTH7','device_fingerprint':'synthetic-http-client','launcher_version':'99.0.0'}))
config_path = f"/secure/launch-authorizations/{launch['launch_authorization_id']}/config.seb?token={launch['launch_token']}"
config = call('GET', config_path)
assert config.status_code == 200
key = calculate_configuration_key(plistlib.loads(config.content))
validation_path = f"/secure/launch-authorizations/{launch['launch_authorization_id']}/validate?token={launch['launch_token']}"
proof = calculate_seb_config_key_hash('http://testserver/api/v1'+validation_path, key)
redemption = call('GET', validation_path, {'X-SafeExamBrowser-ConfigKeyHash':proof})
secure_runner = {'Authorization':'Bearer '+ok(redemption)['runner_token']}
secure_start = call('POST', f"/runner/sessions/{sess['id']}/start", secure_runner)
report('ordinary_http_forges_seb_context_from_downloaded_plist', redemption.status_code == 200 and secure_start.status_code == 200, redeem_status=redemption.status_code, start_without_seb_header_status=secure_start.status_code)
# Save-submit interleaving: pause only SQL scheduling before answer INSERT.
# No business functions, auth dependencies, or result calculation are replaced.
with SessionLocal() as db:
    db.get(ExamSession, sess['id']).is_seb_required = False; db.commit()
_, _, race_runner = participant('race')
race_att = ok(call('POST', f"/runner/sessions/{sess['id']}/start", race_runner))['attempt_id']
insert_reached = threading.Event(); release_insert = threading.Event()
def before_insert(conn, cursor, statement, params, context, executemany):
    if statement.startswith('INSERT INTO answers') and params.get('attempt_id') == race_att:
        insert_reached.set()
        if not release_insert.wait(15):
            raise RuntimeError('Audit scheduling barrier timed out')
sql_event.listen(engine, 'before_cursor_execute', before_insert)
try:
    with ThreadPoolExecutor(max_workers=2) as pool:
        future = pool.submit(call, 'POST', f'/runner/attempts/{race_att}/autosave', {**race_runner,'Idempotency-Key':'race'}, json=payload)
        assert insert_reached.wait(10)
        submitted = call('POST', f'/runner/attempts/{race_att}/submit', race_runner)
        release_insert.set()
        late_save = future.result(timeout=15)
    with SessionLocal() as db:
        status = db.get(Attempt, race_att).status
        grade = db.query(GradeRevision).filter_by(attempt_id=race_att).one().score
        count = db.query(Answer).filter_by(attempt_id=race_att).count()
    report('save_ack_after_submit_does_not_match_grade', submitted.status_code == 200 and late_save.status_code == 200 and grade == 0 and count == 1, submit_status=submitted.status_code, save_status=late_save.status_code, attempt_status=status, grade=grade, persisted_answers=count)
finally:
    release_insert.set(); sql_event.remove(engine, 'before_cursor_execute', before_insert)
print(json.dumps({'source':'45e16ba86cb35df5b8e36084c62237174790ee1c','at_utc':datetime.now(timezone.utc).isoformat(),'environment':'disposable PostgreSQL + TestClient + memory evidence','probes':rows}, indent=2))
assert all(row['gap_reproduced'] for row in rows), 'Some known-gap observations changed; inspect output'
