"""Offline dependency and frozen-spawn smoke test, with no camera/model access."""
import json
import multiprocessing
from monitor_runtime.paths import data, resource, atomic_json

def spawn_probe(queue):
    import numpy as np
    import cv2
    queue.put({'resized': list(cv2.resize(np.zeros((4,4,3),dtype=np.uint8),(2,2)).shape)})

def run():
    from monitor_runtime.bootstrap import prepare_files, initialize_database
    prepare_files()
    initialize_database()
    import django
    import cv2
    import numpy as np
    import torch
    import torchvision
    import onnxruntime
    import openvino as ov
    from ultralytics import YOLO
    from ultralytics.utils import USER_CONFIG_DIR
    assert USER_CONFIG_DIR.resolve().is_relative_to(data('').resolve())
    import pystray
    import whitenoise
    result = {'django':django.get_version(),'opencv':cv2.__version__,'torch':torch.__version__,
              'torchvision':torchvision.__version__,'onnxruntime':onnxruntime.__version__,
              'openvino':ov.__version__}
    assert torch.version.cuda is None
    assert (torch.ones(2,2) @ torch.ones(2,2)).tolist() == [[2.,2.],[2.,2.]]
    assert 'CPUExecutionProvider' in onnxruntime.get_available_providers()
    # Architecture-only random weights: no model download, no customer model or pickle.
    detector = YOLO('yolo26n.yaml', task='detect')
    predictions = detector.predict(np.zeros((64,64,3), dtype=np.uint8), imgsz=64, device='cpu', verbose=False)
    assert len(predictions) == 1 and predictions[0].orig_shape == (64,64)
    result['yolo_cpu_inference'] = 'passed (random weights; no accuracy claim)'
    parameter = ov.opset13.parameter([1],np.float32)
    model = ov.Model([ov.opset13.relu(parameter)],[parameter])
    compiled = ov.Core().compile_model(model,'CPU')
    assert float(compiled([np.array([-1],dtype=np.float32)])[0][0]) == 0
    ctx=multiprocessing.get_context('spawn')
    queue=ctx.Queue()
    process=ctx.Process(target=spawn_probe,args=(queue,))
    process.start()
    try:
        assert queue.get(timeout=60)['resized']==[2,2,3]
        process.join(timeout=20)
        assert process.exitcode==0
    finally:
        if process.is_alive():
            process.terminate()
            process.join(timeout=10)
        queue.close()
    from django.test import Client
    client=Client(HTTP_HOST='localhost')
    response=client.get('/setup',REMOTE_ADDR='127.0.0.1')
    assert response.status_code in (200,403)
    assert resource('public-static/lib/js/app.js').is_file()
    assert resource('zlm/monitor_zlm.exe').is_file()
    assert resource('tools/ffmpeg.exe').is_file()
    from monitor_runtime.licensing import machine_identity
    assert machine_identity()['fingerprint'].startswith('v1:')
    result.update(status='passed',spawn='passed',cpu='passed',resources='passed',
                  writable_caches='ProgramData/test data root')
    atomic_json(data('.runtime/self-test.json'),result)
    return 0