"""Transparent loopback Ollama recorder. No response or model parameter is synthesized."""
import datetime as dt
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import importlib.util
import json
from pathlib import Path
import threading
import time
import urllib.error
import urllib.request
import uuid

OUT=Path(__file__).resolve().parent
spec=importlib.util.spec_from_file_location('task_runtime',OUT/'task-runtime-env.py')
runtime=importlib.util.module_from_spec(spec)
spec.loader.exec_module(runtime)
upstream=json.loads((OUT/'ollama-readiness.json').read_text(encoding='utf-8'))['endpoint']
port=runtime.available_port()
stop=runtime.LAB/'control/stop-model-recorder'
authorized=runtime.LAB/'control/generation-authorized'
phase_file=runtime.LAB/'control/current-case'
phase_file.write_text('preparation',encoding='utf-8')
ALLOWED={'/','/api/version','/api/tags','/api/show','/api/ps','/api/chat','/api/generate'}
class Handler(BaseHTTPRequestHandler):
    protocol_version='HTTP/1.0'
    def log_message(self,*args):
        return
    def do_HEAD(self):self.forward()
    def do_GET(self):self.forward()
    def do_POST(self):self.forward()
    def forward(self):
        path=self.path.split('?',1)[0]
        phase=phase_file.read_text(encoding='utf-8').strip()
        if phase not in {'preparation','primary','boundary'}:
            phase='unknown'
        exchange=OUT/'model-exchanges'/phase/uuid.uuid4().hex
        exchange.mkdir(parents=True)
        body=self.rfile.read(int(self.headers.get('Content-Length','0')))
        (exchange/'request.body.bin').write_bytes(body)
        start=time.monotonic()
        metadata={'startedAt':dt.datetime.now(dt.timezone.utc).isoformat(),'method':self.command,'path':path,'phase':phase,'generation':path in {'/api/chat','/api/generate'},'requestHeadersRetained':False,'forwardedUnchanged':True}
        try:
            if path not in ALLOWED or (metadata['generation'] and not authorized.exists()):
                metadata.update({'httpStatus':403,'blockedBy':'task-recorder','reason':'generation-not-yet-authorized' if metadata['generation'] else 'unexpected-provider-route','forwardedUnchanged':False})
                data=json.dumps({'error':'Task recorder authorization boundary'}).encode()
                self.send_response(403)
                self.send_header('Content-Type','application/json')
                self.end_headers()
                self.wfile.write(data)
                (exchange/'response.body.bin').write_bytes(data)
                return
            request=urllib.request.Request(upstream+self.path,data=body if self.command=='POST' else None,method=self.command,headers={'Content-Type':self.headers.get('Content-Type','application/json')})
            try:
                response=urllib.request.urlopen(request,timeout=300)
            except urllib.error.HTTPError as error:
                response=error
            with response:
                metadata['httpStatus']=response.status
                self.send_response(response.status)
                self.send_header('Content-Type',response.headers.get('Content-Type','application/json'))
                self.send_header('Connection','close')
                self.end_headers()
                with (exchange/'response.body.bin').open('wb') as capture:
                    while True:
                        chunk=response.read1(16384)
                        if not chunk:break
                        capture.write(chunk)
                        self.wfile.write(chunk)
                        self.wfile.flush()
        except Exception as error:
            metadata['errorType']=type(error).__name__
            metadata['error']=str(error)
        finally:
            metadata['finishedAt']=dt.datetime.now(dt.timezone.utc).isoformat()
            metadata['durationSeconds']=round(time.monotonic()-start,4)
            (exchange/'metadata.json').write_text(json.dumps(metadata,indent=2),encoding='utf-8')
server=ThreadingHTTPServer(('127.0.0.1',port),Handler)
record={'endpoint':f'http://127.0.0.1:{port}','upstream':upstream,'generationEmbargo':'No actual model generation forwarded until task-only authorization marker exists','parameterMutation':False,'headerCapture':False,'streaming':'Provider response chunks relayed unchanged and retained; no manufactured response'}
(OUT/'model-recorder-readiness.json').write_text(json.dumps(record,indent=2),encoding='utf-8')
thread=threading.Thread(target=server.serve_forever,daemon=True)
thread.start()
print(json.dumps(record,indent=2),flush=True)
while not stop.exists():time.sleep(0.5)
server.shutdown()
server.server_close()
thread.join(timeout=5)
print(json.dumps({'recorderStopped':True}),flush=True)
