tenets

"""Tests for viz package initialization and factory functions."""

import json
from pathlib import Path
from unittest.mock import mock_open, patch

import pytest

from tenets.viz import (
    ChartConfig,
    ChartType,
    ComplexityVisualizer,
    ContributorVisualizer,
    CouplingVisualizer,
    DisplayConfig,
    TerminalDisplay,
    combine_visualizations,
    create_chart,
    create_terminal_display,
    create_visualizer,
    detect_visualization_type,
    export_visualization,
)


class TestFactoryFunctions:
    """Test suite for factory functions."""

    def test_create_visualizer_complexity(self):
        """Test creating complexity visualizer."""
        viz = create_visualizer("complexity")
        assert isinstance(viz, ComplexityVisualizer)

    def test_create_visualizer_contributors(self):
        """Test creating contributor visualizer."""
        viz = create_visualizer("contributors")
        assert isinstance(viz, ContributorVisualizer)

    def test_create_visualizer_coupling(self):
        """Test creating coupling visualizer."""
        viz = create_visualizer("coupling")
        assert isinstance(viz, CouplingVisualizer)

    def test_create_visualizer_with_configs(self):
        """Test creating visualizer with custom configs."""
        chart_config = ChartConfig(type=ChartType.LINE, title="Test")
        display_config = DisplayConfig(use_colors=False)

        viz = create_visualizer("complexity", chart_config, display_config)

        assert isinstance(viz, ComplexityVisualizer)
        assert viz.chart_config == chart_config
        assert viz.display_config == display_config

    def test_create_visualizer_invalid_type(self):
        """Test creating visualizer with invalid type."""
        with pytest.raises(ValueError, match="Unknown visualizer type"):
            create_visualizer("invalid")

    def test_create_chart_bar(self):
        """Test creating bar chart."""
        chart = create_chart("bar", {"labels": ["A", "B"], "values": [1, 2]}, title="Test Chart")

        assert chart["type"] == "bar"
        assert chart["options"]["plugins"]["title"]["text"] == "Test Chart"
        assert chart["data"]["labels"] == ["A", "B"]

    def test_create_chart_with_enum(self):
        """Test creating chart with ChartType enum."""
        chart = create_chart(
            ChartType.LINE, {"labels": ["Jan", "Feb"], "datasets": []}, title="Line Chart"
        )

        assert chart["type"] == "line"
        assert chart["options"]["plugins"]["title"]["text"] == "Line Chart"

    def test_create_chart_invalid_type(self):
        """Test creating chart with invalid type."""
        with pytest.raises(ValueError, match="Unknown chart type"):
            create_chart("invalid", {})

    def test_create_terminal_display(self):
        """Test creating terminal display."""
        display = create_terminal_display()
        assert isinstance(display, TerminalDisplay)

    def test_create_terminal_display_with_config(self):
        """Test creating terminal display with config."""
        config = DisplayConfig(use_colors=False, max_width=80)
        display = create_terminal_display(config)

        assert isinstance(display, TerminalDisplay)
        # Config would be used internally


class TestDetectVisualizationType:
    """Test suite for visualization type detection."""

    def test_detect_complexity(self):
        """Test detecting complexity visualization."""
        data = {"complexity": 10, "avg_complexity": 8.5, "complex_functions": []}
        assert detect_visualization_type(data) == "complexity"

    def test_detect_contributors(self):
        """Test detecting contributor visualization."""
        data = {"contributors": [], "total_contributors": 10, "bus_factor": 3}
        assert detect_visualization_type(data) == "contributors"

    def test_detect_hotspots(self):
        """Test detecting hotspot visualization."""
        data = {"hotspots": [], "risk_score": 45.5, "critical_count": 5}
        assert detect_visualization_type(data) == "hotspots"

    def test_detect_momentum(self):
        """Test detecting momentum visualization."""
        data = {"velocity": 25, "sprint": "Sprint 5", "velocity_trend": []}
        assert detect_visualization_type(data) == "momentum"

    def test_detect_dependencies(self):
        """Test detecting dependency visualization."""
        data = {"dependencies": [], "circular_dependencies": [], "dependency_graph": {}}
        assert detect_visualization_type(data) == "dependencies"

    def test_detect_coupling(self):
        """Test detecting coupling visualization."""
        data = {"coupling": 5, "afferent_coupling": 3, "instability": 0.5}
        assert detect_visualization_type(data) == "coupling"

    def test_detect_from_list(self):
        """Test detecting from list data."""
        data = [{"complexity": 10, "cyclomatic": 15}, {"complexity": 8, "cyclomatic": 12}]
        assert detect_visualization_type(data) == "complexity"

        data = [{"author": "Alice", "commits": 100}, {"contributor": "Bob", "commits": 50}]
        assert detect_visualization_type(data) == "contributors"

    def test_detect_custom(self):
        """Test detecting custom/unknown visualization."""
        data = {"unknown": "data", "random": 123}
        assert detect_visualization_type(data) == "custom"

        data = []
        assert detect_visualization_type(data) == "custom"

        data = "string data"
        assert detect_visualization_type(data) == "custom"


class TestExportVisualization:
    """Test suite for visualization export."""

    @patch("builtins.open", new_callable=mock_open)
    def test_export_json(self, mock_file):
        """Test exporting as JSON."""
        visualization = {"type": "bar", "data": {"labels": ["A"], "values": [1]}}

        export_visualization(visualization, "chart.json", format="json")

        mock_file.assert_called_once_with(Path("chart.json"), "w")
        handle = mock_file()
        written_content = "".join(call.args[0] for call in handle.write.call_args_list)

        # Verify JSON structure
        parsed = json.loads(written_content)
        assert parsed["type"] == "bar"

    @patch("builtins.open", new_callable=mock_open)
    def test_export_html(self, mock_file):
        """Test exporting as HTML."""
        visualization = {"type": "bar", "data": {}}
        config = ChartConfig(type=ChartType.BAR, title="Test Chart")

        export_visualization(visualization, "chart.html", format="html", config=config)

        mock_file.assert_called_once_with(Path("chart.html"), "w")
        handle = mock_file()
        written_content = "".join(call.args[0] for call in handle.write.call_args_list)

        # Verify HTML structure
        assert "<!DOCTYPE html>" in written_content
        assert "Chart.js" in written_content
        assert "Test Chart" in written_content

    def test_export_unsupported_format(self):
        """Test exporting with unsupported format."""
        visualization = {"type": "bar"}

        with pytest.raises(NotImplementedError, match="SVG export requires"):
            export_visualization(visualization, "chart.svg", format="svg")

        with pytest.raises(ValueError, match="Unsupported export format"):
            export_visualization(visualization, "chart.xyz", format="xyz")


class TestCombineVisualizations:
    """Test suite for combining visualizations."""

    def test_combine_grid_layout(self):
        """Test combining with grid layout."""
        viz1 = {"type": "bar", "data": {}}
        viz2 = {"type": "line", "data": {}}

        dashboard = combine_visualizations([viz1, viz2], layout="grid", title="Dashboard")

        assert dashboard["type"] == "dashboard"
        assert dashboard["title"] == "Dashboard"
        assert dashboard["layout"] == "grid"
        assert len(dashboard["visualizations"]) == 2
        assert dashboard["options"]["responsive"] == True

    def test_combine_vertical_layout(self):
        """Test combining with vertical layout."""
        visualizations = [
            {"type": "bar", "data": {}},
            {"type": "pie", "data": {}},
            {"type": "line", "data": {}},
        ]

        dashboard = combine_visualizations(visualizations, layout="vertical")

        assert dashboard["layout"] == "vertical"
        assert len(dashboard["visualizations"]) == 3

    def test_combine_default_title(self):
        """Test combining with default title."""
        dashboard = combine_visualizations([{"type": "bar"}])

        assert dashboard["title"] == "Dashboard"


class TestPrivateFunctions:
    """Test suite for private helper functions."""

    def test_generate_html_visualization(self):
        """Test HTML generation for single visualization."""
        from tenets.viz import _generate_html_visualization

        visualization = {"type": "bar", "data": {"labels": ["A"], "values": [1]}}
        config = ChartConfig(type=ChartType.BAR, title="Test", width=1000, height=600)

        html = _generate_html_visualization(visualization, config)

        assert "<!DOCTYPE html>" in html
        assert "Test" in html
        assert "1060px" in html  # width + padding
        assert "600px" in html
        assert json.dumps(visualization) in html

    def test_generate_dashboard_html(self):
        """Test HTML generation for dashboard."""
        from tenets.viz import _generate_dashboard_html

        dashboard = {
            "type": "dashboard",
            "title": "My Dashboard",
            "layout": "grid",
            "visualizations": [{"type": "bar", "data": {}}, {"type": "line", "data": {}}],
        }
        config = ChartConfig(type=ChartType.BAR)

        html = _generate_dashboard_html(dashboard, config)

        assert "<!DOCTYPE html>" in html
        assert "My Dashboard" in html
        assert "charts-grid" in html
        assert "chart0" in html
        assert "chart1" in html
        assert "Chart(ctx0" in html
        assert "Chart(ctx1" in html


class TestModuleImports:
    """Test module imports and public API."""

    def test_all_exports(self):
        """Test __all__ exports are available."""
        from tenets import viz

        expected_exports = [
            "BaseVisualizer",
            "ChartConfig",
            "ChartType",
            "ColorPalette",
            "DisplayConfig",
            "DisplayFormat",
            "ComplexityVisualizer",
            "ContributorVisualizer",
            "CouplingVisualizer",
            "TerminalDisplay",
            "ProgressDisplay",
            "create_visualizer",
            "create_chart",
            "create_terminal_display",
            "detect_visualization_type",
            "export_visualization",
            "combine_visualizations",
        ]

        for export in expected_exports:
            assert hasattr(viz, export)

    def test_version(self):
        """Test version is defined."""
        from tenets import viz

        assert hasattr(viz, "__version__")
        assert isinstance(viz.__version__, str)