"""Path-loading regression tests for the actual Audio8 0.1B runtime.
Run: python3 test_manifest_paths.py [baseline|candidate]
Mocks cover model contracts/tokenizer/voices only; separate CPU tests use real ORT.
"""
import contextlib, io, json, sys, tempfile, unittest
from pathlib import Path
from unittest.mock import patch
import numpy as np
import onnx
from onnx import helper, TensorProto
sys.path.insert(0, str(Path.cwd() / "onnx_runtime_0_1b_int8"))
from arktts_runtime import runtime as rt

class Session:
    def get_inputs(self): return []
    def get_outputs(self): return []

FIELDS=[("slow_decode_models","int8"),("fast_models","int8"),
        ("codec_models","fp16"),("slow_decode_model",None),("fast_model",None)]

class Paths(unittest.TestCase):
    def setUp(self):
        self.temp=tempfile.TemporaryDirectory()
        self.base=Path(self.temp.name)
        self.root=self.base/"package";self.root.mkdir()
        self.other=self.base/"package-other";self.other.mkdir()
        (self.other/"outside.onnx").write_bytes(b"outside")
        for name in ["slow_ar_int8.onnx","fast_ar_int8.onnx","codec_decoder_fp16.onnx"]:
            (self.root/name).write_bytes(b"inside")
        (self.root/"nested").mkdir()
        (self.root/"nested"/"inside.onnx").write_bytes(b"inside")
        (self.root/"escape.onnx").symlink_to(self.other/"outside.onnx")
        (self.root/"escape-dir").symlink_to(self.other,target_is_directory=True)
        (self.root/"inside-link.onnx").symlink_to(self.root/"slow_ar_int8.onnx")
        self.manifest={"default_precision":"int8","available_precisions":["int8"],
                       "default_codec_precision":"fp16","available_codec_precisions":["fp16"],
                       "semantic_begin_id":0,"num_codebooks":10}
        self.calls=[]
    def tearDown(self): self.temp.cleanup()
    def construct(self):
        (self.root/"runtime_manifest.json").write_text(json.dumps(self.manifest))
        def session(path,*args):
            self.calls.append(Path(path).resolve())
            return Session()
        with patch.object(rt,"_session",side_effect=session), patch.object(rt.ArkTtsRuntime,"_validate_contract"), patch.object(rt,"PromptBuilder"), patch.object(rt,"VoiceStore"):
            rt.ArkTtsRuntime(self.root,self.base/"voices")
    def assign(self,field,key,value):
        self.manifest[field]={key:value} if key else value
    def test_default_paths(self):
        self.construct()
        self.assertEqual(len(self.calls),3)
        self.assertTrue(all(p.is_relative_to(self.root) for p in self.calls))
    def test_nested_paths(self):
        for field,key in FIELDS[:3]:self.assign(field,key,"nested/inside.onnx")
        self.construct()
        self.assertTrue(all(p==self.root/"nested/inside.onnx" for p in self.calls))
    def test_inside_symlink(self):
        self.assign("slow_decode_models","int8","inside-link.onnx")
        self.construct();self.assertEqual(self.calls[0],self.root/"slow_ar_int8.onnx")
    def test_root_symlink(self):
        alias=self.base/"alias";alias.symlink_to(self.root,target_is_directory=True)
        self.root=alias
        self.construct();self.assertEqual(len(self.calls),3)
    def test_real_cpu_session(self):
        model=helper.make_model(helper.make_graph(
            [helper.make_node("Identity",["x"],["y"])],"path-test",
            [helper.make_tensor_value_info("x",TensorProto.FLOAT,[1])],
            [helper.make_tensor_value_info("y",TensorProto.FLOAT,[1])]),
            opset_imports=[helper.make_opsetid("",13)],ir_version=9)
        path=self.root/"toy.onnx";onnx.save(model,str(path))
        result=rt._session(path,1).run(None,{"x":np.array([3],dtype=np.float32)})
        self.assertEqual(result[0].tolist(),[3.0])
    def test_missing_session_file(self):
        with self.assertRaises(FileNotFoundError):rt._session(self.root/"absent.onnx")

def rejection(field,key,kind):
    def test(self):
        values={"parent":"../package-other/outside.onnx",
          "absolute":str(self.other/"outside.onnx"),
          "symlink_file":"escape.onnx","symlink_dir":"escape-dir/outside.onnx",
          "nested_parent":"nested/../../package-other/outside.onnx",
          "windows_absolute":r"C:\outside.onnx","windows_drive":r"C:outside.onnx",
          "unc":r"\\server\share\outside.onnx","backslash":r"..\outside.onnx",
          "empty":"","null":None,"number":123,"nul":"bad\x00.onnx"}
        self.assign(field,key,values[kind])
        with self.assertRaises(ValueError):self.construct()
        self.assertEqual(self.calls,[],"all paths must be validated before any session")
    return test
for field,key in FIELDS:
    for kind in ["parent","absolute","symlink_file","symlink_dir","nested_parent","windows_absolute","windows_drive","unc","backslash","empty","null","number","nul"]:
        setattr(Paths,"test_reject_"+field+"_"+kind,rejection(field,key,kind))

if __name__=="__main__":
    label=sys.argv[1] if len(sys.argv)>1 else "candidate"
    stream=io.StringIO()
    result=unittest.TextTestRunner(stream=stream,verbosity=2).run(unittest.defaultTestLoader.loadTestsFromTestCase(Paths))
    Path(label+"-tests.log").write_text(stream.getvalue())
    report={"label":label,"total":result.testsRun,"passed":result.testsRun-len(result.failures)-len(result.errors),
        "failed":len(result.failures),"errors":len(result.errors),
        "failures":[str(t) for t,_ in result.failures],"errorTests":[str(t) for t,_ in result.errors]}
    Path(label+"-results.json").write_text(json.dumps(report,indent=2))
    print(json.dumps({k:v for k,v in report.items() if k not in ["failures","errorTests"]}))
    sys.exit(not result.wasSuccessful())