import os

import tempfile

from pathlib import Path

from unittest.mock import patch

import pytest

from minisweagent.environments.local import LocalEnvironment, LocalEnvironmentConfig

def test_local_environment_config_defaults():

    """Test that LocalEnvironmentConfig has correct default values."""

    config = LocalEnvironmentConfig()

    assert config.cwd == ""

    assert config.env == {}

    assert config.timeout == 30

def test_local_environment_basic_execution():

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

    env = LocalEnvironment()

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

    assert result["returncode"] == 0

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

def test_local_environment_set_env_variables():

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

    env = LocalEnvironment(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"]

def test_local_environment_existing_env_variables():

    """Test that existing environment variables are preserved and merged."""

    with patch.dict(os.environ, {"EXISTING_VAR": "existing_value"}):

        env = LocalEnvironment(env={"NEW_VAR": "new_value"})

        # Test that both existing and new variables are available

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

        assert result["returncode"] == 0

        assert "existing_value new_value" in result["output"]

def test_local_environment_env_variable_override():

    """Test that config env variables override existing ones."""

    with patch.dict(os.environ, {"CONFLICT_VAR": "original_value"}):

        env = LocalEnvironment(env={"CONFLICT_VAR": "override_value"})

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

        assert result["returncode"] == 0

        assert "override_value" in result["output"]

def test_local_environment_custom_cwd():

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

    with tempfile.TemporaryDirectory() as temp_dir:

        env = LocalEnvironment(cwd=temp_dir)

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

        assert result["returncode"] == 0

        assert temp_dir in result["output"]

def test_local_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 = LocalEnvironment(cwd=temp_dir1)

        # Execute with different cwd parameter

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

        assert result["returncode"] == 0

        assert temp_dir2 in result["output"]

def test_local_environment_default_cwd():

    """Test that commands use os.getcwd() when no cwd is specified."""

    env = LocalEnvironment()

    current_dir = os.getcwd()

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

    assert result["returncode"] == 0

    assert current_dir in result["output"]

def test_local_environment_command_failure():

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

    env = LocalEnvironment()

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

    assert result["returncode"] == 1

    assert result["output"] == ""

def test_local_environment_nonexistent_command():

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

    env = LocalEnvironment()

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

    assert result["returncode"] != 0

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

def test_local_environment_stderr_capture():

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

    env = LocalEnvironment()

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

    assert result["returncode"] == 0

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

def test_local_environment_timeout():

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

    env = LocalEnvironment(timeout=1)

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

    assert result["returncode"] == -1

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

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

def test_local_environment_custom_timeout():

    """Test custom timeout configuration."""

    config = LocalEnvironmentConfig(timeout=5)

    env = LocalEnvironment(**config.__dict__)

    assert env.config.timeout == 5

@pytest.mark.parametrize(

    ("command", "expected_returncode"),

    [

        ("echo 'test'", 0),

        ("exit 1", 1),

        ("exit 42", 42),

    ],

)

def test_local_environment_return_codes(command, expected_returncode):

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

    env = LocalEnvironment()

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

    assert result["returncode"] == expected_returncode

def test_local_environment_multiline_output():

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

    env = LocalEnvironment()

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

    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]

def test_local_environment_file_operations():

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

    with tempfile.TemporaryDirectory() as temp_dir:

        env = LocalEnvironment(cwd=temp_dir)

        # Create a file

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

        assert result["returncode"] == 0

        # Read the file

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

        assert result["returncode"] == 0

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

        # Verify file exists

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

        assert test_file.exists()

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

def test_local_environment_shell_features():

    """Test that shell features like pipes and redirects work."""

    env = LocalEnvironment()

    # Test pipe

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

    assert result["returncode"] == 0

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

    # Test command substitution

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

    assert result["returncode"] == 0

    assert "nested" in result["output"]