"""Startup regressions for the CUDA workspace warnings observed on the V100."""
import json
import os
from pathlib import Path
import subprocess
import sys
import tempfile
import unittest

PACKAGE = Path(__file__).resolve().parents[1]
VARIABLE = "CUBLAS_WORKSPACE_CONFIG"


class RuntimeTests(unittest.TestCase):
    def run_python(self, code, value=None):
        env = dict(os.environ)
        env.pop(VARIABLE, None)
        if value is not None:
            env[VARIABLE] = value
        return subprocess.run([sys.executable, "-c", code], cwd=PACKAGE,
                              env=env, capture_output=True, text=True, timeout=45)

    def test_default_configures_without_importing_torch(self):
        r = self.run_python("""
import os, sys
from s34_runtime import configure_cuda_workspace
assert configure_cuda_workspace() == ':4096:8'
assert configure_cuda_workspace() == ':4096:8'
assert os.environ['CUBLAS_WORKSPACE_CONFIG'] == ':4096:8'
assert 'torch' not in sys.modules
""")
        self.assertEqual(r.returncode, 0, r.stdout+r.stderr)

    def test_preserves_valid_explicit_settings(self):
        for value in (":4096:8", ":16:8"):
            with self.subTest(value=value):
                r = self.run_python("""
import os
from s34_runtime import configure_cuda_workspace
before = os.environ['CUBLAS_WORKSPACE_CONFIG']
assert configure_cuda_workspace() == before
assert os.environ['CUBLAS_WORKSPACE_CONFIG'] == before
""", value)
                self.assertEqual(r.returncode, 0, r.stdout+r.stderr)

    def test_invalid_or_empty_settings_fail_actionably(self):
        for value in ("", "4096:8", ":invalid:8"):
            with self.subTest(value=value):
                r = self.run_python("import check_environment", value)
                self.assertNotEqual(r.returncode, 0, r.stdout+r.stderr)
                self.assertIn("CUBLAS_WORKSPACE_CONFIG", r.stderr)
                self.assertIn(":4096:8", r.stderr)

    def test_entrypoints_configure_before_torch_import(self):
        for module in ("train_suite34", "check_environment", "s34_training", "s34_checkpoint"):
            with self.subTest(module=module):
                r = self.run_python("""
import importlib, importlib.abc, os, sys
class Guard(importlib.abc.MetaPathFinder):
    def find_spec(self, fullname, path=None, target=None):
        if fullname == 'torch':
            assert os.environ.get('CUBLAS_WORKSPACE_CONFIG') == ':4096:8', 'workspace missing before torch import'
        return None
sys.meta_path.insert(0, Guard())
importlib.import_module(%r)
assert os.environ.get('CUBLAS_WORKSPACE_CONFIG') == ':4096:8', 'workspace absent after entry point bootstrap'
""" % module)
                self.assertEqual(r.returncode, 0, r.stdout+r.stderr)

    def test_shell_exports_workspace_before_python_starts(self):
        with tempfile.TemporaryDirectory() as td:
            interpreter = Path(td)/"print_workspace.sh"
            interpreter.write_text('#!/bin/sh\nprintf "%s\\n" "${CUBLAS_WORKSPACE_CONFIG-ABSENT}"\n')
            interpreter.chmod(0o755)
            for value, expected in ((None, ":4096:8"), (":16:8", ":16:8")):
                with self.subTest(value=value):
                    env = dict(os.environ, PYTHON=str(interpreter))
                    env.pop(VARIABLE, None)
                    if value is not None:
                        env[VARIABLE] = value
                    r = subprocess.run(["bash", str(PACKAGE/"run_suite34.sh"), "--help"],
                                       env=env, capture_output=True, text=True, timeout=20)
                    self.assertEqual(r.returncode, 0, r.stdout+r.stderr)
                    self.assertEqual(r.stdout.strip(), expected)

    def test_environment_reports_effective_workspace(self):
        r = self.run_python("import check_environment; check_environment.main()", ":16:8")
        self.assertEqual(r.returncode, 0, r.stdout+r.stderr)
        events = [json.loads(line.split("] ", 1)[1]) for line in r.stdout.splitlines()
                  if line.startswith("[REPRODUCIBILITY] ")]
        self.assertEqual(len(events), 1, r.stdout)
        self.assertEqual(events[0]["cublas_workspace_config"], ":16:8")

    def test_run_metadata_records_workspace(self):
        r = self.run_python("""
from train_suite34 import environment
assert environment()['cublas_workspace_config'] == ':16:8'
""", ":16:8")
        self.assertEqual(r.returncode, 0, r.stdout+r.stderr)

    def test_cuda_forward_backward_has_no_cublas_determinism_warning(self):
        import torch
        if not torch.cuda.is_available():
            self.skipTest("CUDA hardware unavailable; forward/backward checked on server startup")
        r = self.run_python("""
import check_environment
check_environment.main()
""")
        self.assertEqual(r.returncode, 0, r.stdout+r.stderr)
        self.assertNotIn("not deterministic because it uses CuBLAS", r.stderr)
        self.assertIn('"cuda_deterministic_forward_backward": "PASS"', r.stdout)
