import logging

import time

import pytest

import minisweagent.models

from minisweagent.exceptions import FormatError

from minisweagent.models.test_models import (

    DeterministicModel,

    DeterministicModelConfig,

    DeterministicResponseAPIToolcallModel,

    DeterministicResponseAPIToolcallModelConfig,

    DeterministicToolcallModel,

    DeterministicToolcallModelConfig,

    make_output,

    make_response_api_output,

    make_toolcall_output,

)

def test_basic_functionality_and_cost_tracking(reset_global_stats):

    """Test basic model functionality, cost tracking, and default configuration."""

    model = DeterministicModel(

        outputs=[

            make_output("```mswea_bash_command\necho hello\n```", [{"command": "echo hello"}]),

            make_output("```mswea_bash_command\necho world\n```", [{"command": "echo world"}]),

        ]

    )

    # Test first call with defaults

    result = model.query([{"role": "user", "content": "test"}])

    assert result["content"] == "```mswea_bash_command\necho hello\n```"

    assert result["extra"]["actions"] == [{"command": "echo hello"}]

    assert minisweagent.models.GLOBAL_MODEL_STATS.n_calls == 1

    assert minisweagent.models.GLOBAL_MODEL_STATS.cost == 1.0

    # Test second call and sequential outputs

    result = model.query([{"role": "user", "content": "test"}])

    assert result["content"] == "```mswea_bash_command\necho world\n```"

    assert result["extra"]["actions"] == [{"command": "echo world"}]

    assert minisweagent.models.GLOBAL_MODEL_STATS.n_calls == 2

    assert minisweagent.models.GLOBAL_MODEL_STATS.cost == 2.0

def test_custom_cost_and_multiple_models(reset_global_stats):

    """Test custom cost configuration and global tracking across multiple models."""

    model1 = DeterministicModel(

        outputs=[make_output("```mswea_bash_command\necho r1\n```", [{"command": "echo r1"}])], cost_per_call=2.5

    )

    model2 = DeterministicModel(

        outputs=[make_output("```mswea_bash_command\necho r2\n```", [{"command": "echo r2"}])], cost_per_call=3.0

    )

    result1 = model1.query([{"role": "user", "content": "test"}])

    assert result1["content"] == "```mswea_bash_command\necho r1\n```"

    assert minisweagent.models.GLOBAL_MODEL_STATS.cost == 2.5

    result2 = model2.query([{"role": "user", "content": "test"}])

    assert result2["content"] == "```mswea_bash_command\necho r2\n```"

    assert minisweagent.models.GLOBAL_MODEL_STATS.cost == 5.5

    assert minisweagent.models.GLOBAL_MODEL_STATS.n_calls == 2

def test_config_dataclass():

    """Test DeterministicModelConfig with custom values."""

    config = DeterministicModelConfig(

        outputs=[make_output("Test", [{"command": "test"}])], model_name="custom", cost_per_call=5.0

    )

    assert config.cost_per_call == 5.0

    assert config.model_name == "custom"

    model = DeterministicModel(**config.model_dump())

    assert model.config.cost_per_call == 5.0

def test_sleep_and_warning_commands(caplog):

    """Test special /sleep and /warning command handling."""

    # Test sleep command - processes sleep then returns actual output (counts as 1 call)

    model = DeterministicModel(

        outputs=[

            make_output("", [{"command": "/sleep 0.1"}]),

            make_output("```mswea_bash_command\necho after_sleep\n```", [{"command": "echo after_sleep"}]),

        ]

    )

    start_time = time.time()

    result = model.query([{"role": "user", "content": "test"}])

    assert result["content"] == "```mswea_bash_command\necho after_sleep\n```"

    assert time.time() - start_time >= 0.1

    # Test warning command - processes warning then returns actual output (counts as 1 call)

    model2 = DeterministicModel(

        outputs=[

            make_output("", [{"command": "/warning Test message"}]),

            make_output("```mswea_bash_command\necho after_warning\n```", [{"command": "echo after_warning"}]),

        ]

    )

    with caplog.at_level(logging.WARNING):

        result2 = model2.query([{"role": "user", "content": "test"}])

        assert result2["content"] == "```mswea_bash_command\necho after_warning\n```"

    assert "Test message" in caplog.text

def test_raise_exception():

    """Test {"raise": Exception(...)} raises the exception."""

    model = DeterministicModel(outputs=[make_output("", [{"raise": FormatError()}])])

    with pytest.raises(FormatError):

        model.query([{"role": "user", "content": "test"}])

def test_toolcall_model_basic(reset_global_stats):

    """Test DeterministicToolcallModel basic functionality."""

    tool_calls = [

        {"id": "call_123", "type": "function", "function": {"name": "bash", "arguments": '{"command": "ls"}'}}

    ]

    actions = [{"command": "ls", "tool_call_id": "call_123"}]

    model = DeterministicToolcallModel(

        outputs=[make_toolcall_output(None, tool_calls, actions)],

    )

    result = model.query([{"role": "user", "content": "list files"}])

    assert result["tool_calls"] == tool_calls

    assert result["extra"]["actions"] == actions

    assert minisweagent.models.GLOBAL_MODEL_STATS.n_calls == 1

def test_toolcall_model_format_observation(reset_global_stats):

    """Test DeterministicToolcallModel formats observations as tool results."""

    tool_calls = [

        {"id": "call_456", "type": "function", "function": {"name": "bash", "arguments": '{"command": "pwd"}'}}

    ]

    actions = [{"command": "pwd", "tool_call_id": "call_456"}]

    model = DeterministicToolcallModel(outputs=[make_toolcall_output(None, tool_calls, actions)])

    result = model.query([{"role": "user", "content": "test"}])

    outputs = [{"output": "/home/user", "returncode": 0, "exception_info": ""}]

    obs_messages = model.format_observation_messages(result, outputs)

    assert len(obs_messages) == 1

    assert obs_messages[0]["role"] == "tool"

    assert obs_messages[0]["tool_call_id"] == "call_456"

    assert "/home/user" in obs_messages[0]["content"]

def test_toolcall_config():

    """Test DeterministicToolcallModelConfig with custom values."""

    config = DeterministicToolcallModelConfig(

        outputs=[make_toolcall_output(None, [], [])], model_name="custom_toolcall", cost_per_call=2.0

    )

    assert config.cost_per_call == 2.0

    assert config.model_name == "custom_toolcall"

    model = DeterministicToolcallModel(**config.model_dump())

    assert model.config.cost_per_call == 2.0

def test_response_api_model_basic(reset_global_stats):

    """Test DeterministicResponseAPIToolcallModel basic functionality."""

    actions = [{"command": "ls", "tool_call_id": "call_resp_123"}]

    model = DeterministicResponseAPIToolcallModel(

        outputs=[make_response_api_output("I'll list files", actions)],

    )

    result = model.query([{"role": "user", "content": "list files"}])

    assert result["object"] == "response"

    assert result["extra"]["actions"] == actions

    assert minisweagent.models.GLOBAL_MODEL_STATS.n_calls == 1

    # Check output structure

    assert len(result["output"]) == 2  # message + function_call

    assert result["output"][0]["type"] == "message"

    assert result["output"][1]["type"] == "function_call"

    assert result["output"][1]["call_id"] == "call_resp_123"

def test_response_api_model_format_observation(reset_global_stats):

    """Test DeterministicResponseAPIToolcallModel formats observations as function_call_output."""

    actions = [{"command": "pwd", "tool_call_id": "call_resp_456"}]

    model = DeterministicResponseAPIToolcallModel(outputs=[make_response_api_output(None, actions)])

    result = model.query([{"role": "user", "content": "test"}])

    outputs = [{"output": "/home/user", "returncode": 0, "exception_info": ""}]

    obs_messages = model.format_observation_messages(result, outputs)

    assert len(obs_messages) == 1

    assert obs_messages[0]["type"] == "function_call_output"

    assert obs_messages[0]["call_id"] == "call_resp_456"

    assert "/home/user" in obs_messages[0]["output"]

def test_response_api_model_format_message():

    """Test DeterministicResponseAPIToolcallModel formats messages in Responses API format."""

    model = DeterministicResponseAPIToolcallModel(outputs=[])

    msg = model.format_message(role="user", content="Hello")

    assert msg["type"] == "message"

    assert msg["role"] == "user"

    assert msg["content"] == [{"type": "input_text", "text": "Hello"}]

def test_response_api_config():

    """Test DeterministicResponseAPIToolcallModelConfig with custom values."""

    config = DeterministicResponseAPIToolcallModelConfig(

        outputs=[make_response_api_output(None, [])], model_name="custom_response_api", cost_per_call=3.0

    )

    assert config.cost_per_call == 3.0

    assert config.model_name == "custom_response_api"

    model = DeterministicResponseAPIToolcallModel(**config.model_dump())

    assert model.config.cost_per_call == 3.0