import json

import tempfile

from pathlib import Path

from unittest.mock import patch

import pytest

import typer

from minisweagent.run.utilities.inspector import TrajectoryInspector, main

def get_screen_text(app: TrajectoryInspector) -> str:

    """Extract all text content from the app's UI."""

    text_parts = []

    def _append_visible_static_text(container):

        for static_widget in container.query("Static"):

            if static_widget.display:

                if hasattr(static_widget, "content") and static_widget.content:  # type: ignore[attr-defined]

                    text_parts.append(str(static_widget.content))  # type: ignore[attr-defined]

                elif hasattr(static_widget, "renderable") and static_widget.renderable:  # type: ignore[attr-defined]

                    text_parts.append(str(static_widget.renderable))  # type: ignore[attr-defined]

    # Get all Static widgets in the main content container

    content_container = app.query_one("#content")

    _append_visible_static_text(content_container)

    return "\n".join(text_parts)

@pytest.fixture

def sample_simple_trajectory():

    """Sample trajectory in simple format (list of messages)."""

    return [

        {"role": "system", "content": "You are a helpful assistant."},

        {"role": "user", "content": "Hello, solve this problem."},

        {"role": "assistant", "content": "I'll help you solve this.\n\n```mswea_bash_command\nls -la\n```"},

        {"role": "user", "content": "Command output here."},

        {

            "role": "assistant",

            "content": "Now I'll finish.\n\n```mswea_bash_command\necho COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT\n```",

        },

    ]

@pytest.fixture

def sample_swebench_trajectory():

    """Sample trajectory in SWEBench format (dict with messages array)."""

    return {

        "instance_id": "test-instance-1",

        "info": {

            "exit_status": "Submitted",

            "submission": "Fixed the issue",

            "model_stats": {"instance_cost": 0.05, "api_calls": 3},

        },

        "messages": [

            {"role": "system", "content": "You are a helpful assistant."},

            {"role": "user", "content": [{"type": "text", "text": "Please solve this issue."}]},

            {"role": "assistant", "content": "I'll analyze the issue.\n\n```mswea_bash_command\ncat file.py\n```"},

            {"role": "user", "content": [{"type": "text", "text": "File contents here."}]},

            {

                "role": "assistant",

                "content": "Fixed!\n\n```mswea_bash_command\necho COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT\n```",

            },

        ],

    }

@pytest.fixture

def sample_toolcall_trajectory():

    """Sample trajectory with tool_calls format."""

    return [

        {"role": "system", "content": "You are a helpful assistant."},

        {"role": "user", "content": "List files."},

        {

            "role": "assistant",

            "content": "",

            "tool_calls": [{"id": "1", "function": {"name": "bash", "arguments": '{"command": "ls -la"}'}}],

        },

        {"role": "tool", "tool_call_id": "1", "content": '{"returncode": 0, "output": "file.txt"}'},

    ]

@pytest.fixture

def sample_response_api_trajectory():

    """Sample trajectory with Responses API format."""

    return [

        {"role": "system", "content": "You are a helpful assistant."},

        {"role": "user", "content": "List files."},

        {

            "type": "assistant",

            "output": [

                {"type": "message", "content": [{"type": "text", "text": "Let me check."}]},

                {"type": "function_call", "name": "bash", "arguments": '{"command": "ls"}'},

            ],

        },

    ]

@pytest.fixture

def temp_trajectory_files(sample_simple_trajectory, sample_swebench_trajectory):

    """Create temporary trajectory files for testing."""

    with tempfile.TemporaryDirectory() as temp_dir:

        temp_path = Path(temp_dir)

        # Simple format trajectory

        simple_file = temp_path / "simple.traj.json"

        simple_file.write_text(json.dumps(sample_simple_trajectory, indent=2))

        # SWEBench format trajectory

        swebench_file = temp_path / "swebench.traj.json"

        swebench_file.write_text(json.dumps(sample_swebench_trajectory, indent=2))

        # Invalid JSON file

        invalid_file = temp_path / "invalid.traj.json"

        invalid_file.write_text("invalid json content")

        yield [simple_file, swebench_file, invalid_file]

@pytest.mark.slow

async def test_trajectory_inspector_basic_navigation(temp_trajectory_files):

    """Test basic step navigation in trajectory inspector."""

    valid_files = [f for f in temp_trajectory_files if f.name != "invalid.traj.json"]

    app = TrajectoryInspector(valid_files)

    async with app.run_test() as pilot:

        # Should start with first trajectory, first step

        await pilot.pause(0.1)

        assert "Trajectory 1/2 - simple.traj.json - Step 1/3" in app.title

        content = get_screen_text(app)

        assert "SYSTEM" in content

        assert "You are a helpful assistant" in content

        assert "solve this problem" in content

        # Navigate to next step

        await pilot.press("l")

        assert "Step 2/3" in app.title

        assert "ASSISTANT" in get_screen_text(app)

        assert "I'll help you solve this" in get_screen_text(app)

        # Navigate to last step

        await pilot.press("$")

        assert "Step 3/3" in app.title

        assert "ASSISTANT" in get_screen_text(app)

        assert "echo COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT" in get_screen_text(app)

        # Navigate back to first step

        await pilot.press("0")

        assert "Step 1/3" in app.title

        assert "SYSTEM" in get_screen_text(app)

        # Navigate with left/right arrows

        await pilot.press("right")

        assert "Step 2/3" in app.title

        await pilot.press("left")

        assert "Step 1/3" in app.title

@pytest.mark.slow

async def test_trajectory_inspector_trajectory_navigation(temp_trajectory_files):

    """Test navigation between different trajectory files."""

    valid_files = [f for f in temp_trajectory_files if f.name != "invalid.traj.json"]

    app = TrajectoryInspector(valid_files)

    async with app.run_test() as pilot:

        await pilot.pause(0.1)

        # Should start with first trajectory

        assert "Trajectory 1/2 - simple.traj.json" in app.title

        content = get_screen_text(app)

        assert "You are a helpful assistant" in content

        # Navigate to next trajectory

        await pilot.press("L")

        assert "Trajectory 2/2 - swebench.traj.json" in app.title

        await pilot.pause(0.1)

        content = get_screen_text(app)

        assert "You are a helpful assistant" in content

        # Navigate back to previous trajectory

        await pilot.press("H")

        assert "Trajectory 1/2 - simple.traj.json" in app.title

        # Try to navigate beyond bounds

        await pilot.press("H")  # Should stay at first

        assert "Trajectory 1/2 - simple.traj.json" in app.title

        await pilot.press("L")  # Go to second

        await pilot.press("L")  # Try to go beyond

        assert "Trajectory 2/2 - swebench.traj.json" in app.title  # Should stay at last

@pytest.mark.slow

async def test_trajectory_inspector_swebench_format(temp_trajectory_files):

    """Test that SWEBench format trajectories are handled correctly."""

    valid_files = [f for f in temp_trajectory_files if f.name != "invalid.traj.json"]

    app = TrajectoryInspector(valid_files)

    async with app.run_test() as pilot:

        # Navigate to SWEBench trajectory

        await pilot.press("L")

        await pilot.pause(0.1)

        assert "Trajectory 2/2 - swebench.traj.json" in app.title

        assert "Step 1/3" in app.title

        # Check that list content is properly rendered - step 1 should have the initial user message

        content = get_screen_text(app)

        assert "Please solve this issue" in content

@pytest.mark.slow

async def test_trajectory_inspector_scrolling(temp_trajectory_files):

    """Test scrolling behavior in trajectory inspector."""

    valid_files = [f for f in temp_trajectory_files if f.name != "invalid.traj.json"]

    app = TrajectoryInspector(valid_files)

    async with app.run_test() as pilot:

        await pilot.pause(0.1)

        # Test scrolling

        vs = app.query_one("VerticalScroll")

        initial_y = vs.scroll_target_y

        await pilot.press("j")  # scroll down

        assert vs.scroll_target_y >= initial_y

        await pilot.press("k")  # scroll up

        # Should scroll up (may not be exactly equal due to content constraints)

@pytest.mark.slow

async def test_trajectory_inspector_empty_trajectory():

    """Test inspector behavior with empty trajectory list."""

    app = TrajectoryInspector([])

    async with app.run_test() as pilot:

        await pilot.pause(0.1)

        assert "Trajectory Inspector - No Data" in app.title

        assert "No trajectory loaded" in get_screen_text(app)

        # Navigation should not crash

        await pilot.press("l")

        await pilot.press("h")

        await pilot.press("L")

        await pilot.press("H")

async def test_trajectory_inspector_invalid_file(temp_trajectory_files):

    """Test inspector behavior with invalid JSON file."""

    invalid_file = [f for f in temp_trajectory_files if f.name == "invalid.traj.json"][0]

    # Mock notify to capture error messages

    app = TrajectoryInspector([invalid_file])

    # Since this is not an async run_test, we need to manually trigger the load

    # The error should be captured when _load_current_trajectory is called

    app._load_current_trajectory()

    assert app.messages == []

    assert app.steps == []

def test_trajectory_inspector_load_trajectory_formats(

    sample_simple_trajectory, sample_swebench_trajectory, sample_toolcall_trajectory, sample_response_api_trajectory

):

    """Test loading different trajectory formats."""

    with tempfile.TemporaryDirectory() as temp_dir:

        temp_path = Path(temp_dir)

        # Test simple format (text-based actions)

        simple_file = temp_path / "simple.traj.json"

        simple_file.write_text(json.dumps(sample_simple_trajectory))

        app = TrajectoryInspector([simple_file])

        assert len(app.messages) == 5

        assert len(app.steps) == 3

        # Test SWEBench format (dict with messages array)

        swebench_file = temp_path / "swebench.traj.json"

        swebench_file.write_text(json.dumps(sample_swebench_trajectory))

        app = TrajectoryInspector([swebench_file])

        assert len(app.messages) == 5

        assert len(app.steps) == 3

        # Test tool_calls format (OpenAI function calling)

        toolcall_file = temp_path / "toolcall.traj.json"

        toolcall_file.write_text(json.dumps(sample_toolcall_trajectory))

        app = TrajectoryInspector([toolcall_file])

        assert len(app.messages) == 4

        assert len(app.steps) == 2

        # Test Responses API format (step splitting uses 'role', not 'type')

        response_api_file = temp_path / "response_api.traj.json"

        response_api_file.write_text(json.dumps(sample_response_api_trajectory))

        app = TrajectoryInspector([response_api_file])

        assert len(app.messages) == 3

        assert len(app.steps) == 1

def test_trajectory_inspector_unrecognized_format():

    """Test inspector behavior with unrecognized trajectory format."""

    with tempfile.TemporaryDirectory() as temp_dir:

        temp_path = Path(temp_dir)

        # Create file with unrecognized format

        unrecognized_file = temp_path / "unrecognized.traj.json"

        unrecognized_file.write_text(json.dumps({"some": "other", "format": True}))

        app = TrajectoryInspector([unrecognized_file])

        # Should handle gracefully

        assert app.messages == []

        assert app.steps == []

def test_trajectory_inspector_current_trajectory_name():

    """Test current_trajectory_name property."""

    with tempfile.TemporaryDirectory() as temp_dir:

        temp_path = Path(temp_dir)

        test_file = temp_path / "test.traj.json"

        test_file.write_text(json.dumps([]))

        app = TrajectoryInspector([test_file])

        assert app.current_trajectory_name == "test.traj.json"

        # Test with empty trajectory list

        app = TrajectoryInspector([])

        assert app.current_trajectory_name == "No trajectories"

@pytest.mark.slow

async def test_trajectory_inspector_css_loading():

    """Test that CSS is properly loaded from config."""

    app = TrajectoryInspector([])

    # Verify CSS contains expected styles

    assert ".message-container" in app.CSS

    assert ".message-header" in app.CSS

    assert ".message-content" in app.CSS

@pytest.mark.slow

async def test_trajectory_inspector_quit_binding(temp_trajectory_files):

    """Test quit functionality."""

    valid_files = [f for f in temp_trajectory_files if f.name != "invalid.traj.json"]

    app = TrajectoryInspector(valid_files)

    async with app.run_test() as pilot:

        await pilot.pause(0.1)

        # Test quit functionality

        await pilot.press("q")

        await pilot.pause(0.1)

        # App should exit gracefully (the test framework handles this)

def test_trajectory_inspector_binding_labels():

    """Test that binding labels use arrow symbols."""

    bindings = {b.action: b.description for b in TrajectoryInspector.BINDINGS}

    assert bindings["scroll_down"] == "↓"

    assert bindings["scroll_up"] == "↑"

@patch("minisweagent.run.utilities.inspector.TrajectoryInspector.run")

def test_main_with_single_file(mock_run, temp_trajectory_files):

    """Test main function with a single trajectory file."""

    valid_file = temp_trajectory_files[0]  # simple.traj.json

    main(str(valid_file))

    mock_run.assert_called_once()

    # Verify the inspector was created with the correct file

    assert mock_run.call_count == 1

@patch("minisweagent.run.utilities.inspector.TrajectoryInspector.run")

def test_main_with_directory_containing_trajectories(mock_run, temp_trajectory_files):

    """Test main function with a directory containing trajectory files."""

    directory = temp_trajectory_files[0].parent

    main(str(directory))

    mock_run.assert_called_once()

@patch("minisweagent.run.utilities.inspector.TrajectoryInspector.run")

def test_main_with_directory_no_trajectories(mock_run):

    """Test main function with a directory containing no trajectory files."""

    with tempfile.TemporaryDirectory() as temp_dir:

        # Create some non-trajectory files

        temp_path = Path(temp_dir)

        (temp_path / "other.json").write_text('{"not": "trajectory"}')

        (temp_path / "readme.txt").write_text("some text")

        with pytest.raises(typer.BadParameter, match="No trajectory files found"):

            main(str(temp_dir))

        mock_run.assert_not_called()

@patch("minisweagent.run.utilities.inspector.TrajectoryInspector.run")

def test_main_with_nonexistent_path(mock_run):

    """Test main function with a path that doesn't exist."""

    nonexistent_path = "/this/path/does/not/exist"

    with pytest.raises(typer.BadParameter, match="Path .* does not exist"):

        main(nonexistent_path)

    mock_run.assert_not_called()

@patch("minisweagent.run.utilities.inspector.TrajectoryInspector.run")

def test_main_with_current_directory_default(mock_run, temp_trajectory_files):

    """Test main function with default argument (current directory)."""

    directory = temp_trajectory_files[0].parent

    # Change to the temp directory to test the default "." behavior

    import os

    original_cwd = os.getcwd()

    try:

        os.chdir(str(directory))

        main(".")  # Explicitly test with "." since default is handled by typer

        mock_run.assert_called_once()

    finally:

        os.chdir(original_cwd)