"""Trusted worker watchdog; distinguish startup failures from candidate hangs."""
import json
import os
from pathlib import Path
import signal
import subprocess
import sys
import tempfile
import time


def supervise(request, worker='/opt/smolscript/worker.py', worker_uid=None, worker_gid=None,
              startup_seconds=45, candidate_seconds=None, total_seconds=240, workspace=None):
    request=Path(request).resolve()
    workspace=Path(workspace).resolve() if workspace is not None else request.parent
    payload=json.loads(request.read_text())
    if candidate_seconds is None:candidate_seconds=max(6,3*payload.get('timeout_seconds',3))
    with tempfile.TemporaryDirectory(dir=workspace,prefix='watchdog-') as directory:
        os.chmod(directory,0o777)
        state_path=Path(directory)/'state.json'
        env={k:v for k,v in os.environ.items() if k in ('PATH','HOME','LANG','LC_ALL','TZ','PYTHONHASHSEED','PYTHONPATH','PLAYWRIGHT_BROWSERS_PATH')}
        env['SMOLSCRIPT_WORKER_STATE']=str(state_path)
        env['HOME']=str(workspace)
        for key,name in (('XDG_CACHE_HOME','cache'),('XDG_CONFIG_HOME','config'),('TMPDIR','tmp')):
            target=Path(directory)/name;target.mkdir(mode=0o777);target.chmod(0o777);env[key]=str(target)
        credentials={}
        if worker_uid is not None:credentials.update(user=worker_uid,group=worker_gid,extra_groups=[])
        with tempfile.TemporaryFile() as stdout,tempfile.TemporaryFile() as stderr:
            process=subprocess.Popen([sys.executable,str(worker),str(request)],cwd=workspace,
                stdout=stdout,stderr=stderr,env=env,start_new_session=True,**credentials)
            started=time.monotonic();phase_started=started;previous=None;state={}
            try:
                while process.poll() is None:
                    try:state=json.loads(state_path.read_text())
                    except (FileNotFoundError,json.JSONDecodeError):pass
                    phase=(state.get('phase'),state.get('scenario'),state.get('operation'))
                    if phase!=previous:previous=phase;phase_started=time.monotonic()
                    now=time.monotonic()
                    candidate=state.get('phase')=='candidate' and not payload.get('diagnostic')
                    browser=payload.get('diagnostic') or payload.get('kind') in ('html','css','dom')
                    limit=(candidate_seconds if candidate else startup_seconds) if browser else total_seconds
                    if now-phase_started>limit or now-started>total_seconds:
                        if candidate and isinstance(state.get('syntax_success'),bool):
                            observations=list(state.get('observations',[]))
                            for _ in range(len(payload.get('scenarios',[]))-len(observations)):
                                observations.append({'actual':[],'baseline':[],
                                    'error':'CandidateTimeout: browser execution exceeded its wall-time limit'})
                            return {'syntax_success':state['syntax_success'],'observations':observations,'candidate_timeout':True}
                        stderr.seek(0)
                        detail=stderr.read(2000).decode('utf8','replace')
                        raise RuntimeError('SmolScript worker timed out during browser/runtime setup; evaluation incomplete; '
                            f"phase={state.get('phase','worker_start')} operation={state.get('operation')} "
                            f"scenario={state.get('scenario')} language={payload.get('language',payload.get('kind'))}; stderr={detail}")
                    try:process.wait(timeout=.1)
                    except subprocess.TimeoutExpired:pass
                stdout.seek(0);stderr.seek(0)
                if process.returncode:
                    raise RuntimeError('SmolScript sandbox worker failed: '+stderr.read(2000).decode('utf8','replace'))
                response=json.loads(stdout.read(8*1024*1024))
                if response.get('infrastructure_error'):raise RuntimeError(response['infrastructure_error'])
                return response
            finally:
                # Kill descendants even if the worker exited but left children alive.
                try:os.killpg(process.pid,signal.SIGKILL)
                except ProcessLookupError:pass
                process.wait(timeout=5)

if __name__=='__main__':
    try:response=supervise(sys.argv[1],workspace=Path.cwd())
    except Exception as exc:response={'infrastructure_error':type(exc).__name__+': '+str(exc)[:2000]}
    print(json.dumps(response,allow_nan=False))