"""
Tool_OCR - PDF Generator Unit Tests
Tests for app/services/pdf_generator.py
"""

import pytest
from pathlib import Path
from unittest.mock import Mock, patch, MagicMock
import subprocess

from app.services.pdf_generator import PDFGenerator, PDFGenerationError


@pytest.mark.unit
class TestPDFGeneratorInit:
    """Test PDF generator initialization"""

    def test_init(self):
        """Test PDF generator initialization"""
        generator = PDFGenerator()

        assert generator is not None
        assert hasattr(generator, 'css_templates')
        assert len(generator.css_templates) == 3
        assert 'default' in generator.css_templates
        assert 'academic' in generator.css_templates
        assert 'business' in generator.css_templates

    def test_css_templates_have_content(self):
        """Test that CSS templates contain content"""
        generator = PDFGenerator()

        for template_name, css_content in generator.css_templates.items():
            assert isinstance(css_content, str)
            assert len(css_content) > 100
            assert '@page' in css_content
            assert 'body' in css_content


@pytest.mark.unit
class TestPandocAvailability:
    """Test Pandoc availability checking"""

    @patch('subprocess.run')
    def test_check_pandoc_available_success(self, mock_run):
        """Test Pandoc availability check when pandoc is installed"""
        mock_run.return_value = Mock(returncode=0, stdout="pandoc 2.x")

        generator = PDFGenerator()
        is_available = generator.check_pandoc_available()

        assert is_available is True
        mock_run.assert_called_once()
        assert mock_run.call_args[0][0] == ["pandoc", "--version"]

    @patch('subprocess.run')
    def test_check_pandoc_available_not_found(self, mock_run):
        """Test Pandoc availability check when pandoc is not installed"""
        mock_run.side_effect = FileNotFoundError()

        generator = PDFGenerator()
        is_available = generator.check_pandoc_available()

        assert is_available is False

    @patch('subprocess.run')
    def test_check_pandoc_available_timeout(self, mock_run):
        """Test Pandoc availability check when command times out"""
        mock_run.side_effect = subprocess.TimeoutExpired("pandoc", 5)

        generator = PDFGenerator()
        is_available = generator.check_pandoc_available()

        assert is_available is False


@pytest.mark.unit
class TestPandocPDFGeneration:
    """Test PDF generation using Pandoc"""

    @pytest.fixture
    def sample_markdown(self, temp_dir):
        """Create a sample Markdown file"""
        md_file = temp_dir / "sample.md"
        md_file.write_text("# Test Document\n\nThis is a test.", encoding="utf-8")
        return md_file

    @patch('subprocess.run')
    def test_generate_pdf_pandoc_success(self, mock_run, sample_markdown, temp_dir):
        """Test successful PDF generation with Pandoc"""
        output_path = temp_dir / "output.pdf"
        mock_run.return_value = Mock(returncode=0, stderr="")

        # Create the output file to simulate successful generation
        output_path.touch()

        generator = PDFGenerator()
        result = generator.generate_pdf_pandoc(sample_markdown, output_path)

        assert result == output_path
        assert output_path.exists()
        mock_run.assert_called_once()

        # Verify pandoc command structure
        cmd_args = mock_run.call_args[0][0]
        assert "pandoc" in cmd_args
        assert str(sample_markdown) in cmd_args
        assert str(output_path) in cmd_args
        assert "--pdf-engine=weasyprint" in cmd_args

    @patch('subprocess.run')
    def test_generate_pdf_pandoc_with_metadata(self, mock_run, sample_markdown, temp_dir):
        """Test Pandoc PDF generation with metadata"""
        output_path = temp_dir / "output.pdf"
        mock_run.return_value = Mock(returncode=0, stderr="")
        output_path.touch()

        metadata = {
            "title": "Test Title",
            "author": "Test Author",
            "date": "2025-01-01"
        }

        generator = PDFGenerator()
        result = generator.generate_pdf_pandoc(
            sample_markdown,
            output_path,
            metadata=metadata
        )

        assert result == output_path

        # Verify metadata in command
        cmd_args = mock_run.call_args[0][0]
        assert "--metadata" in cmd_args
        assert "title=Test Title" in cmd_args
        assert "author=Test Author" in cmd_args
        assert "date=2025-01-01" in cmd_args

    @patch('subprocess.run')
    def test_generate_pdf_pandoc_with_custom_css(self, mock_run, sample_markdown, temp_dir):
        """Test Pandoc PDF generation with custom CSS template"""
        output_path = temp_dir / "output.pdf"
        mock_run.return_value = Mock(returncode=0, stderr="")
        output_path.touch()

        generator = PDFGenerator()
        result = generator.generate_pdf_pandoc(
            sample_markdown,
            output_path,
            css_template="academic"
        )

        assert result == output_path
        mock_run.assert_called_once()

    @patch('subprocess.run')
    def test_generate_pdf_pandoc_command_failed(self, mock_run, sample_markdown, temp_dir):
        """Test Pandoc PDF generation when command fails"""
        output_path = temp_dir / "output.pdf"
        mock_run.return_value = Mock(returncode=1, stderr="Pandoc error message")

        generator = PDFGenerator()

        with pytest.raises(PDFGenerationError) as exc_info:
            generator.generate_pdf_pandoc(sample_markdown, output_path)

        assert "Pandoc failed" in str(exc_info.value)
        assert "Pandoc error message" in str(exc_info.value)

    @patch('subprocess.run')
    def test_generate_pdf_pandoc_timeout(self, mock_run, sample_markdown, temp_dir):
        """Test Pandoc PDF generation timeout"""
        output_path = temp_dir / "output.pdf"
        mock_run.side_effect = subprocess.TimeoutExpired("pandoc", 60)

        generator = PDFGenerator()

        with pytest.raises(PDFGenerationError) as exc_info:
            generator.generate_pdf_pandoc(sample_markdown, output_path)

        assert "timed out" in str(exc_info.value).lower()

    @patch('subprocess.run')
    def test_generate_pdf_pandoc_output_not_created(self, mock_run, sample_markdown, temp_dir):
        """Test when Pandoc command succeeds but output file not created"""
        output_path = temp_dir / "output.pdf"
        mock_run.return_value = Mock(returncode=0, stderr="")
        # Don't create output file

        generator = PDFGenerator()

        with pytest.raises(PDFGenerationError) as exc_info:
            generator.generate_pdf_pandoc(sample_markdown, output_path)

        assert "PDF file not created" in str(exc_info.value)


@pytest.mark.unit
class TestWeasyPrintPDFGeneration:
    """Test PDF generation using WeasyPrint directly"""

    @pytest.fixture
    def sample_markdown(self, temp_dir):
        """Create a sample Markdown file"""
        md_file = temp_dir / "sample.md"
        md_file.write_text("# Test Document\n\nThis is a test.", encoding="utf-8")
        return md_file

    @patch('app.services.pdf_generator.HTML')
    @patch('app.services.pdf_generator.CSS')
    def test_generate_pdf_weasyprint_success(self, mock_css, mock_html, sample_markdown, temp_dir):
        """Test successful PDF generation with WeasyPrint"""
        output_path = temp_dir / "output.pdf"

        # Mock HTML and CSS objects
        mock_html_instance = Mock()
        mock_html_instance.write_pdf = Mock()
        mock_html.return_value = mock_html_instance

        # Create output file to simulate successful generation
        def create_pdf(*args, **kwargs):
            output_path.touch()

        mock_html_instance.write_pdf.side_effect = create_pdf

        generator = PDFGenerator()
        result = generator.generate_pdf_weasyprint(sample_markdown, output_path)

        assert result == output_path
        assert output_path.exists()
        mock_html.assert_called_once()
        mock_css.assert_called_once()
        mock_html_instance.write_pdf.assert_called_once()

    @patch('app.services.pdf_generator.HTML')
    @patch('app.services.pdf_generator.CSS')
    def test_generate_pdf_weasyprint_with_metadata(self, mock_css, mock_html, sample_markdown, temp_dir):
        """Test WeasyPrint PDF generation with metadata"""
        output_path = temp_dir / "output.pdf"

        mock_html_instance = Mock()
        mock_html_instance.write_pdf = Mock()
        mock_html.return_value = mock_html_instance

        def create_pdf(*args, **kwargs):
            output_path.touch()

        mock_html_instance.write_pdf.side_effect = create_pdf

        metadata = {
            "title": "Test Title",
            "author": "Test Author"
        }

        generator = PDFGenerator()
        result = generator.generate_pdf_weasyprint(
            sample_markdown,
            output_path,
            metadata=metadata
        )

        assert result == output_path

        # Check that HTML string includes title
        html_call_args = mock_html.call_args
        assert html_call_args[1]['string'] is not None
        assert "Test Title" in html_call_args[1]['string']

    @patch('app.services.pdf_generator.HTML')
    def test_generate_pdf_weasyprint_markdown_conversion(self, mock_html, sample_markdown, temp_dir):
        """Test that Markdown is properly converted to HTML"""
        output_path = temp_dir / "output.pdf"

        captured_html = None

        def capture_html(string, **kwargs):
            nonlocal captured_html
            captured_html = string
            mock_instance = Mock()
            mock_instance.write_pdf = Mock(side_effect=lambda *args, **kwargs: output_path.touch())
            return mock_instance

        mock_html.side_effect = capture_html

        generator = PDFGenerator()
        generator.generate_pdf_weasyprint(sample_markdown, output_path)

        # Verify HTML structure
        assert captured_html is not None
        assert "<!DOCTYPE html>" in captured_html
        assert "<h1>Test Document</h1>" in captured_html
        assert "<p>This is a test.</p>" in captured_html

    @patch('app.services.pdf_generator.HTML')
    @patch('app.services.pdf_generator.CSS')
    def test_generate_pdf_weasyprint_with_template(self, mock_css, mock_html, sample_markdown, temp_dir):
        """Test WeasyPrint PDF generation with different templates"""
        output_path = temp_dir / "output.pdf"

        mock_html_instance = Mock()
        mock_html_instance.write_pdf = Mock()
        mock_html.return_value = mock_html_instance

        def create_pdf(*args, **kwargs):
            output_path.touch()

        mock_html_instance.write_pdf.side_effect = create_pdf

        generator = PDFGenerator()

        # Test academic template
        generator.generate_pdf_weasyprint(
            sample_markdown,
            output_path,
            css_template="academic"
        )

        # Verify CSS was called with academic template content
        css_call_args = mock_css.call_args
        assert css_call_args[1]['string'] is not None
        assert "Times New Roman" in css_call_args[1]['string']

    @patch('app.services.pdf_generator.HTML')
    def test_generate_pdf_weasyprint_error_handling(self, mock_html, sample_markdown, temp_dir):
        """Test WeasyPrint error handling"""
        output_path = temp_dir / "output.pdf"

        mock_html.side_effect = Exception("WeasyPrint rendering error")

        generator = PDFGenerator()

        with pytest.raises(PDFGenerationError) as exc_info:
            generator.generate_pdf_weasyprint(sample_markdown, output_path)

        assert "WeasyPrint PDF generation failed" in str(exc_info.value)


@pytest.mark.unit
class TestUnifiedPDFGeneration:
    """Test unified PDF generation with automatic fallback"""

    @pytest.fixture
    def sample_markdown(self, temp_dir):
        """Create a sample Markdown file"""
        md_file = temp_dir / "sample.md"
        md_file.write_text("# Test Document\n\nTest content.", encoding="utf-8")
        return md_file

    def test_generate_pdf_nonexistent_markdown(self, temp_dir):
        """Test error when Markdown file doesn't exist"""
        nonexistent = temp_dir / "nonexistent.md"
        output_path = temp_dir / "output.pdf"

        generator = PDFGenerator()

        with pytest.raises(PDFGenerationError) as exc_info:
            generator.generate_pdf(nonexistent, output_path)

        assert "not found" in str(exc_info.value).lower()

    @patch.object(PDFGenerator, 'check_pandoc_available')
    @patch.object(PDFGenerator, 'generate_pdf_pandoc')
    def test_generate_pdf_prefers_pandoc(self, mock_pandoc_gen, mock_check, sample_markdown, temp_dir):
        """Test that Pandoc is preferred when available"""
        output_path = temp_dir / "output.pdf"
        output_path.touch()

        mock_check.return_value = True
        mock_pandoc_gen.return_value = output_path

        generator = PDFGenerator()
        result = generator.generate_pdf(sample_markdown, output_path, prefer_pandoc=True)

        assert result == output_path
        mock_check.assert_called_once()
        mock_pandoc_gen.assert_called_once()

    @patch.object(PDFGenerator, 'check_pandoc_available')
    @patch.object(PDFGenerator, 'generate_pdf_weasyprint')
    def test_generate_pdf_uses_weasyprint_when_pandoc_unavailable(
        self, mock_weasy_gen, mock_check, sample_markdown, temp_dir
    ):
        """Test fallback to WeasyPrint when Pandoc unavailable"""
        output_path = temp_dir / "output.pdf"
        output_path.touch()

        mock_check.return_value = False
        mock_weasy_gen.return_value = output_path

        generator = PDFGenerator()
        result = generator.generate_pdf(sample_markdown, output_path, prefer_pandoc=True)

        assert result == output_path
        mock_check.assert_called_once()
        mock_weasy_gen.assert_called_once()

    @patch.object(PDFGenerator, 'check_pandoc_available')
    @patch.object(PDFGenerator, 'generate_pdf_pandoc')
    @patch.object(PDFGenerator, 'generate_pdf_weasyprint')
    def test_generate_pdf_fallback_on_pandoc_failure(
        self, mock_weasy_gen, mock_pandoc_gen, mock_check, sample_markdown, temp_dir
    ):
        """Test automatic fallback to WeasyPrint when Pandoc fails"""
        output_path = temp_dir / "output.pdf"
        output_path.touch()

        mock_check.return_value = True
        mock_pandoc_gen.side_effect = PDFGenerationError("Pandoc failed")
        mock_weasy_gen.return_value = output_path

        generator = PDFGenerator()
        result = generator.generate_pdf(sample_markdown, output_path, prefer_pandoc=True)

        assert result == output_path
        mock_pandoc_gen.assert_called_once()
        mock_weasy_gen.assert_called_once()

    @patch.object(PDFGenerator, 'check_pandoc_available')
    @patch.object(PDFGenerator, 'generate_pdf_weasyprint')
    def test_generate_pdf_creates_output_directory(
        self, mock_weasy_gen, mock_check, sample_markdown, temp_dir
    ):
        """Test that output directory is created if needed"""
        output_dir = temp_dir / "subdir" / "outputs"
        output_path = output_dir / "output.pdf"
        output_path.parent.mkdir(parents=True, exist_ok=True)
        output_path.touch()

        mock_check.return_value = False
        mock_weasy_gen.return_value = output_path

        generator = PDFGenerator()
        result = generator.generate_pdf(sample_markdown, output_path)

        assert output_dir.exists()
        assert result == output_path


@pytest.mark.unit
class TestTemplateManagement:
    """Test CSS template management"""

    def test_get_available_templates(self):
        """Test retrieving available templates"""
        generator = PDFGenerator()
        templates = generator.get_available_templates()

        assert isinstance(templates, dict)
        assert len(templates) == 3
        assert "default" in templates
        assert "academic" in templates
        assert "business" in templates

        # Check descriptions are in Chinese
        for desc in templates.values():
            assert isinstance(desc, str)
            assert len(desc) > 0

    def test_save_custom_template(self):
        """Test saving a custom CSS template"""
        generator = PDFGenerator()

        custom_css = "@page { size: A4; }"
        generator.save_custom_template("custom", custom_css)

        assert "custom" in generator.css_templates
        assert generator.css_templates["custom"] == custom_css

    def test_save_custom_template_overwrites_existing(self):
        """Test that saving custom template can overwrite existing"""
        generator = PDFGenerator()

        new_css = "@page { size: Letter; }"
        generator.save_custom_template("default", new_css)

        assert generator.css_templates["default"] == new_css


@pytest.mark.unit
class TestEdgeCases:
    """Test edge cases and error handling"""

    @pytest.fixture
    def sample_markdown(self, temp_dir):
        """Create a sample Markdown file"""
        md_file = temp_dir / "sample.md"
        md_file.write_text("# Test", encoding="utf-8")
        return md_file

    @patch('app.services.pdf_generator.HTML')
    @patch('app.services.pdf_generator.CSS')
    def test_generate_with_unicode_content(self, mock_css, mock_html, temp_dir):
        """Test PDF generation with Unicode/Chinese content"""
        md_file = temp_dir / "unicode.md"
        md_file.write_text("# 測試文檔\n\n這是中文內容。", encoding="utf-8")
        output_path = temp_dir / "output.pdf"

        captured_html = None

        def capture_html(string, **kwargs):
            nonlocal captured_html
            captured_html = string
            mock_instance = Mock()
            mock_instance.write_pdf = Mock(side_effect=lambda *args, **kwargs: output_path.touch())
            return mock_instance

        mock_html.side_effect = capture_html

        generator = PDFGenerator()
        result = generator.generate_pdf_weasyprint(md_file, output_path)

        assert result == output_path
        assert "測試文檔" in captured_html
        assert "中文內容" in captured_html

    @patch('app.services.pdf_generator.HTML')
    @patch('app.services.pdf_generator.CSS')
    def test_generate_with_table_markdown(self, mock_css, mock_html, temp_dir):
        """Test PDF generation with Markdown tables"""
        md_file = temp_dir / "table.md"
        md_content = """
# Document with Table

| Column 1 | Column 2 |
|----------|----------|
| Data 1   | Data 2   |
"""
        md_file.write_text(md_content, encoding="utf-8")
        output_path = temp_dir / "output.pdf"

        captured_html = None

        def capture_html(string, **kwargs):
            nonlocal captured_html
            captured_html = string
            mock_instance = Mock()
            mock_instance.write_pdf = Mock(side_effect=lambda *args, **kwargs: output_path.touch())
            return mock_instance

        mock_html.side_effect = capture_html

        generator = PDFGenerator()
        result = generator.generate_pdf_weasyprint(md_file, output_path)

        assert result == output_path
        # Markdown tables should be converted to HTML tables
        assert "<table>" in captured_html
        assert "<th>" in captured_html or "<td>" in captured_html

    def test_custom_css_string_not_in_templates(self, sample_markdown, temp_dir):
        """Test using custom CSS string that's not a template name"""
        generator = PDFGenerator()

        # This should work - treat as custom CSS string
        custom_css = "body { font-size: 20pt; }"

        # When CSS template is not in templates dict, it should be used as-is
        assert custom_css not in generator.css_templates.values()