import re
import json
import os
from pathlib import Path
import subprocess

import pytest
import yaml

from dlb.registry import load_registry


ENVIRONMENT_DIR = Path("envs")
EXPECTED_ENVIRONMENTS = {
    "dlb-flm",
    "dlb-langflow",
    "dlb-duo",
    "dlb-mdlm",
    "dlb-candi",
    "dlb-rdlm",
    "dlb-sdtt",
    "dlb-di4c",
    "dlb-eval",
}


@pytest.fixture
def registry():
    return load_registry(Path("configs/experiments.yaml"))


def load_environments():
    return {
        path.stem: yaml.safe_load(path.read_text())
        for path in sorted(ENVIRONMENT_DIR.glob("*.yml"))
        if not path.name.startswith(".")
    }


def pip_dependencies(environment):
    return next(
        dependency["pip"]
        for dependency in environment["dependencies"]
        if isinstance(dependency, dict) and "pip" in dependency
    )


def conda_dependencies(environment):
    return [
        dependency
        for dependency in environment["dependencies"]
        if isinstance(dependency, str)
    ]


def pinned_pip_dependencies(environment):
    return {
        package.split("==", 1)[0]: package.split("==", 1)[1]
        for package in pip_dependencies(environment)
        if "==" in package
    }


def test_all_declared_environments_exist(registry):
    environments = load_environments()
    names = {environment["name"] for environment in environments.values()}

    assert {model.environment for model in registry.models.values()} <= names
    assert names == EXPECTED_ENVIRONMENTS


def test_gpu_environments_pin_python_torch_and_cuda_strategy():
    for environment in load_environments().values():
        dependencies = environment["dependencies"]
        rendered_dependencies = "\n".join(
            dependency if isinstance(dependency, str) else ""
            for dependency in dependencies
        )
        pip_packages = "\n".join(pip_dependencies(environment))

        assert re.search(r"^python=", rendered_dependencies, re.MULTILINE)
        assert "torch==" in pip_packages or re.search(
            r"^pytorch=", rendered_dependencies, re.MULTILINE
        )
        assert re.search(r"^pytorch-cuda=", rendered_dependencies, re.MULTILINE)
        assert environment["channels"]


def test_special_upstream_constraints_are_explicit():
    environments = load_environments()

    assert "flash-attn==2.8.3" not in pip_dependencies(environments["flm"])
    assert "flash-attn==2.7.4.post1" not in pip_dependencies(environments["duo"])
    assert "python=3.9" in environments["rdlm"]["dependencies"]
    assert "pytorch=2.3.1" in environments["rdlm"]["dependencies"]
    assert all("nightly" not in package for package in pip_dependencies(environments["sdtt"]))
    assert "torchdata==0.8.0" in pip_dependencies(environments["sdtt"])


def test_conda_pytorch_environments_do_not_override_its_torch_stack_with_pip():
    for environment in load_environments().values():
        assert all(
            not package.startswith(("torch==", "torchvision==", "triton=="))
            for package in pip_dependencies(environment)
        )

    for name in {"flm", "duo", "mdlm", "sdtt", "di4c"}:
        assert "torchvision=0.20.1" in load_environments()[name]["dependencies"]


def test_conda_pytorch_environments_pin_mkl_before_ijit_regression():
    for name, environment in load_environments().items():
        dependencies = conda_dependencies(environment)
        if any(dependency.startswith("pytorch=") for dependency in dependencies):
            assert "mkl<2024.1" in dependencies, name
        assert not any(
            dependency.startswith("intel-openmp=2024.0") for dependency in dependencies
        )


def test_upstream_entrypoint_dependencies_are_explicit():
    environments = load_environments()

    assert "rich==14.2.0" in pip_dependencies(environments["flm"])
    assert "rich==13.7.1" in pip_dependencies(environments["duo"])
    assert "rich==13.7.1" in pip_dependencies(environments["mdlm"])
    assert "rich==14.2.0" in pip_dependencies(environments["candi"])


def test_project_runtime_dependencies_are_available_in_every_environment():
    for name, environment in load_environments().items():
        packages = pinned_pip_dependencies(environment)
        assert packages["pydantic"] == "2.12.4", name
        assert packages["pyyaml"] == "6.0.2", name


def test_langflow_environment_includes_conditional_prompt_data_dependencies():
    """Catch conditional runs failing before LangFlow loads because datasets is absent."""

    packages = pinned_pip_dependencies(load_environments()["langflow"])

    assert packages["datasets"] == "3.6.0"
    assert packages["fsspec"] == "2025.3.0"
    assert packages["pyarrow"] == "20.0.0"


def test_python39_pydantic_environments_include_annotation_backport():
    environments = load_environments()

    for name in {"mdlm", "rdlm"}:
        packages = pinned_pip_dependencies(environments[name])
        assert packages["eval-type-backport"] == "0.2.2"


def test_sdtt_family_includes_pkg_resources_provider_for_legacy_imports():
    environments = load_environments()

    for name in {"sdtt", "di4c"}:
        assert "setuptools==80.9.0" in pip_dependencies(environments[name])
        assert "nltk==3.9.1" in pip_dependencies(environments[name])


def test_known_pinned_dependency_pairs_use_compatible_versions():
    environments = load_environments()
    compatibility_matrix = {
        ("duo", "datasets", "2.15.0", "fsspec"): {"2023.10.0"},
        ("candi", "numpy", "1.24.3", "scipy"): {"1.11.4"},
    }

    for (environment, left, left_version, right), compatible_versions in (
        compatibility_matrix.items()
    ):
        packages = pinned_pip_dependencies(environments[environment])
        assert packages[left] == left_version
        assert packages[right] in compatible_versions


def test_mdlm_defers_source_only_cuda_extensions_until_torch_is_available():
    dependencies = pip_dependencies(load_environments()["mdlm"])

    assert not any(package.startswith("causal-conv1d==") for package in dependencies)
    assert not any(package.startswith("mamba-ssm==") for package in dependencies)


@pytest.fixture
def fake_conda(tmp_path):
    command = tmp_path / "fake-conda"
    command.write_text(
        """#!/usr/bin/env python3
import json
import os
from pathlib import Path
import sys

arguments = sys.argv[1:]
with Path(os.environ["FAKE_CONDA_LOG"]).open("a") as log:
    log.write(json.dumps(arguments) + "\\n")

if arguments == ["env", "list", "--json"]:
    mode = os.environ.get("FAKE_ENV_LIST_MODE", "")
    if mode == "failure":
        raise SystemExit(23)
    if mode == "malformed":
        print("not-json")
        raise SystemExit(0)
    if mode == "wrong_type":
        print(json.dumps([]))
        raise SystemExit(0)
    if mode == "foreign":
        print(json.dumps({"envs": ["/foreign/dlb-langflow"]}))
        raise SystemExit(0)
    print(json.dumps({"envs": os.environ.get("FAKE_ENVS", "").split(os.pathsep)}))
    raise SystemExit(0)

if arguments == ["info", "--json"]:
    mode = os.environ.get("FAKE_INFO_MODE", "")
    if mode == "failure":
        raise SystemExit(23)
    if mode == "malformed":
        print("not-json")
        raise SystemExit(0)
    print(json.dumps({"envs_dirs": ["/opt/conda/envs"]}))
    raise SystemExit(0)

failure = os.environ.get("FAKE_FAIL_SUBSTRING", "")
if failure and any(failure in argument for argument in arguments):
    failure_stderr = os.environ.get("FAKE_FAIL_STDERR")
    if failure_stderr:
        print(failure_stderr, file=sys.stderr)
    raise SystemExit(23)

if arguments[:1] == ["run"]:
    if arguments[3:5] == ["python", "-c"]:
        print("2.5.1 12.4")
        raise SystemExit(0)
    if arguments[3:6] == ["python", "-m", "pip"]:
        raise SystemExit(0)
    if os.environ.get("FAKE_DROP_RUN_STDIN") and arguments[4] == "-":
        sys.stdin.read()
        raise SystemExit(0)
    if arguments[4] == "-":
        probe_source = sys.stdin.read()
    else:
        probe_source = Path(arguments[4]).read_text()
    output = os.environ.get("FAKE_PROBE_OUTPUT")
    if output is not None:
        print(output)
    else:
        modules = arguments[6:]
        payload = {
            "environment": arguments[5],
            "python": "3.11",
            "torch": "2.5.1",
            "torch_cuda": "12.4",
            "cuda_available": True,
            "imports": {module: True for module in modules},
        }
        if os.environ.get("FAKE_UNHEALTHY_PROBE"):
            payload["imports"][modules[0]] = False
            payload["import_errors"] = {modules[0]: "simulated import failure"}
        print("DLB_ENV_PROBE_V1:" + json.dumps(payload, sort_keys=True))
        if (
            os.environ.get("FAKE_APPEND_CONDA_DIAGNOSTIC")
            and "raise SystemExit(0)" not in probe_source
        ):
            print("CondaError: child process exited with status 1", file=sys.stderr)
            raise SystemExit(23)
"""
    )
    command.chmod(0o755)
    return command


def run_script(script_name, fake_conda, tmp_path, names, **extra_environment):
    log = tmp_path / "conda.log"
    environment = {
        **os.environ,
        "DLB_CONDA": str(fake_conda),
        "DLB_ENV_NAMES": ",".join(names),
        "FAKE_CONDA_LOG": str(log),
        **extra_environment,
    }
    completed = subprocess.run(
        ["bash", str(ENVIRONMENT_DIR / script_name)],
        cwd=Path.cwd(),
        env=environment,
        text=True,
        capture_output=True,
    )
    calls = [json.loads(line) for line in log.read_text().splitlines()] if log.exists() else []
    return completed, calls


def test_create_all_creates_absent_environment_then_installs_flash_attention(
    fake_conda, tmp_path
):
    completed, calls = run_script("create_all.sh", fake_conda, tmp_path, ["dlb-flm"])

    assert completed.returncode == 0, completed.stderr
    create_call = next(call for call in calls if call[:3] == ["env", "create", "--file"])
    assert Path(create_call[3]).name == "flm.yml"
    assert [
        "run",
        "-n",
        "dlb-flm",
        "python",
        "-m",
        "pip",
        "install",
        "flash-attn==2.7.4.post1",
        "--no-build-isolation",
    ] in calls


def test_create_all_checks_torch_import_before_flash_attention(fake_conda, tmp_path):
    completed, calls = run_script("create_all.sh", fake_conda, tmp_path, ["dlb-duo"])

    assert completed.returncode == 0, completed.stderr
    torch_import_call = next(
        call for call in calls
        if call[:5] == ["run", "-n", "dlb-duo", "python", "-c"]
        and "import torch" in call[5]
    )
    flash_install_call = [
        "run",
        "-n",
        "dlb-duo",
        "python",
        "-m",
        "pip",
        "install",
        "flash-attn==2.7.4.post1",
        "--no-build-isolation",
    ]
    assert calls.index(torch_import_call) < calls.index(flash_install_call)


def test_create_all_installs_mdlm_cuda_extensions_from_git_after_torch(
    fake_conda, tmp_path
):
    completed, calls = run_script("create_all.sh", fake_conda, tmp_path, ["dlb-mdlm"])

    assert completed.returncode == 0, completed.stderr
    torch_import_call = next(
        call for call in calls
        if call[:5] == ["run", "-n", "dlb-mdlm", "python", "-c"]
        and "import torch" in call[5]
    )
    extension_install_call = [
        "run",
        "-n",
        "dlb-mdlm",
        "python",
        "-m",
        "pip",
        "install",
        "--no-build-isolation",
        "git+https://github.com/Dao-AILab/causal-conv1d.git@v1.1.3.post1",
        "git+https://github.com/state-spaces/mamba.git@v1.1.4",
    ]
    assert calls.index(torch_import_call) < calls.index(extension_install_call)


def test_create_all_updates_existing_environment_without_pruning(fake_conda, tmp_path):
    completed, calls = run_script(
        "create_all.sh",
        fake_conda,
        tmp_path,
        ["dlb-langflow"],
        FAKE_ENVS="/opt/conda/envs/dlb-langflow",
    )

    assert completed.returncode == 0, completed.stderr
    update_call = next(call for call in calls if call[:3] == ["env", "update", "--file"])
    assert Path(update_call[3]).name == "langflow.yml"
    assert update_call == [
        "env",
        "update",
        "--file",
        update_call[3],
    ]


def test_create_all_reports_failures_but_continues_other_environments(fake_conda, tmp_path):
    completed, calls = run_script(
        "create_all.sh",
        fake_conda,
        tmp_path,
        ["dlb-langflow", "dlb-eval"],
        FAKE_FAIL_SUBSTRING="langflow.yml",
    )

    assert completed.returncode != 0
    assert "dlb-langflow" in completed.stderr
    assert any(
        call[:3] == ["env", "create", "--file"] and Path(call[3]).name == "eval.yml"
        for call in calls
    )


@pytest.mark.parametrize(
    ("environment_variable", "value"),
    [
        ("FAKE_ENV_LIST_MODE", "malformed"),
        ("FAKE_ENV_LIST_MODE", "wrong_type"),
        ("FAKE_ENV_LIST_MODE", "failure"),
        ("FAKE_INFO_MODE", "malformed"),
        ("FAKE_INFO_MODE", "failure"),
        ("FAKE_ENV_LIST_MODE", "foreign"),
    ],
)
def test_create_all_refuses_unreliable_environment_discovery(
    fake_conda, tmp_path, environment_variable, value
):
    completed, calls = run_script(
        "create_all.sh",
        fake_conda,
        tmp_path,
        ["dlb-langflow"],
        **{environment_variable: value},
    )

    assert completed.returncode != 0
    assert "discovery" in completed.stderr
    assert not any(call[:2] == ["env", "create"] for call in calls)


def test_create_all_distinguishes_exact_existing_name_from_absence(fake_conda, tmp_path):
    existing, existing_calls = run_script(
        "create_all.sh",
        fake_conda,
        tmp_path,
        ["dlb-langflow"],
        FAKE_ENVS="/opt/conda/envs/dlb-langflow",
    )
    absent, absent_calls = run_script(
        "create_all.sh", fake_conda, tmp_path, ["dlb-langflow"]
    )

    assert existing.returncode == 0
    assert any(call[:2] == ["env", "update"] for call in existing_calls)
    assert absent.returncode == 0
    assert any(call[:2] == ["env", "create"] for call in absent_calls)


def test_verify_all_emits_json_for_each_environment_and_fails_in_aggregate(
    fake_conda, tmp_path
):
    completed, calls = run_script(
        "verify_all.sh",
        fake_conda,
        tmp_path,
        ["dlb-langflow", "dlb-duo"],
        FAKE_FAIL_SUBSTRING="dlb-duo",
    )

    records = [json.loads(line) for line in completed.stdout.splitlines()]
    assert completed.returncode != 0
    assert records[0]["environment"] == "dlb-langflow"
    assert records[0]["cuda_available"] is True
    assert "torchvision" in calls[-1]
    assert "flash_attn" in calls[-1]
    assert "rich" in calls[-1]
    assert records[1] == {
        "environment": "dlb-duo",
        "python": None,
        "torch": None,
        "torch_cuda": None,
        "cuda_available": False,
        "imports": {},
        "error": "verification probe failed",
    }


def test_verify_all_debug_mode_reports_probe_manager_stderr(fake_conda, tmp_path):
    completed, _ = run_script(
        "verify_all.sh",
        fake_conda,
        tmp_path,
        ["dlb-duo"],
        DLB_VERIFY_DEBUG="1",
        FAKE_FAIL_SUBSTRING="dlb-duo",
        FAKE_FAIL_STDERR="simulated native loader failure",
    )

    records = [json.loads(line) for line in completed.stdout.splitlines()]
    assert completed.returncode != 0
    assert records[0]["error"] == "verification probe failed"
    assert "conda run exited with status 23" in records[0]["diagnostic"]
    assert "simulated native loader failure" in records[0]["diagnostic"]


def test_verify_all_does_not_depend_on_manager_forwarding_stdin(fake_conda, tmp_path):
    completed, calls = run_script(
        "verify_all.sh",
        fake_conda,
        tmp_path,
        ["dlb-duo"],
        FAKE_DROP_RUN_STDIN="1",
    )

    assert completed.returncode == 0, completed.stderr
    run_call = next(call for call in calls if call[:3] == ["run", "-n", "dlb-duo"])
    assert run_call[3] == "python"
    assert run_call[4] != "-"


@pytest.mark.parametrize(
    "probe_output",
    [
        "run -n dlb-langflow python",
        "noise\nDLB_ENV_PROBE_V1:{}",
        "DLB_ENV_PROBE_V1:not-json",
    ],
)
def test_verify_all_rejects_untrusted_manager_stdout(fake_conda, tmp_path, probe_output):
    completed, _ = run_script(
        "verify_all.sh",
        fake_conda,
        tmp_path,
        ["dlb-langflow"],
        FAKE_PROBE_OUTPUT=probe_output,
    )

    records = [json.loads(line) for line in completed.stdout.splitlines()]
    assert completed.returncode != 0
    assert records == [
        {
            "environment": "dlb-langflow",
            "python": None,
            "torch": None,
            "torch_cuda": None,
            "cuda_available": False,
            "imports": {},
            "error": "verification probe failed",
        }
    ]


@pytest.mark.parametrize(
    "payload",
    [
        '{"environment":"dlb-langflow","python":"3.11","torch":NaN,"torch_cuda":"12.4","cuda_available":true,"imports":{"einops":true,"huggingface_hub":true,"safetensors":true,"transformers":true}}',
        '{"environment":"dlb-langflow","python":"3.11","torch":"2.5.1","torch_cuda":Infinity,"cuda_available":true,"imports":{"einops":true,"huggingface_hub":true,"safetensors":true,"transformers":true}}',
        '{"environment":"dlb-langflow","python":"3.11","torch":"2.5.1","torch_cuda":"12.4","cuda_available":true,"imports":{"einops":true,"huggingface_hub":true,"safetensors":true,"transformers":true},"unexpected":true}',
        '{"environment":"dlb-langflow","python":"3.11","torch":"2.5.1","torch_cuda":"12.4","cuda_available":true,"imports":{"einops":true,"huggingface_hub":true,"safetensors":true,"transformers":true,"unexpected":true}}',
        '{"environment":"dlb-langflow","python":"3.11","torch":"2.5.1","torch_cuda":"12.4","cuda_available":1,"imports":{"einops":true,"huggingface_hub":true,"safetensors":true,"transformers":true}}',
        '{"environment":"dlb-langflow","python":"3.11","torch":"2.5.1","torch_cuda":"12.4","cuda_available":true,"imports":{"einops":true,"einops":false,"huggingface_hub":true,"safetensors":true,"transformers":true}}',
        '{"environment":"dlb-langflow","python":"3.11","torch":"2.5.1","torch_cuda":"12.4","cuda_available":true,"imports":{"einops":true,"huggingface_hub":true,"safetensors":true}}',
    ],
    ids=[
        "nan",
        "infinity",
        "unknown-top-level-field",
        "unknown-import-field",
        "bool-as-int",
        "duplicate-requested-import",
        "missing-requested-import",
    ],
)
def test_verify_all_rejects_invalid_probe_schema(fake_conda, tmp_path, payload):
    completed, _ = run_script(
        "verify_all.sh",
        fake_conda,
        tmp_path,
        ["dlb-langflow"],
        FAKE_PROBE_OUTPUT="DLB_ENV_PROBE_V1:" + payload,
    )

    records = [json.loads(line) for line in completed.stdout.splitlines()]
    assert completed.returncode != 0
    assert records == [
        {
            "environment": "dlb-langflow",
            "python": None,
            "torch": None,
            "torch_cuda": None,
            "cuda_available": False,
            "imports": {},
            "error": "verification probe failed",
        }
    ]
    assert "NaN" not in completed.stdout
    assert "Infinity" not in completed.stdout


def test_verify_all_preserves_unhealthy_probe_when_manager_adds_diagnostic(
    fake_conda, tmp_path
):
    completed, _ = run_script(
        "verify_all.sh",
        fake_conda,
        tmp_path,
        ["dlb-langflow"],
        FAKE_UNHEALTHY_PROBE="1",
        FAKE_APPEND_CONDA_DIAGNOSTIC="1",
    )

    records = [json.loads(line) for line in completed.stdout.splitlines()]
    assert completed.returncode != 0
    assert records[0]["imports"]["datasets"] is False
    assert records[0]["import_errors"] == {"datasets": "simulated import failure"}
    assert "CondaError" not in completed.stdout
    assert "CondaError" not in completed.stderr


def test_verify_all_rejects_echo_manager_output(fake_conda, tmp_path):
    completed, _ = run_script(
        "verify_all.sh", fake_conda, tmp_path, ["dlb-langflow"], DLB_CONDA="/bin/echo"
    )

    records = [json.loads(line) for line in completed.stdout.splitlines()]
    assert completed.returncode != 0
    assert records[0]["error"] == "verification probe failed"


def test_verify_all_rejects_flash_attention_without_required_torch_triton_api(
    fake_conda, tmp_path
):
    payload = {
        "environment": "dlb-flm",
        "python": "3.11",
        "torch": "2.5.1",
        "torch_cuda": "12.4",
        "cuda_available": True,
        "imports": {
            module: True
            for module in [
                "datasets",
                "einops",
                "entmax",
                "flash_attn",
                "fsspec",
                "huggingface_hub",
                "hydra",
                "lightning",
                "numpy",
                "omegaconf",
                "pydantic",
                "requests",
                "rich",
                "scipy",
                "timm",
                "tokenizers",
                "torchmetrics",
                "tqdm",
                "transformers",
                "triton",
                "wandb",
                "yaml",
            ]
        },
        "runtime_checks": {"flash_attn_torch_wrap_triton": False},
        "runtime_errors": {
            "flash_attn_torch_wrap_triton": (
                "flash-attn 2.8.3 requires torch.library.wrap_triton"
            )
        },
    }
    completed, _ = run_script(
        "verify_all.sh",
        fake_conda,
        tmp_path,
        ["dlb-flm"],
        FAKE_PROBE_OUTPUT="DLB_ENV_PROBE_V1:" + json.dumps(payload, sort_keys=True),
    )

    records = [json.loads(line) for line in completed.stdout.splitlines()]
    assert completed.returncode != 0
    assert records[0]["runtime_checks"]["flash_attn_torch_wrap_triton"] is False
    assert "wrap_triton" in records[0]["runtime_errors"]["flash_attn_torch_wrap_triton"]


def test_verify_all_escapes_unknown_environment_names(fake_conda, tmp_path):
    completed, _ = run_script(
        "verify_all.sh", fake_conda, tmp_path, ['bad"name']
    )

    records = [json.loads(line) for line in completed.stdout.splitlines()]
    assert completed.returncode != 0
    assert records[0]["environment"] == 'bad"name'
    assert records[0]["error"] == "unknown environment"


def test_verify_all_checks_the_complete_method_import_mapping(fake_conda, tmp_path):
    project_runtime_imports = {"pydantic", "yaml"}
    expected_imports = {
        "dlb-flm": {
            "datasets", "einops", "entmax", "flash_attn", "fsspec", "huggingface_hub",
            "hydra", "lightning", "numpy", "omegaconf", "requests", "rich", "scipy",
            "timm", "tokenizers", "torchmetrics", "tqdm", "transformers", "triton", "wandb",
        },
        "dlb-langflow": {
            "datasets", "einops", "fsspec", "huggingface_hub", "pyarrow",
            "safetensors", "transformers",
        },
        "dlb-duo": {
            "datasets", "einops", "flash_attn", "fsspec", "h5py", "huggingface_hub",
            "hydra", "lightning", "numpy", "omegaconf", "requests", "rich", "scipy", "timm",
            "tokenizers", "torchmetrics", "torchvision", "tqdm", "transformers", "triton", "wandb",
        },
        "dlb-mdlm": {
            "causal_conv1d", "datasets", "einops", "eval_type_backport", "flash_attn",
            "fsspec", "huggingface_hub", "hydra", "lightning", "mamba_ssm", "numpy",
            "omegaconf", "requests", "rich", "timm", "tokenizers", "torchmetrics",
            "transformers", "wandb",
        },
        "dlb-candi": {
            "datasets", "einops", "evaluate", "flash_attn", "fsspec", "huggingface_hub", "hydra",
            "lightning", "numpy", "omegaconf", "requests", "rich", "scipy", "tokenizers", "torchmetrics",
            "tqdm", "transformers",
        },
        "dlb-rdlm": {
            "accelerate", "datasets", "einops", "eval_type_backport", "fsspec",
            "huggingface_hub", "hydra", "numpy", "omegaconf", "requests", "scipy",
            "tokenizers", "tqdm", "transformers", "wandb",
        },
        "dlb-sdtt": {
            "datasets", "einops", "flash_attn", "fsspec", "huggingface_hub", "hydra", "lightning",
            "loguru", "mauve", "nltk", "numpy", "omegaconf", "pandas", "requests", "safetensors",
            "tensorboard", "timm", "tokenizers", "torchdata", "tqdm", "transformers", "wandb",
        },
        "dlb-di4c": {
            "datasets", "einops", "flash_attn", "fsspec", "huggingface_hub", "hydra", "lightning",
            "loguru", "mauve", "nltk", "numpy", "omegaconf", "pandas", "requests", "safetensors",
            "tensorboard", "timm", "tokenizers", "torchdata", "tqdm", "transformers", "wandb",
        },
        "dlb-eval": {"accelerate", "datasets", "evaluate", "fsspec", "mauve", "sacrebleu", "scipy", "tokenizers", "transformers"},
    }
    expected_imports = {
        environment: modules | project_runtime_imports
        for environment, modules in expected_imports.items()
    }
    completed, calls = run_script(
        "verify_all.sh", fake_conda, tmp_path, list(expected_imports)
    )

    assert completed.returncode == 0, completed.stderr
    requested_imports = {}
    for call in calls:
        if call[:1] != ["run"]:
            continue
        assert call[:2] == ["run", "-n"]
        assert call[3] == "python"
        assert call[4] != "-"
        manager_environment = call[2]
        probe_environment = call[5]
        assert manager_environment == probe_environment
        assert manager_environment in expected_imports
        assert manager_environment not in requested_imports
        raw_modules = call[6:]
        assert len(raw_modules) == len(set(raw_modules))
        requested_imports[manager_environment] = set(raw_modules)

    assert set(requested_imports) == set(expected_imports)
    for environment, expected_modules in expected_imports.items():
        assert requested_imports[environment] == expected_modules


def test_pack_all_writes_archives_without_removing_environment(fake_conda, tmp_path):
    packer = tmp_path / "fake-conda-pack"
    packer.write_text(
        """#!/usr/bin/env python3
import pathlib
import sys
output = pathlib.Path(sys.argv[sys.argv.index("-o") + 1])
output.write_bytes(b"archive")
"""
    )
    packer.chmod(0o755)
    artifact_dir = tmp_path / "artifacts"

    completed, calls = run_script(
        "pack_all.sh",
        fake_conda,
        tmp_path,
        ["dlb-langflow"],
        DLB_CONDA_PACK=str(packer),
        DLB_ARTIFACT_DIR=str(artifact_dir),
    )

    assert completed.returncode == 0, completed.stderr
    assert (artifact_dir / "dlb-langflow.tar.gz").read_bytes() == b"archive"
    assert all("remove" not in call for call in calls)


def test_pack_all_rejects_a_non_file_destination_before_atomic_publication(
    fake_conda, tmp_path
):
    packer = tmp_path / "fake-conda-pack"
    packer.write_text(
        """#!/usr/bin/env python3
import pathlib
import sys
output = pathlib.Path(sys.argv[sys.argv.index("-o") + 1])
output.write_bytes(b"archive")
"""
    )
    packer.chmod(0o755)
    artifact_dir = tmp_path / "artifacts"
    (artifact_dir / "dlb-langflow.tar.gz").mkdir(parents=True)

    completed, _ = run_script(
        "pack_all.sh",
        fake_conda,
        tmp_path,
        ["dlb-langflow"],
        DLB_CONDA_PACK=str(packer),
        DLB_ARTIFACT_DIR=str(artifact_dir),
    )

    assert completed.returncode != 0
    assert not (artifact_dir / "dlb-langflow.tar.gz" / "dlb-langflow.tar.gz").exists()