"""Tests for format converters."""

import json
import tempfile
from pathlib import Path

import pytest

from config_converter.converters import (
    JsonConverter,
    YamlConverter,
    TomlConverter,
    IniConverter,
    BaseConverter,
    ConversionError,
)


class TestJsonConverter:
    """Tests for JSON converter."""

    def setup_method(self) -> None:
        self.converter = JsonConverter()

    def test_read_valid_json(self) -> None:
        """Test reading valid JSON file."""
        with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
            json.dump({"key": "value", "number": 42}, f)
            f.flush()
            result = self.converter.read(f.name)
        assert result == {"key": "value", "number": 42}

    def test_read_invalid_json(self) -> None:
        """Test reading invalid JSON raises error."""
        with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
            f.write("{invalid json}")
            f.flush()
            with pytest.raises(ConversionError):
                self.converter.read(f.name)

    def test_read_file_not_found(self) -> None:
        """Test reading non-existent file raises error."""
        with pytest.raises(ConversionError):
            self.converter.read("/nonexistent/path/file.json")

    def test_write_json(self) -> None:
        """Test writing JSON file."""
        with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
            output_path = f.name
        try:
            self.converter.write({"test": "data"}, output_path)
            with open(output_path, "r") as f:
                result = json.load(f)
            assert result == {"test": "data"}
        finally:
            Path(output_path).unlink(missing_ok=True)

    def test_parse_json_string(self) -> None:
        """Test parsing JSON string."""
        result = self.converter.parse('{"key": "value"}')
        assert result == {"key": "value"}

    def test_format_json_string(self) -> None:
        """Test formatting data to JSON string."""
        result = self.converter.format({"key": "value"})
        assert result == '{\n  "key": "value"\n}'


class TestYamlConverter:
    """Tests for YAML converter."""

    def setup_method(self) -> None:
        self.converter = YamlConverter()

    def test_read_valid_yaml(self) -> None:
        """Test reading valid YAML file."""
        with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f:
            f.write("key: value\nnumber: 42\n")
            f.flush()
            result = self.converter.read(f.name)
        assert result == {"key": "value", "number": 42}

    def test_read_yaml_with_yml_extension(self) -> None:
        """Test reading YAML file with yml extension."""
        with tempfile.NamedTemporaryFile(mode="w", suffix=".yml", delete=False) as f:
            f.write("key: value\n")
            f.flush()
            result = self.converter.read(f.name)
        assert result == {"key": "value"}

    def test_write_yaml(self) -> None:
        """Test writing YAML file."""
        with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f:
            output_path = f.name
        try:
            self.converter.write({"test": "data"}, output_path)
            with open(output_path, "r") as f:
                result = f.read()
            assert "test: data" in result
        finally:
            Path(output_path).unlink(missing_ok=True)

    def test_parse_yaml_string(self) -> None:
        """Test parsing YAML string."""
        result = self.converter.parse("key: value")
        assert result == {"key": "value"}


class TestTomlConverter:
    """Tests for TOML converter."""

    def setup_method(self) -> None:
        self.converter = TomlConverter()

    def test_read_valid_toml(self) -> None:
        """Test reading valid TOML file."""
        with tempfile.NamedTemporaryFile(mode="w", suffix=".toml", delete=False) as f:
            f.write('key = "value"\nnumber = 42\n')
            f.flush()
            result = self.converter.read(f.name)
        assert result["key"] == "value"
        assert result["number"] == 42

    def test_write_toml(self) -> None:
        """Test writing TOML file."""
        with tempfile.NamedTemporaryFile(mode="w", suffix=".toml", delete=False) as f:
            output_path = f.name
        try:
            self.converter.write({"test": "data"}, output_path)
            with open(output_path, "r") as f:
                result = f.read()
            assert 'test = "data"' in result
        finally:
            Path(output_path).unlink(missing_ok=True)

    def test_parse_toml_string(self) -> None:
        """Test parsing TOML string."""
        result = self.converter.parse('key = "value"')
        assert result["key"] == "value"


class TestIniConverter:
    """Tests for INI converter."""

    def setup_method(self) -> None:
        self.converter = IniConverter()

    def test_read_valid_ini(self) -> None:
        """Test reading valid INI file."""
        with tempfile.NamedTemporaryFile(mode="w", suffix=".ini", delete=False) as f:
            f.write("[section]\nkey = value\n")
            f.flush()
            result = self.converter.read(f.name)
        assert "section" in result
        assert result["section"]["key"] == "value"

    def test_write_ini(self) -> None:
        """Test writing INI file."""
        with tempfile.NamedTemporaryFile(mode="w", suffix=".ini", delete=False) as f:
            output_path = f.name
        try:
            self.converter.write({"section": {"key": "value"}}, output_path)
            with open(output_path, "r") as f:
                result = f.read()
            assert "[section]" in result
        finally:
            Path(output_path).unlink(missing_ok=True)

    def test_parse_ini_string(self) -> None:
        """Test parsing INI string."""
        result = self.converter.parse("[section]\nkey = value")
        assert "section" in result


class TestBaseConverter:
    """Tests for base converter."""

    def test_get_converter_json(self) -> None:
        """Test getting JSON converter."""
        converter = BaseConverter.get_converter("json")
        assert isinstance(converter, JsonConverter)

    def test_get_converter_yaml(self) -> None:
        """Test getting YAML converter."""
        converter = BaseConverter.get_converter("yaml")
        assert isinstance(converter, YamlConverter)

    def test_get_converter_toml(self) -> None:
        """Test getting TOML converter."""
        converter = BaseConverter.get_converter("toml")
        assert isinstance(converter, TomlConverter)

    def test_get_converter_ini(self) -> None:
        """Test getting INI converter."""
        converter = BaseConverter.get_converter("ini")
        assert isinstance(converter, IniConverter)

    def test_get_converter_unsupported(self) -> None:
        """Test getting unsupported converter raises error."""
        with pytest.raises(ConversionError):
            BaseConverter.get_converter("unsupported")

    def test_guess_format_json(self) -> None:
        """Test guessing JSON format from extension."""
        assert BaseConverter.guess_format("file.json") == "json"

    def test_guess_format_yaml(self) -> None:
        """Test guessing YAML format from extension."""
        assert BaseConverter.guess_format("file.yaml") == "yaml"
        assert BaseConverter.guess_format("file.yml") == "yaml"

    def test_guess_format_toml(self) -> None:
        """Test guessing TOML format from extension."""
        assert BaseConverter.guess_format("file.toml") == "toml"

    def test_guess_format_ini(self) -> None:
        """Test guessing INI format from extension."""
        assert BaseConverter.guess_format("file.ini") == "ini"

    def test_get_supported_formats(self) -> None:
        """Test getting supported formats."""
        formats = BaseConverter.get_supported_formats()
        assert "json" in formats
        assert "yaml" in formats
        assert "toml" in formats
        assert "ini" in formats