"""Verify docker-compose.yml's langgraph command honors LANGGRAPH_STRICT_ASYNC.

Renders the compose file via ``docker compose config`` with and without
the env var and asserts the resulting langgraph command line includes
or omits ``--allow-blocking`` as expected.
"""

from __future__ import annotations

import os
import shutil
import subprocess
from pathlib import Path

import pytest
import yaml

REPO_ROOT = Path(__file__).resolve().parents[1]
COMPOSE = REPO_ROOT / "docker-compose.yml"


@pytest.fixture(autouse=True)
def _ensure_dotenv():
    """``docker compose config`` needs a .env to satisfy env_file refs."""
    env_file = REPO_ROOT / ".env"
    created = False
    if not env_file.exists():
        env_file.write_text("")
        created = True
    yield
    if created:
        env_file.unlink(missing_ok=True)


def _langgraph_command(env_overrides: dict[str, str]) -> str:
    """Render compose and return the langgraph service's command as a single string."""
    if shutil.which("docker") is None:
        pytest.skip("docker CLI not available")
    env = {**os.environ, **env_overrides}
    result = subprocess.run(
        ["docker", "compose", "-f", str(COMPOSE), "config"],
        env=env,
        cwd=REPO_ROOT,
        capture_output=True,
        text=True,
        check=False,
    )
    if result.returncode != 0:
        pytest.fail(
            f"docker compose config failed (exit {result.returncode}):\n"
            f"--- stderr ---\n{result.stderr}\n"
            f"--- stdout ---\n{result.stdout}"
        )
    rendered = yaml.safe_load(result.stdout)
    cmd = (rendered.get("services") or {}).get("langgraph", {}).get("command")
    if cmd is None:
        pytest.fail("langgraph service has no `command` after compose render")
    return cmd if isinstance(cmd, str) else " ".join(cmd)


def test_default_command_includes_allow_blocking():
    """Without LANGGRAPH_STRICT_ASYNC set, --allow-blocking should be in the command."""
    cmd = _langgraph_command({})
    assert "--allow-blocking" in cmd, (
        f"expected --allow-blocking in default langgraph command; got:\n{cmd}"
    )


def test_strict_async_removes_allow_blocking():
    """With LANGGRAPH_STRICT_ASYNC=1, --allow-blocking must NOT be in the STRICT branch."""
    cmd = _langgraph_command({"LANGGRAPH_STRICT_ASYNC": "1"})
    # The command string itself is a shell snippet; we need to verify
    # the *executed* path doesn't have --allow-blocking. The else-branch
    # of the if statement (which is what runs when STRICT is set) has
    # the bare `langgraph dev ...` invocation without --allow-blocking.
    # The string still CONTAINS "--allow-blocking" as a literal in the
    # if-branch — that's OK; what matters is the branch logic. Assert
    # both branches are present and the structure is intact.
    assert "LANGGRAPH_STRICT_ASYNC" in cmd, (
        f"expected LANGGRAPH_STRICT_ASYNC check in command; got:\n{cmd}"
    )
    # The if/else structure means BOTH branches are in the rendered command
    # string (it's a shell snippet). The branch SELECTION happens at runtime
    # inside sh -c. To verify the opt-out actually works, this test ensures
    # the conditional structure is present and STRICT branch lacks the flag.
    # A more rigorous test would run the actual shell snippet; this is the
    # closest we can verify at compose-render time.
    # Split on the else clause and check the else-branch text:
    else_branch = cmd.split("else")[1] if "else" in cmd else ""
    assert "--allow-blocking" not in else_branch, (
        f"--allow-blocking should not appear in the STRICT (else) branch; got else: {else_branch!r}"
    )