"""Tests for the parser module."""

import pytest
from cli_explain_fix.parser import ErrorParser, ParsedError


class TestErrorParser:
    """Test cases for ErrorParser."""

    def setup_method(self):
        """Set up parser instance for each test."""
        self.parser = ErrorParser()

    def test_detect_language_python_traceback(self, sample_python_traceback):
        """Test language detection for Python traceback."""
        lang = self.parser.detect_language(sample_python_traceback)
        assert lang == "python"

    def test_detect_language_python_simple(self, sample_python_simple_error):
        """Test language detection for simple Python error."""
        lang = self.parser.detect_language(sample_python_simple_error)
        assert lang == "python"

    def test_detect_language_javascript(self, sample_js_error):
        """Test language detection for JavaScript error."""
        lang = self.parser.detect_language(sample_js_error)
        assert lang == "javascript"

    def test_detect_language_go(self, sample_go_panic):
        """Test language detection for Go panic."""
        lang = self.parser.detect_language(sample_go_panic)
        assert lang == "go"

    def test_detect_language_rust(self, sample_rust_panic):
        """Test language detection for Rust panic."""
        lang = self.parser.detect_language(sample_rust_panic)
        assert lang == "rust"

    def test_detect_language_json(self, sample_json_error):
        """Test language detection for JSON error."""
        lang = self.parser.detect_language(sample_json_error)
        assert lang == "json"

    def test_detect_language_yaml(self, sample_yaml_error):
        """Test language detection for YAML error."""
        lang = self.parser.detect_language(sample_yaml_error)
        assert lang == "yaml"

    def test_detect_language_cli(self, sample_cli_error):
        """Test language detection for CLI error."""
        lang = self.parser.detect_language(sample_cli_error)
        assert lang == "cli"

    def test_detect_language_unknown(self, sample_unknown_error):
        """Test language detection for unknown error."""
        lang = self.parser.detect_language(sample_unknown_error)
        assert lang == "unknown"

    def test_parse_python_traceback(self, sample_python_traceback):
        """Test parsing Python traceback."""
        result = self.parser.parse(sample_python_traceback)

        assert isinstance(result, ParsedError)
        assert result.error_type == "ModuleNotFoundError"
        assert result.language == "python"
        assert "requests" in result.message
        assert result.file_name == "/app/main.py"
        assert result.line_number == 10
        assert len(result.stack_frames) > 0

    def test_parse_python_simple(self, sample_python_simple_error):
        """Test parsing simple Python error."""
        result = self.parser.parse(sample_python_simple_error)

        assert isinstance(result, ParsedError)
        assert result.error_type == "ValueError"
        assert result.language == "python"
        assert "invalid value" in result.message

    def test_parse_javascript_error(self, sample_js_error):
        """Test parsing JavaScript error."""
        result = self.parser.parse(sample_js_error)

        assert isinstance(result, ParsedError)
        assert result.error_type == "TypeError"
        assert result.language == "javascript"

    def test_parse_go_panic(self, sample_go_panic):
        """Test parsing Go panic."""
        result = self.parser.parse(sample_go_panic)

        assert isinstance(result, ParsedError)
        assert result.error_type == "panic"
        assert result.language == "go"

    def test_parse_rust_panic(self, sample_rust_panic):
        """Test parsing Rust panic."""
        result = self.parser.parse(sample_rust_panic)

        assert isinstance(result, ParsedError)
        assert result.error_type == "panic"
        assert result.language == "rust"

    def test_parse_json_error(self, sample_json_error):n        """Test parsing JSON error."""
        result = self.parser.parse(sample_json_error)

        assert isinstance(result, ParsedError)
        assert result.error_type == "JSONParseError"
        assert result.language == "json"

    def test_parse_yaml_error(self, sample_yaml_error):
        """Test parsing YAML error."""
        result = self.parser.parse(sample_yaml_error)

        assert isinstance(result, ParsedError)
        assert result.error_type == "YAMLParseError"
        assert result.language == "yaml"

    def test_parse_cli_error(self, sample_cli_error):
        """Test parsing CLI error."""
        result = self.parser.parse(sample_cli_error)

        assert isinstance(result, ParsedError)
        assert result.error_type == "GenericError"
        assert result.language == "cli"

    def test_parse_with_explicit_language(self, sample_python_simple_error):
        """Test parsing with explicit language specification."""
        result = self.parser.parse(sample_python_simple_error, language="python")

        assert result.language == "python"
        assert result.error_type == "ValueError"

    def test_parse_unknown_error(self, sample_unknown_error):
        """Test parsing unknown error returns default."""
        result = self.parser.parse(sample_unknown_error)

        assert isinstance(result, ParsedError)
        assert result.error_type == "UnknownError"
        assert result.language == "unknown"

    def test_parse_empty_input(self):
        """Test parsing empty input."""
        result = self.parser.parse("")

        assert isinstance(result, ParsedError)
        assert result.error_type == "UnknownError"
        assert result.message == "Unknown error occurred"

    def test_parsed_error_to_dict(self, sample_python_simple_error):
        """Test ParsedError.to_dict() method."""
        result = self.parser.parse(sample_python_simple_error)
        data = result.to_dict()

        assert isinstance(data, dict)
        assert "error_type" in data
        assert "message" in data
        assert "language" in data
        assert "stack_frames" in data

    def test_parse_complex_python_traceback(self):
        """Test parsing complex Python traceback with multiple frames."""
        traceback = '''Traceback (most recent call last):
  File "app.py", line 5, in <module>
    main()
  File "app.py", line 10, in main
    process()
  File "processor.py", line 20, in process
    result = data['key']
KeyError: 'key'
'''
        result = self.parser.parse(traceback)

        assert result.error_type == "KeyError"
        assert result.language == "python"
        assert result.file_name == "processor.py"
        assert result.line_number == 20
        assert len(result.stack_frames) == 3