import json
from unittest.mock import patch

from rp.ui.output import OutputFormatter


class TestOutputFormatter:
    def test_init(self):
        formatter = OutputFormatter()
        assert formatter.format_type == "text"
        assert formatter.quiet is False

        formatter = OutputFormatter("json", True)
        assert formatter.format_type == "json"
        assert formatter.quiet is True

    @patch("builtins.print")
    def test_output_text_quiet(self, mock_print):
        formatter = OutputFormatter(quiet=True)
        formatter.output("test", "response")
        mock_print.assert_not_called()

    @patch("builtins.print")
    def test_output_text_error_quiet(self, mock_print):
        formatter = OutputFormatter(quiet=True)
        formatter.output("test", "error")
        mock_print.assert_called()

    @patch("builtins.print")
    def test_output_text_result_quiet(self, mock_print):
        formatter = OutputFormatter(quiet=True)
        formatter.output("test", "result")
        mock_print.assert_called()

    @patch("builtins.print")
    def test_output_json(self, mock_print):
        formatter = OutputFormatter("json")
        formatter.output("test data", "response")
        args = mock_print.call_args[0][0]
        data = json.loads(args)
        assert data["type"] == "response"
        assert data["data"] == "test data"
        assert "timestamp" in data

    @patch("builtins.print")
    def test_output_structured_dict(self, mock_print):
        formatter = OutputFormatter("structured")
        formatter.output({"key": "value", "key2": "value2"}, "response")
        assert mock_print.call_count == 2
        calls = [call[0][0] for call in mock_print.call_args_list]
        assert "key: value" in calls
        assert "key2: value2" in calls

    @patch("builtins.print")
    def test_output_structured_list(self, mock_print):
        formatter = OutputFormatter("structured")
        formatter.output(["item1", "item2"], "response")
        assert mock_print.call_count == 2
        calls = [call[0][0] for call in mock_print.call_args_list]
        assert "- item1" in calls
        assert "- item2" in calls

    @patch("builtins.print")
    def test_output_structured_other(self, mock_print):
        formatter = OutputFormatter("structured")
        formatter.output("plain text", "response")
        mock_print.assert_called_once_with("plain text")

    @patch("builtins.print")
    def test_output_text_dict(self, mock_print):
        formatter = OutputFormatter("text")
        formatter.output({"key": "value"}, "response")
        args = mock_print.call_args[0][0]
        data = json.loads(args)
        assert data == {"key": "value"}

    @patch("builtins.print")
    def test_output_text_list(self, mock_print):
        formatter = OutputFormatter("text")
        formatter.output(["item1"], "response")
        args = mock_print.call_args[0][0]
        data = json.loads(args)
        assert data == ["item1"]

    @patch("builtins.print")
    def test_output_text_other(self, mock_print):
        formatter = OutputFormatter("text")
        formatter.output("plain text", "response")
        mock_print.assert_called_once_with("plain text")

    @patch("builtins.print")
    def test_error_json(self, mock_print):
        formatter = OutputFormatter("json")
        formatter.error("test error")
        args = mock_print.call_args[0][0]
        data = json.loads(args)
        assert data["type"] == "error"
        assert data["data"]["error"] == "test error"

    @patch("sys.stderr")
    def test_error_text(self, mock_stderr):
        formatter = OutputFormatter("text")
        formatter.error("test error")
        mock_stderr.write.assert_called()
        calls = mock_stderr.write.call_args_list
        assert any("Error: test error" in call[0][0] for call in calls)

    @patch("builtins.print")
    def test_success_json(self, mock_print):
        formatter = OutputFormatter("json")
        formatter.success("test success")
        args = mock_print.call_args[0][0]
        data = json.loads(args)
        assert data["type"] == "success"
        assert data["data"]["success"] == "test success"

    @patch("builtins.print")
    def test_success_text(self, mock_print):
        formatter = OutputFormatter("text")
        formatter.success("test success")
        mock_print.assert_called_once_with("test success")

    @patch("builtins.print")
    def test_success_quiet(self, mock_print):
        formatter = OutputFormatter("text", quiet=True)
        formatter.success("test success")
        mock_print.assert_not_called()

    @patch("builtins.print")
    def test_info_json(self, mock_print):
        formatter = OutputFormatter("json")
        formatter.info("test info")
        args = mock_print.call_args[0][0]
        data = json.loads(args)
        assert data["type"] == "info"
        assert data["data"]["info"] == "test info"

    @patch("builtins.print")
    def test_info_text(self, mock_print):
        formatter = OutputFormatter("text")
        formatter.info("test info")
        mock_print.assert_called_once_with("test info")

    @patch("builtins.print")
    def test_info_quiet(self, mock_print):
        formatter = OutputFormatter("text", quiet=True)
        formatter.info("test info")
        mock_print.assert_not_called()

    @patch("builtins.print")
    def test_result(self, mock_print):
        formatter = OutputFormatter("text")
        formatter.result("test result")
        mock_print.assert_called_once_with("test result")