"""Tests for converter modules."""

import pytest
import json
import tempfile
import os
from pathlib import Path


class TestJSONConverter:
    """Tests for JSON converter."""
    
    def test_loads_valid_json(self):
        from src.converters import JSONConverter
        converter = JSONConverter()
        
        data = converter.loads('{"name": "test", "value": 123}')
        assert data == {"name": "test", "value": 123}
    
    def test_dumps_dict(self):
        from src.converters import JSONConverter
        converter = JSONConverter()
        
        result = converter.dumps({"name": "test"}, indent=2)
        assert '"name": "test"' in result
    
    def test_dumps_list(self):
        from src.converters import JSONConverter
        converter = JSONConverter()
        
        result = converter.dumps([1, 2, 3])
        assert "1" in result and "2" in result and "3" in result
    
    def test_convert_to_yaml(self):
        from src.converters import JSONConverter, YAMLConverter
        converter = JSONConverter()
        yaml_converter = YAMLConverter()
        
        content = '{"name": "test"}'
        result = converter.convert(content, yaml_converter)
        assert result.success
        assert "name: test" in result.data
    
    def test_roundtrip(self):
        from src.converters import JSONConverter
        converter = JSONConverter()
        
        original = {"key": "value", "number": 42, "list": [1, 2, 3]}
        dumped = converter.dumps(original)
        loaded = converter.loads(dumped)
        assert loaded == original
    
    def test_file_operations(self):
        from src.converters import JSONConverter
        converter = JSONConverter()
        
        with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
            f.write('{"test": true}')
            temp_path = f.name
        
        try:
            content = converter.read_file(temp_path)
            assert '{"test": true}' in content
            
            converter.write_file(temp_path, '{"new": "data"}')
            content = converter.read_file(temp_path)
            assert '"new": "data"' in content
        finally:
            os.unlink(temp_path)


class TestYAMLConverter:
    """Tests for YAML converter."""
    
    def test_loads_valid_yaml(self):
        from src.converters import YAMLConverter
        converter = YAMLConverter()
        
        data = converter.loads('name: test\nvalue: 123')
        assert data == {"name": "test", "value": 123}
    
    def test_dumps_dict(self):
        from src.converters import YAMLConverter
        converter = YAMLConverter()
        
        result = converter.dumps({"name": "test"})
        assert "name: test" in result
    
    def test_convert_to_json(self):
        from src.converters import YAMLConverter, JSONConverter
        converter = YAMLConverter()
        json_converter = JSONConverter()
        
        content = 'name: test'
        result = converter.convert(content, json_converter)
        assert result.success
        assert '"name": "test"' in result.data
    
    def test_nested_data(self):
        from src.converters import YAMLConverter
        converter = YAMLConverter()
        
        data = {"outer": {"inner": "value"}, "list": [1, 2]}
        result = converter.dumps(data)
        assert "outer:" in result
        assert "inner: value" in result


class TestTOMLConverter:
    """Tests for TOML converter."""
    
    def test_loads_valid_toml(self):
        from src.converters import TOMLConverter
        converter = TOMLConverter()
        
        data = converter.loads('name = "test"\nvalue = 123')
        assert data["name"] == "test"
        assert data["value"] == 123
    
    def test_dumps_dict(self):
        from src.converters import TOMLConverter
        converter = TOMLConverter()
        
        result = converter.dumps({"name": "test"})
        assert 'name = "test"' in result
    
    def test_convert_to_json(self):
        from src.converters import TOMLConverter, JSONConverter
        converter = TOMLConverter()
        json_converter = JSONConverter()
        
        content = 'name = "test"'
        result = converter.convert(content, json_converter)
        assert result.success
        assert '"name": "test"' in result.data


class TestCSVConverter:
    """Tests for CSV converter."""
    
    def test_loads_valid_csv(self):
        from src.converters import CSVConverter
        converter = CSVConverter()
        
        data = converter.loads("name,age\nAlice,30\nBob,25")
        assert len(data) == 2
        assert data.iloc[0]["name"] == "Alice"
    
    def test_dumps_list_of_dicts(self):
        from src.converters import CSVConverter
        converter = CSVConverter()
        
        data = [{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]
        result = converter.dumps(data)
        assert "name,age" in result
        assert "Alice" in result
    
    def test_convert_to_json(self):
        from src.converters import CSVConverter, JSONConverter
        csv_converter = CSVConverter()
        json_converter = JSONConverter()
        
        content = "name,age\nAlice,30"
        result = csv_converter.convert(content, json_converter)
        assert result.success
        assert '"name": "Alice"' in result.data
    
    def test_roundtrip(self):
        from src.converters import CSVConverter
        converter = CSVConverter()
        
        original = [{"name": "Alice", "age": 30}]
        dumped = converter.dumps(original)
        loaded = converter.loads(dumped)
        assert loaded.iloc[0]["name"] == "Alice"


class TestConverterFactory:
    """Tests for converter factory function."""
    
    def test_get_converter_json(self):
        from src.converters import get_converter
        
        converter = get_converter("json")
        assert converter.format_name == "json"
    
    def test_get_converter_yaml(self):
        from src.converters import get_converter
        
        converter = get_converter("yaml")
        assert converter.format_name == "yaml"
    
    def test_get_converter_toml(self):
        from src.converters import get_converter
        
        converter = get_converter("toml")
        assert converter.format_name == "toml"
    
    def test_get_converter_csv(self):
        from src.converters import get_converter
        
        converter = get_converter("csv")
        assert converter.format_name == "csv"
    
    def test_get_converter_invalid(self):
        from src.converters import get_converter
        
        with pytest.raises(ValueError):
            get_converter("invalid")
    
    def test_supported_formats(self):
        from src.converters import SUPPORTED_FORMATS
        
        assert "json" in SUPPORTED_FORMATS
        assert "yaml" in SUPPORTED_FORMATS
        assert "toml" in SUPPORTED_FORMATS
        assert "csv" in SUPPORTED_FORMATS


class TestFormatDetection:
    """Tests for format detection."""
    
    def test_detect_json(self):
        from src.converters import JSONConverter
        converter = JSONConverter()
        
        fmt = converter.detect_format("test.json")
        assert fmt == "json"
    
    def test_detect_yaml(self):
        from src.converters import YAMLConverter
        converter = YAMLConverter()
        
        fmt = converter.detect_format("test.yaml")
        assert fmt == "yaml"
    
    def test_detect_yml(self):
        from src.converters import YAMLConverter
        converter = YAMLConverter()
        
        fmt = converter.detect_format("test.yml")
        assert fmt == "yaml"
    
    def test_detect_toml(self):
        from src.converters import TOMLConverter
        converter = TOMLConverter()
        
        fmt = converter.detect_format("test.toml")
        assert fmt == "toml"
    
    def test_detect_csv(self):
        from src.converters import CSVConverter
        converter = CSVConverter()
        
        fmt = converter.detect_format("test.csv")
        assert fmt == "csv"
    
    def test_detect_unknown(self):
        from src.converters import JSONConverter
        converter = JSONConverter()
        
        fmt = converter.detect_format("test.xyz")
        assert fmt is None