"""Run only trusted watchdog fixtures on host; no candidate generations."""
import importlib.util
import json
import os
from pathlib import Path
import sys
import tempfile
import unittest
ROOT=Path(__file__).resolve().parents[1]
sys.path.insert(0,str(ROOT))
spec=importlib.util.spec_from_file_location('smolscript_watchdog',ROOT/'sandbox/supervisor.py')
watchdog=importlib.util.module_from_spec(spec);spec.loader.exec_module(watchdog)

class WatchdogTests(unittest.TestCase):
    def fixture(self,d,source):
        request=Path(d)/'request.json';request.write_text(json.dumps({'kind':'dom','scenarios':[{},{}]}))
        worker=Path(d)/'fixture.py';worker.write_text(source)
        return request,worker
    def test_candidate_timeout_preserves_syntax_and_completed_scenarios(self):
        with tempfile.TemporaryDirectory() as d:
            request,worker=self.fixture(d,'''import json,os,time
from pathlib import Path
Path(os.environ['SMOLSCRIPT_WORKER_STATE']).write_text(json.dumps({'phase':'candidate','scenario':1,'syntax_success':True,'observations':[{'actual':['ok'],'baseline':[None],'error':None}]}))
while True: time.sleep(1)
''')
            result=watchdog.supervise(request,worker,startup_seconds=2,candidate_seconds=.1,total_seconds=3)
            self.assertTrue(result['syntax_success']);self.assertTrue(result['candidate_timeout'])
            self.assertEqual(result['observations'][0]['actual'],['ok'])
            self.assertIn('CandidateTimeout',result['observations'][1]['error'])
    def test_startup_hang_is_infrastructure_failure(self):
        with tempfile.TemporaryDirectory() as d:
            request,worker=self.fixture(d,'import time\ntime.sleep(60)\n')
            with self.assertRaisesRegex(RuntimeError,'setup; evaluation incomplete'):
                watchdog.supervise(request,worker,startup_seconds=.1,total_seconds=2)
    def test_normal_return_and_infrastructure_error(self):
        with tempfile.TemporaryDirectory() as d:
            request,worker=self.fixture(d,'print(\'{"syntax_success":false,"observations":[]}\')')
            self.assertFalse(watchdog.supervise(request,worker)['syntax_success'])
            worker.write_text('print(\'{"infrastructure_error":"Chromium missing"}\')')
            with self.assertRaisesRegex(RuntimeError,'Chromium missing'):watchdog.supervise(request,worker)
    def test_program_does_not_use_browser_startup_deadline(self):
        with tempfile.TemporaryDirectory() as d:
            request,worker=self.fixture(d,'import time\ntime.sleep(.25)\nprint(\'{"syntax_success":true,"observations":[]}\')')
            request.write_text('{"kind":"scalar"}')
            result=watchdog.supervise(request,worker,startup_seconds=.05,total_seconds=2)
            self.assertTrue(result['syntax_success'])
    def test_browser_runner_records_timeout_as_failed_task(self):
        from runners.common import BrowserRunner
        class Sandbox:
            def run(self,payload,timeout):
                return {'syntax_success':True,'candidate_timeout':True,'observations':[
                    {'actual':[],'baseline':[],'error':'CandidateTimeout: execution exceeded wall time'}]}
        row={'language':'javascript','timeout_seconds':3,'metadata':{'family':'dom','fixture':'<p id="x">0</p>'}}
        result=BrowserRunner().evaluate(row,'function setup() {}',
            {'tests':[{'checks':[{'kind':'text','selector':'#x','value':'1'}]}]},Sandbox())
        self.assertTrue(result['syntax_success']);self.assertFalse(result['passed'])
        self.assertTrue(result['candidate_timeout']);self.assertIn('CandidateTimeout',result['tests'][0]['error'])

    def test_worker_environment_excludes_credentials(self):
        with tempfile.TemporaryDirectory() as d:
            request,worker=self.fixture(d,'import json,os\nprint(json.dumps({"secret":os.environ.get("SMOLSCRIPT_TEST_SECRET")}))')
            from unittest.mock import patch
            with patch.dict(os.environ,SMOLSCRIPT_TEST_SECRET='never-pass-to-worker'):
                self.assertIsNone(watchdog.supervise(request,worker)['secret'])
    def test_css_injection_is_synchronous_and_does_not_wait_for_load(self):
        from unittest.mock import Mock
        sys.path.insert(0,str(ROOT/'runners'))
        spec=importlib.util.spec_from_file_location('worker_injection_test',ROOT/'sandbox/worker.py')
        worker=importlib.util.module_from_spec(spec);spec.loader.exec_module(worker)
        page=Mock()
        worker.inject_css(page,'p { color: red; }')
        page.add_style_tag.assert_not_called()
        source,css=page.evaluate.call_args.args
        self.assertEqual(css,'p { color: red; }')
        self.assertIn('style.textContent=css',source)
        self.assertNotIn('Promise',source);self.assertNotIn('onload',source)
    def test_setup_timeout_identifies_exact_operation(self):
        with tempfile.TemporaryDirectory() as d:
            request,worker=self.fixture(d,'''import json,os,time
from pathlib import Path
Path(os.environ['SMOLSCRIPT_WORKER_STATE']).write_text(json.dumps({'phase':'fixture_setup','scenario':0,'operation':'base_css'}))
time.sleep(60)
''')
            with self.assertRaisesRegex(RuntimeError,'operation=base_css'):
                watchdog.supervise(request,worker,startup_seconds=.15,total_seconds=3)
    def test_worker_has_writable_private_home_and_xdg_paths(self):
        with tempfile.TemporaryDirectory() as d:
            request,worker=self.fixture(d,'''import json,os
from pathlib import Path
for key in ('HOME','XDG_CACHE_HOME','XDG_CONFIG_HOME','TMPDIR'):
    (Path(os.environ[key])/('probe-'+key)).write_text('ok')
print(json.dumps({'home':os.environ['HOME']}))
''')
            self.assertEqual(watchdog.supervise(request,worker)['home'],str(Path(d).resolve()))

    def test_readonly_request_is_separate_from_writable_workspace(self):
        with tempfile.TemporaryDirectory() as d:
            inputs=Path(d)/'input';inputs.mkdir()
            work=Path(d)/'work';work.mkdir()
            request,worker=self.fixture(inputs,'''import json,os
from pathlib import Path
Path('artifact').write_text('ok')
print(json.dumps({'cwd':os.getcwd(),'home':os.environ['HOME']}))
''')
            request.chmod(0o444);inputs.chmod(0o555)
            try:result=watchdog.supervise(request,worker,workspace=work)
            finally:inputs.chmod(0o755)
            self.assertEqual(result['cwd'],str(work.resolve()));self.assertEqual(result['home'],str(work.resolve()))
            self.assertTrue((work/'artifact').exists());self.assertFalse((inputs/'artifact').exists())

    def test_missing_layout_target_does_not_wait_on_locator_evaluate(self):
        sys.path.insert(0,str(ROOT/'runners'))
        spec=importlib.util.spec_from_file_location('worker_layout_test',ROOT/'sandbox/worker.py')
        worker=importlib.util.module_from_spec(spec);spec.loader.exec_module(worker)
        class Locator:
            def count(self):return 0
            def evaluate(self,*args):raise AssertionError('should not wait')
        class Page:
            def locator(self,*args):return Locator()
        self.assertIn('error',worker.observe(Page(),{'selector':'#absent','kind':'layout_row'}))

if __name__=='__main__':unittest.main()