import os
import subprocess
from unittest.mock import patch

import pytest

from minisweagent.environments.singularity import SingularityEnvironment, SingularityEnvironmentConfig


def is_singularity_available():
    """Check if Singularity is available."""
    try:
        subprocess.run(["singularity", "version"], capture_output=True, check=True, timeout=5)
        return True
    except (subprocess.CalledProcessError, FileNotFoundError, subprocess.TimeoutExpired):
        return False


@pytest.mark.skipif(not is_singularity_available(), reason="Singularity not available")
def test_singularity_environment_config_defaults():
    """Test that SingularityEnvironmentConfig has correct default values."""
    config = SingularityEnvironmentConfig(image="python:3.11")

    assert config.image == "python:3.11"
    assert config.cwd == "/"
    assert config.env == {}
    assert config.forward_env == []
    assert config.timeout == 30
    assert config.executable == "singularity"


@pytest.mark.slow
@pytest.mark.skipif(not is_singularity_available(), reason="Singularity not available")
def test_singularity_environment_basic_execution():
    """Test basic command execution in Singularity container."""
    # Using a lightweight image that should be available or easily pulled
    env = SingularityEnvironment(image="docker://python:3.11-slim")

    result = env.execute({"command": "echo 'hello world'"})
    assert result["returncode"] == 0
    assert "hello world" in result["output"]


@pytest.mark.slow
@pytest.mark.skipif(not is_singularity_available(), reason="Singularity not available")
def test_singularity_environment_set_env_variables():
    """Test setting environment variables in the container."""
    env = SingularityEnvironment(
        image="docker://python:3.11-slim", env={"TEST_VAR": "test_value", "ANOTHER_VAR": "another_value"}
    )

    # Test single environment variable
    result = env.execute({"command": "echo $TEST_VAR"})
    assert result["returncode"] == 0
    assert "test_value" in result["output"]

    # Test multiple environment variables
    result = env.execute({"command": "echo $TEST_VAR $ANOTHER_VAR"})
    assert result["returncode"] == 0
    assert "test_value another_value" in result["output"]


@pytest.mark.slow
@pytest.mark.skipif(not is_singularity_available(), reason="Singularity not available")
def test_singularity_environment_forward_env_variables():
    """Test forwarding environment variables from host to container."""
    with patch.dict(os.environ, {"HOST_VAR": "host_value", "ANOTHER_HOST_VAR": "another_host_value"}):
        env = SingularityEnvironment(image="docker://python:3.11-slim", forward_env=["HOST_VAR", "ANOTHER_HOST_VAR"])

        # Test single forwarded environment variable
        result = env.execute({"command": "echo $HOST_VAR"})
        assert result["returncode"] == 0
        assert "host_value" in result["output"]

        # Test multiple forwarded environment variables
        result = env.execute({"command": "echo $HOST_VAR $ANOTHER_HOST_VAR"})
        assert result["returncode"] == 0
        assert "host_value another_host_value" in result["output"]


@pytest.mark.slow
@pytest.mark.skipif(not is_singularity_available(), reason="Singularity not available")
def test_singularity_environment_forward_nonexistent_env_variables():
    """Test forwarding non-existent environment variables (should be empty)."""
    env = SingularityEnvironment(image="docker://python:3.11-slim", forward_env=["NONEXISTENT_VAR"])

    result = env.execute({"command": 'echo "[$NONEXISTENT_VAR]"'})
    assert result["returncode"] == 0
    assert "[]" in result["output"]  # Empty variable should result in empty string


@pytest.mark.slow
@pytest.mark.skipif(not is_singularity_available(), reason="Singularity not available")
def test_singularity_environment_combined_env_and_forward():
    """Test both setting and forwarding environment variables together."""
    with patch.dict(os.environ, {"HOST_VAR": "from_host"}):
        env = SingularityEnvironment(
            image="docker://python:3.11-slim", env={"SET_VAR": "from_config"}, forward_env=["HOST_VAR"]
        )

        result = env.execute({"command": "echo $SET_VAR $HOST_VAR"})
        assert result["returncode"] == 0
        assert "from_config from_host" in result["output"]


@pytest.mark.slow
@pytest.mark.skipif(not is_singularity_available(), reason="Singularity not available")
def test_singularity_environment_env_override_forward():
    """Test that explicitly set env variables take precedence over forwarded ones."""
    with patch.dict(os.environ, {"CONFLICT_VAR": "from_host"}):
        env = SingularityEnvironment(
            image="docker://python:3.11-slim", env={"CONFLICT_VAR": "from_config"}, forward_env=["CONFLICT_VAR"]
        )

        result = env.execute({"command": "echo $CONFLICT_VAR"})
        assert result["returncode"] == 0
        # The explicitly set env should take precedence (comes after forwarded in singularity exec command)
        assert "from_config" in result["output"]


@pytest.mark.slow
@pytest.mark.skipif(not is_singularity_available(), reason="Singularity not available")
def test_singularity_environment_custom_cwd():
    """Test executing commands in a custom working directory."""
    env = SingularityEnvironment(image="docker://python:3.11-slim", cwd="/tmp")

    result = env.execute({"command": "pwd"})
    assert result["returncode"] == 0
    assert "/tmp" in result["output"]


@pytest.mark.slow
@pytest.mark.skipif(not is_singularity_available(), reason="Singularity not available")
def test_singularity_environment_cwd_parameter_override():
    """Test that the cwd parameter in execute() overrides the config cwd."""
    env = SingularityEnvironment(image="docker://python:3.11-slim", cwd="/")

    result = env.execute({"command": "pwd"}, cwd="/tmp")
    assert result["returncode"] == 0
    assert "/tmp" in result["output"]


@pytest.mark.slow
@pytest.mark.skipif(not is_singularity_available(), reason="Singularity not available")
def test_singularity_environment_command_failure():
    """Test that command failures are properly captured."""
    env = SingularityEnvironment(image="docker://python:3.11-slim")

    result = env.execute({"command": "exit 42"})
    assert result["returncode"] == 42


@pytest.mark.slow
@pytest.mark.skipif(not is_singularity_available(), reason="Singularity not available")
def test_singularity_environment_timeout():
    """Test timeout functionality returns structured output instead of raising."""
    env = SingularityEnvironment(image="docker://python:3.11-slim", timeout=1)

    result = env.execute({"command": "sleep 5"})
    assert result["returncode"] == -1
    assert "timed out" in result["exception_info"]
    assert result["extra"]["exception_type"] == "TimeoutExpired"