import re
import subprocess
import sys
from pathlib import Path
from unittest.mock import Mock, patch

import pytest

from minisweagent.run.mini import DEFAULT_CONFIG_FILE, app, main


def strip_ansi_codes(text: str) -> str:
    """Remove ANSI escape sequences from text."""
    ansi_escape = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
    return ansi_escape.sub("", text)


def test_configure_if_first_time_called():
    """Test that configure_if_first_time is called when running mini main."""
    with (
        patch("minisweagent.run.mini.configure_if_first_time") as mock_configure,
        patch("minisweagent.run.mini.InteractiveAgent") as mock_interactive_agent_class,
        patch("minisweagent.run.mini.get_model") as mock_get_model,
        patch("minisweagent.run.mini.LocalEnvironment") as mock_env,
        patch("minisweagent.run.mini.get_config_from_spec") as mock_get_config,
    ):
        # Setup mocks
        mock_model = Mock()
        mock_get_model.return_value = mock_model
        mock_environment = Mock()
        mock_env.return_value = mock_environment
        mock_get_config.return_value = {"agent": {"system_template": "test"}, "env": {}, "model": {}}

        # Setup mock agent instance
        mock_agent = Mock()
        mock_agent.run.return_value = {"exit_status": "Success", "submission": "Result"}
        mock_interactive_agent_class.return_value = mock_agent

        # Call main function
        main(
            config_spec=[str(DEFAULT_CONFIG_FILE)],
            model_name="test-model",
            task="Test task",
            yolo=False,
            output=None,
            model_class=None,
        )

        # Verify configure_if_first_time was called
        mock_configure.assert_called_once()


def test_mini_command_calls_run_interactive():
    """Test that mini command creates InteractiveAgent."""
    with (
        patch("minisweagent.run.mini.configure_if_first_time"),
        patch("minisweagent.run.mini.InteractiveAgent") as mock_interactive_agent_class,
        patch("minisweagent.run.mini.get_model") as mock_get_model,
        patch("minisweagent.run.mini.LocalEnvironment") as mock_env,
        patch("minisweagent.run.mini.get_config_from_spec") as mock_get_config,
    ):
        # Setup mocks
        mock_model = Mock()
        mock_get_model.return_value = mock_model
        mock_environment = Mock()
        mock_env.return_value = mock_environment
        mock_get_config.return_value = {"agent": {"system_template": "test", "mode": "confirm"}, "env": {}, "model": {}}

        # Setup mock agent instance
        mock_agent = Mock()
        mock_agent.run.return_value = {"exit_status": "Success", "submission": "Result"}
        mock_interactive_agent_class.return_value = mock_agent

        # Call main function with task provided (so prompt is not called)
        main(
            config_spec=[str(DEFAULT_CONFIG_FILE)],
            model_name="test-model",
            task="Test task",
            yolo=False,
            output=None,
            model_class=None,
        )

        # Verify InteractiveAgent was instantiated
        mock_interactive_agent_class.assert_called_once()
        args, kwargs = mock_interactive_agent_class.call_args
        assert args[0] == mock_model  # model
        assert args[1] == mock_environment  # env
        # Verify agent.run was called with the task
        mock_agent.run.assert_called_once_with("Test task")


def test_mini_calls_prompt_when_no_task_provided():
    """Test that mini calls prompt when no task is provided."""
    with (
        patch("minisweagent.run.mini.configure_if_first_time"),
        patch("minisweagent.run.mini._multiline_prompt") as mock_prompt,
        patch("minisweagent.run.mini.InteractiveAgent") as mock_interactive_agent_class,
        patch("minisweagent.run.mini.get_model") as mock_get_model,
        patch("minisweagent.run.mini.LocalEnvironment") as mock_env,
        patch("minisweagent.run.mini.get_config_from_spec") as mock_get_config,
    ):
        # Setup mocks
        mock_prompt.return_value = "User provided task"
        mock_model = Mock()
        mock_get_model.return_value = mock_model
        mock_environment = Mock()
        mock_env.return_value = mock_environment
        mock_get_config.return_value = {"agent": {"system_template": "test", "mode": "confirm"}, "env": {}, "model": {}}

        # Setup mock agent instance
        mock_agent = Mock()
        mock_agent.run.return_value = {"exit_status": "Success", "submission": "Result"}
        mock_interactive_agent_class.return_value = mock_agent

        # Call main function without task
        main(
            config_spec=[str(DEFAULT_CONFIG_FILE)],
            model_name="test-model",
            task=None,  # No task provided
            yolo=False,
            output=None,
            model_class=None,
        )

        # Verify prompt was called
        mock_prompt.assert_called_once()

        # Verify InteractiveAgent was instantiated
        mock_interactive_agent_class.assert_called_once()
        # Verify agent.run was called with the task from prompt
        mock_agent.run.assert_called_once_with("User provided task")


def test_mini_with_explicit_model():
    """Test that mini works with explicitly provided model."""
    with (
        patch("minisweagent.run.mini.configure_if_first_time"),
        patch("minisweagent.run.mini.InteractiveAgent") as mock_interactive_agent_class,
        patch("minisweagent.run.mini.get_model") as mock_get_model,
        patch("minisweagent.run.mini.LocalEnvironment") as mock_env,
        patch("minisweagent.run.mini.get_config_from_spec") as mock_get_config,
    ):
        # Setup mocks
        mock_model = Mock()
        mock_get_model.return_value = mock_model
        mock_environment = Mock()
        mock_env.return_value = mock_environment
        mock_get_config.return_value = {
            "agent": {"system_template": "test", "mode": "yolo"},
            "env": {},
            "model": {"default_config": "test"},
        }

        # Setup mock agent instance
        mock_agent = Mock()
        mock_agent.run.return_value = {"exit_status": "Success", "submission": "Result"}
        mock_interactive_agent_class.return_value = mock_agent

        # Call main function with explicit model
        main(
            config_spec=[str(DEFAULT_CONFIG_FILE)],
            model_name="gpt-4",
            task="Test task with explicit model",
            yolo=True,
            output=None,
            model_class=None,
        )

        # Verify get_model was called (model name is merged into config)
        mock_get_model.assert_called_once()

        # Verify InteractiveAgent was instantiated
        mock_interactive_agent_class.assert_called_once()
        # Verify agent.run was called
        mock_agent.run.assert_called_once_with("Test task with explicit model")


def test_yolo_mode_sets_correct_agent_config():
    """Test that yolo mode sets the correct agent configuration."""
    with (
        patch("minisweagent.run.mini.configure_if_first_time"),
        patch("minisweagent.run.mini.InteractiveAgent") as mock_interactive_agent_class,
        patch("minisweagent.run.mini.get_model") as mock_get_model,
        patch("minisweagent.run.mini.LocalEnvironment") as mock_env,
        patch("minisweagent.run.mini.get_config_from_spec") as mock_get_config,
    ):
        # Setup mocks
        mock_model = Mock()
        mock_get_model.return_value = mock_model
        mock_environment = Mock()
        mock_env.return_value = mock_environment
        mock_get_config.return_value = {"agent": {"system_template": "test"}, "env": {}, "model": {}}

        # Setup mock agent instance
        mock_agent = Mock()
        mock_agent.run.return_value = {"exit_status": "Success", "submission": "Result"}
        mock_interactive_agent_class.return_value = mock_agent

        # Call main function with yolo=True
        main(
            config_spec=[str(DEFAULT_CONFIG_FILE)],
            model_name="test-model",
            task="Test yolo task",
            yolo=True,
            output=None,
            model_class=None,
        )

        # Verify InteractiveAgent was called with yolo mode
        mock_interactive_agent_class.assert_called_once()
        args, kwargs = mock_interactive_agent_class.call_args
        # The agent_config should contain the mode as a keyword argument
        assert kwargs.get("mode") == "yolo"
        # Verify agent.run was called
        mock_agent.run.assert_called_once_with("Test yolo task")


def test_confirm_mode_sets_correct_agent_config():
    """Test that when yolo=False, no explicit mode is set (defaults to None)."""
    with (
        patch("minisweagent.run.mini.configure_if_first_time"),
        patch("minisweagent.run.mini.InteractiveAgent") as mock_interactive_agent_class,
        patch("minisweagent.run.mini.get_model") as mock_get_model,
        patch("minisweagent.run.mini.LocalEnvironment") as mock_env,
        patch("minisweagent.run.mini.get_config_from_spec") as mock_get_config,
    ):
        # Setup mocks
        mock_model = Mock()
        mock_get_model.return_value = mock_model
        mock_environment = Mock()
        mock_env.return_value = mock_environment
        mock_get_config.return_value = {"agent": {"system_template": "test"}, "env": {}, "model": {}}

        # Setup mock agent instance
        mock_agent = Mock()
        mock_agent.run.return_value = {"exit_status": "Success", "submission": "Result"}
        mock_interactive_agent_class.return_value = mock_agent

        # Call main function with yolo=False (default)
        main(
            config_spec=[str(DEFAULT_CONFIG_FILE)],
            model_name="test-model",
            task="Test confirm task",
            yolo=False,
            output=None,
            model_class=None,
        )

        # Verify InteractiveAgent was called with no explicit mode (defaults to None)
        mock_interactive_agent_class.assert_called_once()
        args, kwargs = mock_interactive_agent_class.call_args
        # The agent_config should not contain mode when yolo=False (defaults to None)
        assert kwargs.get("mode") is None
        # Verify agent.run was called
        mock_agent.run.assert_called_once_with("Test confirm task")


def test_mini_help():
    """Test that mini --help works correctly."""
    result = subprocess.run(
        [sys.executable, "-m", "minisweagent", "--help"],
        capture_output=True,
        text=True,
        timeout=10,
    )

    assert result.returncode == 0
    # Strip ANSI color codes for reliable text matching
    clean_output = strip_ansi_codes(result.stdout)
    assert "Run mini-SWE-agent in your local environment." in clean_output
    assert "--help" in clean_output
    assert "--config" in clean_output
    assert "--model" in clean_output
    assert "--task" in clean_output
    assert "--yolo" in clean_output
    assert "--output" in clean_output


def test_mini_help_with_typer_runner():
    """Test help functionality using typer's test runner."""
    from typer.testing import CliRunner

    runner = CliRunner()
    result = runner.invoke(app, ["--help"])

    assert result.exit_code == 0
    # Strip ANSI color codes for reliable text matching
    clean_output = strip_ansi_codes(result.stdout)
    assert "Run mini-SWE-agent in your local environment." in clean_output
    assert "--help" in clean_output
    assert "--config" in clean_output
    assert "--model" in clean_output
    assert "--task" in clean_output
    assert "--yolo" in clean_output
    assert "--output" in clean_output


def test_python_m_minisweagent_help():
    """Test that python -m minisweagent --help works correctly."""
    result = subprocess.run(
        [sys.executable, "-m", "minisweagent", "--help"],
        capture_output=True,
        text=True,
        timeout=10,
    )

    assert result.returncode == 0
    assert "mini-SWE-agent" in result.stdout


def test_mini_script_help():
    """Test that the mini script entry point help works."""
    result = subprocess.run(
        ["mini", "--help"],
        capture_output=True,
        text=True,
        timeout=10,
    )

    assert result.returncode == 0
    assert "mini-SWE-agent" in result.stdout


def test_mini_swe_agent_help():
    """Test that mini-swe-agent --help works correctly."""
    result = subprocess.run(
        ["mini-swe-agent", "--help"],
        capture_output=True,
        text=True,
        timeout=10,
    )

    assert result.returncode == 0
    clean_output = strip_ansi_codes(result.stdout)
    assert "mini-SWE-agent" in clean_output


def test_mini_extra_help():
    """Test that mini-extra --help works correctly."""
    result = subprocess.run(
        ["mini-extra", "--help"],
        capture_output=True,
        text=True,
        timeout=10,
    )

    assert result.returncode == 0
    clean_output = strip_ansi_codes(result.stdout)
    assert "central entry point for all extra commands" in clean_output
    assert "config" in clean_output
    assert "inspect" in clean_output
    assert "swebench" in clean_output


def test_mini_e_help():
    """Test that mini-e --help works correctly."""
    result = subprocess.run(
        ["mini-e", "--help"],
        capture_output=True,
        text=True,
        timeout=10,
    )

    assert result.returncode == 0
    clean_output = strip_ansi_codes(result.stdout)
    assert "central entry point for all extra commands" in clean_output


@pytest.mark.parametrize(
    ("subcommand", "aliases"),
    [
        ("config", ["config"]),
        ("inspect", ["inspect", "i", "inspector"]),
        ("swebench", ["swebench"]),
        ("swebench-single", ["swebench-single"]),
    ],
)
def test_mini_extra_subcommand_help(subcommand: str, aliases: list[str]):
    """Test that mini-extra subcommands --help work correctly."""
    for alias in aliases:
        result = subprocess.run(
            ["mini-extra", alias, "--help"],
            capture_output=True,
            text=True,
            timeout=10,
        )

        assert result.returncode == 0
        # Just verify that help output is returned (content varies by subcommand)
        assert len(result.stdout) > 0


def test_mini_extra_config_help():
    """Test that mini-extra config --help works correctly."""
    result = subprocess.run(
        ["mini-extra", "config", "--help"],
        capture_output=True,
        text=True,
        timeout=10,
    )

    assert result.returncode == 0
    assert len(result.stdout) > 0
    # Config command should have help output
    clean_output = strip_ansi_codes(result.stdout)
    assert "--help" in clean_output


def test_exit_immediately_flag_sets_confirm_exit_false():
    """Test that --exit-immediately flag sets confirm_exit to False in agent config."""
    with (
        patch("minisweagent.run.mini.configure_if_first_time"),
        patch("minisweagent.run.mini.InteractiveAgent") as mock_interactive_agent_class,
        patch("minisweagent.run.mini.get_model") as mock_get_model,
        patch("minisweagent.run.mini.LocalEnvironment") as mock_env,
        patch("minisweagent.run.mini.get_config_from_spec") as mock_get_config,
    ):
        # Setup mocks
        mock_model = Mock()
        mock_get_model.return_value = mock_model
        mock_environment = Mock()
        mock_env.return_value = mock_environment
        mock_get_config.return_value = {"agent": {"system_template": "test"}, "env": {}, "model": {}}

        # Create mock agent with config
        mock_agent = Mock()
        mock_agent.config.confirm_exit = False
        mock_agent.run.return_value = {"exit_status": "Success", "submission": "Result"}
        mock_interactive_agent_class.return_value = mock_agent

        # Call main function with --exit-immediately flag
        agent = main(
            config_spec=[str(DEFAULT_CONFIG_FILE)],
            model_name="test-model",
            task="Test task",
            yolo=False,
            output=None,
            exit_immediately=True,  # This should set confirm_exit=False
            model_class=None,
        )

        # Verify the agent's config has confirm_exit set to False
        assert agent.config.confirm_exit is False


def test_no_exit_immediately_flag_sets_confirm_exit_true():
    """Test that when --exit-immediately flag is not used, confirm_exit defaults to True."""
    with (
        patch("minisweagent.run.mini.configure_if_first_time"),
        patch("minisweagent.run.mini.InteractiveAgent") as mock_interactive_agent_class,
        patch("minisweagent.run.mini.get_model") as mock_get_model,
        patch("minisweagent.run.mini.LocalEnvironment") as mock_env,
        patch("minisweagent.run.mini.get_config_from_spec") as mock_get_config,
    ):
        # Setup mocks
        mock_model = Mock()
        mock_get_model.return_value = mock_model
        mock_environment = Mock()
        mock_env.return_value = mock_environment
        mock_get_config.return_value = {"agent": {"system_template": "test"}, "env": {}, "model": {}}

        # Create mock agent with config
        mock_agent = Mock()
        mock_agent.config.confirm_exit = True
        mock_agent.run.return_value = {"exit_status": "Success", "submission": "Result"}
        mock_interactive_agent_class.return_value = mock_agent

        # Call main function without --exit-immediately flag (defaults to False)
        agent = main(
            config_spec=[str(DEFAULT_CONFIG_FILE)],
            model_name="test-model",
            task="Test task",
            yolo=False,
            output=None,
            model_class=None,
        )

        # Verify the agent's config has confirm_exit set to True
        assert agent.config.confirm_exit is True


def test_exit_immediately_flag_with_typer_runner():
    """Test --exit-immediately flag using typer's test runner."""
    from typer.testing import CliRunner

    with (
        patch("minisweagent.run.mini.configure_if_first_time"),
        patch("minisweagent.run.mini.InteractiveAgent") as mock_interactive_agent_class,
        patch("minisweagent.run.mini.get_model") as mock_get_model,
        patch("minisweagent.run.mini.LocalEnvironment") as mock_env,
        patch("minisweagent.run.mini.get_config_from_spec") as mock_get_config,
    ):
        # Setup mocks
        mock_model = Mock()
        mock_get_model.return_value = mock_model
        mock_environment = Mock()
        mock_env.return_value = mock_environment
        mock_get_config.return_value = {"agent": {"system_template": "test"}, "env": {}, "model": {}}

        # Setup mock agent instance
        mock_agent = Mock()
        mock_agent.run.return_value = {"exit_status": "Success", "result": "Result"}
        mock_agent.messages = []
        mock_interactive_agent_class.return_value = mock_agent

        runner = CliRunner()
        result = runner.invoke(app, ["--task", "Test task", "--exit-immediately", "--model", "test-model"])

        assert result.exit_code == 0
        mock_interactive_agent_class.assert_called_once()
        args, kwargs = mock_interactive_agent_class.call_args
        # The agent_config should contain confirm_exit as a keyword argument
        assert kwargs.get("confirm_exit") is False


def test_output_file_is_created(tmp_path):
    """Test that output trajectory file is created when --output is specified."""
    from typer.testing import CliRunner

    output_file = tmp_path / "test_traj.json"

    # Create a temporary config file
    config_file = tmp_path / "test_config.yaml"
    default_config_path = Path("src/minisweagent/config/default.yaml")
    config_file.write_text(default_config_path.read_text())

    with (
        patch("minisweagent.run.mini.configure_if_first_time"),
        patch("minisweagent.run.mini.get_model") as mock_get_model,
        patch("minisweagent.run.mini.LocalEnvironment") as mock_env_class,
        patch("minisweagent.agents.interactive._prompt_session.prompt", return_value=""),
        patch("minisweagent.agents.interactive._multiline_prompt_session.prompt", return_value=""),
    ):
        # Setup mocks
        mock_model = Mock()
        mock_model.config = Mock()
        mock_model.config.model_dump.return_value = {}
        mock_model.serialize.return_value = {
            "info": {
                "config": {"model": {}, "model_type": "MockModel"},
            }
        }
        mock_model.get_template_vars.return_value = {}
        mock_model.format_message.side_effect = lambda **kwargs: dict(**kwargs)
        # query now returns dict with extra["actions"]
        mock_model.query.side_effect = [
            {
                "role": "assistant",
                "content": "```mswea_bash_command\necho COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT\necho done\n```",
                "extra": {"actions": [{"command": "echo COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT\necho done"}]},
            },
        ]
        # format_observation_messages returns observation messages
        mock_model.format_observation_messages.return_value = []
        mock_get_model.return_value = mock_model

        # Environment execute raises Submitted when COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT is seen
        from minisweagent.exceptions import Submitted

        def execute_side_effect(action):
            raise Submitted(
                {
                    "role": "exit",
                    "content": "done",
                    "extra": {"exit_status": "Submitted", "submission": "done"},
                }
            )

        mock_environment = Mock()
        mock_environment.config = Mock()
        mock_environment.config.model_dump.return_value = {}
        mock_environment.execute.side_effect = execute_side_effect
        mock_environment.get_template_vars.return_value = {
            "system": "TestOS",
            "release": "1.0",
            "version": "1.0.0",
            "machine": "x86_64",
        }
        mock_environment.serialize.return_value = {
            "info": {"config": {"environment": {}, "environment_type": "MockEnvironment"}}
        }
        mock_env_class.return_value = mock_environment

        runner = CliRunner()
        result = runner.invoke(
            app,
            [
                "--task",
                "Test task",
                "--model",
                "test-model",
                "--output",
                str(output_file),
                "--config",
                str(config_file),
            ],
        )

        if result.exit_code != 0:
            print(f"Error output: {result.output}")
        assert result.exit_code == 0
        assert output_file.exists(), f"Output file {output_file} was not created"