import shutil

import tempfile

from pathlib import Path

import pytest

from minisweagent.environments.extra.bubblewrap import BubblewrapEnvironment, BubblewrapEnvironmentConfig

@pytest.mark.skipif(not shutil.which("bwrap"), reason="bubblewrap not available")

def test_bubblewrap_environment_basic_execution():

    """Test basic command execution in bubblewrap environment."""

    env = BubblewrapEnvironment()

    try:

        result = env.execute({"command": "echo 'hello world'"})

        print(f"test_bubblewrap_environment_basic_execution result: {result}")

        assert result["returncode"] == 0

        assert "hello world" in result["output"]

    finally:

        env.cleanup()

@pytest.mark.skipif(not shutil.which("bwrap"), reason="bubblewrap not available")

def test_bubblewrap_environment_set_env_variables():

    """Test setting environment variables in the bubblewrap environment."""

    env = BubblewrapEnvironment(env={"TEST_VAR": "test_value", "ANOTHER_VAR": "another_value"})

    try:

        # Test single environment variable

        result = env.execute({"command": "echo $TEST_VAR"})

        print(f"test_bubblewrap_environment_set_env_variables result (single var): {result}")

        assert result["returncode"] == 0

        assert "test_value" in result["output"]

        # Test multiple environment variables

        result = env.execute({"command": "echo $TEST_VAR $ANOTHER_VAR"})

        print(f"test_bubblewrap_environment_set_env_variables result (multiple vars): {result}")

        assert result["returncode"] == 0

        assert "test_value another_value" in result["output"]

    finally:

        env.cleanup()

@pytest.mark.skipif(not shutil.which("bwrap"), reason="bubblewrap not available")

def test_bubblewrap_environment_custom_cwd():

    """Test executing commands in a custom working directory."""

    with tempfile.TemporaryDirectory() as temp_dir:

        env = BubblewrapEnvironment(cwd=temp_dir)

        try:

            result = env.execute({"command": "pwd"})

            print(f"test_bubblewrap_environment_custom_cwd result: {result}")

            assert result["returncode"] == 0

            assert temp_dir in result["output"]

        finally:

            env.cleanup()

@pytest.mark.skipif(not shutil.which("bwrap"), reason="bubblewrap not available")

def test_bubblewrap_environment_cwd_parameter_override():

    """Test that the cwd parameter in execute() overrides the config cwd."""

    with tempfile.TemporaryDirectory() as temp_dir1, tempfile.TemporaryDirectory() as temp_dir2:

        env = BubblewrapEnvironment(cwd=temp_dir1)

        try:

            # Execute with different cwd parameter

            result = env.execute({"command": "pwd"}, cwd=temp_dir2)

            print(f"test_bubblewrap_environment_cwd_parameter_override result: {result}")

            assert result["returncode"] == 0

            assert temp_dir2 in result["output"]

        finally:

            env.cleanup()

@pytest.mark.skipif(not shutil.which("bwrap"), reason="bubblewrap not available")

def test_bubblewrap_environment_command_failure():

    """Test that command failures are properly captured."""

    env = BubblewrapEnvironment()

    try:

        result = env.execute({"command": "exit 1"})

        print(f"test_bubblewrap_environment_command_failure result: {result}")

        assert result["returncode"] == 1

        assert result["output"] == ""

    finally:

        env.cleanup()

@pytest.mark.skipif(not shutil.which("bwrap"), reason="bubblewrap not available")

def test_bubblewrap_environment_nonexistent_command():

    """Test execution of non-existent command."""

    env = BubblewrapEnvironment()

    try:

        result = env.execute({"command": "nonexistent_command_12345"})

        print(f"test_bubblewrap_environment_nonexistent_command result: {result}")

        assert result["returncode"] != 0

        assert "nonexistent_command_12345" in result["output"] or "command not found" in result["output"]

    finally:

        env.cleanup()

@pytest.mark.skipif(not shutil.which("bwrap"), reason="bubblewrap not available")

def test_bubblewrap_environment_stderr_capture():

    """Test that stderr is properly captured."""

    env = BubblewrapEnvironment()

    try:

        result = env.execute({"command": "echo 'error message' >&2"})

        print(f"test_bubblewrap_environment_stderr_capture result: {result}")

        assert result["returncode"] == 0

        assert "error message" in result["output"]

    finally:

        env.cleanup()

@pytest.mark.skipif(not shutil.which("bwrap"), reason="bubblewrap not available")

def test_bubblewrap_environment_timeout():

    """Test timeout functionality returns structured output instead of raising."""

    env = BubblewrapEnvironment(timeout=1)

    try:

        result = env.execute({"command": "sleep 2"})

        assert result["returncode"] == -1

        assert "timed out" in result["exception_info"]

        assert result["extra"]["exception_type"] == "TimeoutExpired"

    finally:

        env.cleanup()

@pytest.mark.skipif(not shutil.which("bwrap"), reason="bubblewrap not available")

@pytest.mark.parametrize(

    ("command", "expected_returncode"),

    [

        ("echo 'test'", 0),

        ("exit 1", 1),

        ("exit 42", 42),

    ],

)

def test_bubblewrap_environment_return_codes(command, expected_returncode):

    """Test that various return codes are properly captured."""

    env = BubblewrapEnvironment()

    try:

        result = env.execute({"command": command})

        print(f"test_bubblewrap_environment_return_codes result (cmd: {command}): {result}")

        assert result["returncode"] == expected_returncode

    finally:

        env.cleanup()

@pytest.mark.skipif(not shutil.which("bwrap"), reason="bubblewrap not available")

def test_bubblewrap_environment_multiline_output():

    """Test handling of multiline command output."""

    env = BubblewrapEnvironment()

    try:

        result = env.execute({"command": "echo -e 'line1\\nline2\\nline3'"})

        print(f"test_bubblewrap_environment_multiline_output result: {result}")

        assert result["returncode"] == 0

        output_lines = result["output"].strip().split("\n")

        assert len(output_lines) == 3

        assert "line1" in output_lines[0]

        assert "line2" in output_lines[1]

        assert "line3" in output_lines[2]

    finally:

        env.cleanup()

@pytest.mark.skipif(not shutil.which("bwrap"), reason="bubblewrap not available")

def test_bubblewrap_environment_file_operations():

    """Test file operations in the bubblewrap environment."""

    with tempfile.TemporaryDirectory() as temp_dir:

        env = BubblewrapEnvironment(cwd=temp_dir)

        try:

            # Create a file

            result = env.execute({"command": "echo 'test content' > test.txt"})

            print(f"test_bubblewrap_environment_file_operations result (create file): {result}")

            assert result["returncode"] == 0

            # Read the file

            result = env.execute({"command": "cat test.txt"})

            print(f"test_bubblewrap_environment_file_operations result (read file): {result}")

            assert result["returncode"] == 0

            assert "test content" in result["output"]

            # Verify file exists (should be in the working directory)

            test_file = Path(temp_dir) / "test.txt"

            assert test_file.exists()

            assert test_file.read_text().strip() == "test content"

        finally:

            env.cleanup()

@pytest.mark.skipif(not shutil.which("bwrap"), reason="bubblewrap not available")

def test_bubblewrap_environment_working_directory_creation():

    """Test that working directory is properly created."""

    env = BubblewrapEnvironment()

    try:

        assert env.working_dir.exists()

        assert env.working_dir.is_dir()

    finally:

        env.cleanup()

@pytest.mark.skipif(not shutil.which("bwrap"), reason="bubblewrap not available")

def test_bubblewrap_environment_cleanup():

    """Test that cleanup properly removes working directory."""

    env = BubblewrapEnvironment()

    working_dir = env.working_dir

    assert working_dir.exists()

    env.cleanup()

    assert not working_dir.exists()

def test_bubblewrap_environment_custom_executable():

    """Test custom bubblewrap executable configuration."""

    config = BubblewrapEnvironmentConfig(executable="/custom/path/to/bwrap")

    env = BubblewrapEnvironment(**config.__dict__)

    try:

        assert env.config.executable == "/custom/path/to/bwrap"

    finally:

        env.cleanup()

def test_bubblewrap_environment_custom_wrapper_args():

    """Test custom wrapper args configuration."""

    custom_args = ["--ro-bind", "/usr", "/usr", "--tmpfs", "/tmp"]

    config = BubblewrapEnvironmentConfig(wrapper_args=custom_args)

    env = BubblewrapEnvironment(**config.__dict__)

    try:

        assert env.config.wrapper_args == custom_args

    finally:

        env.cleanup()

def test_bubblewrap_environment_get_template_vars():

    """Test get_template_vars method returns expected data."""

    env = BubblewrapEnvironment(env={"TEST_VAR": "test_value"})

    try:

        template_vars = env.get_template_vars()

        print(f"test_bubblewrap_environment_get_template_vars template_vars: {template_vars}")

        # Should contain config data

        assert "env" in template_vars

        assert template_vars["env"]["TEST_VAR"] == "test_value"

        assert "timeout" in template_vars

        assert template_vars["timeout"] == 30

        # Should contain platform info

        assert "system" in template_vars

        assert "machine" in template_vars

    finally:

        env.cleanup()