"""
HTML 渲染器单元测试

测试 HtmlRenderer 类的各个渲染方法
"""

import pytest
from pathlib import Path
from renderers.html_renderer import HtmlRenderer, DPI
from core.elements import TextElement, ImageElement, ShapeElement, TableElement


class TestHtmlRenderer:
    """HtmlRenderer 测试类"""

    def test_renderer_has_dpi_constant(self):
        """测试渲染器有 DPI 常量"""
        assert DPI == 96

    def test_init_renderer(self):
        """测试创建渲染器"""
        renderer = HtmlRenderer()
        assert renderer is not None


class TestRenderText:
    """render_text 方法测试类"""

    def test_render_text_basic(self):
        """测试渲染基本文本"""
        renderer = HtmlRenderer()
        elem = TextElement(
            content="Test Content",
            box=[1, 2, 3, 0.5],
            font={"size": 18, "color": "#333333"}
        )

        html = renderer.render_text(elem)

        assert "Test Content" in html
        assert "text-element" in html
        assert "left: 96px" in html  # 1 * 96
        assert "top: 192px" in html  # 2 * 96
        assert "font-size: 18pt" in html
        assert "color: #333333" in html

    def test_render_text_with_bold(self):
        """测试渲染粗体文本"""
        renderer = HtmlRenderer()
        elem = TextElement(
            content="Bold Text",
            box=[0, 0, 1, 1],
            font={"size": 16, "bold": True}
        )

        html = renderer.render_text(elem)

        assert "font-weight: bold;" in html

    def test_render_text_with_italic(self):
        """测试渲染斜体文本"""
        renderer = HtmlRenderer()
        elem = TextElement(
            content="Italic Text",
            box=[0, 0, 1, 1],
            font={"size": 16, "italic": True}
        )

        html = renderer.render_text(elem)

        assert "font-style: italic;" in html

    def test_render_text_with_center_align(self):
        """测试渲染居中对齐文本"""
        renderer = HtmlRenderer()
        elem = TextElement(
            content="Centered",
            box=[0, 0, 1, 1],
            font={"align": "center"}
        )

        html = renderer.render_text(elem)

        assert "text-align: center;" in html

    def test_render_text_with_right_align(self):
        """测试渲染右对齐文本"""
        renderer = HtmlRenderer()
        elem = TextElement(
            content="Right Aligned",
            box=[0, 0, 1, 1],
            font={"align": "right"}
        )

        html = renderer.render_text(elem)

        assert "text-align: right;" in html

    def test_render_text_with_default_align(self):
        """测试默认左对齐"""
        renderer = HtmlRenderer()
        elem = TextElement(
            content="Default",
            box=[0, 0, 1, 1],
            font={}
        )

        html = renderer.render_text(elem)

        assert "text-align: left;" in html

    def test_render_text_escapes_html(self):
        """测试 HTML 特殊字符转义"""
        renderer = HtmlRenderer()
        elem = TextElement(
            content="<script>alert('xss')</script>",
            box=[0, 0, 1, 1],
            font={}
        )

        html = renderer.render_text(elem)

        assert "&lt;" in html
        assert "&gt;" in html
        assert "<script>" not in html

    def test_render_text_with_special_characters(self):
        """测试特殊字符处理"""
        renderer = HtmlRenderer()
        elem = TextElement(
            content="Test & < > \" '",
            box=[0, 0, 1, 1],
            font={}
        )

        html = renderer.render_text(elem)

        assert "&amp;" in html
        assert "&lt;" in html
        assert "&gt;" in html

    def test_render_text_with_long_content(self):
        """测试长文本内容"""
        renderer = HtmlRenderer()
        long_content = "A" * 500
        elem = TextElement(
            content=long_content,
            box=[0, 0, 5, 1],
            font={"size": 12}
        )

        html = renderer.render_text(elem)

        assert long_content in html
        assert "word-wrap: break-word" in html

    def test_render_text_with_newlines(self):
        """测试包含换行符的文本"""
        renderer = HtmlRenderer()
        elem = TextElement(
            content="Line 1\nLine 2\nLine 3",
            box=[0, 0, 5, 2],
            font={"size": 14}
        )

        html = renderer.render_text(elem)

        # 换行符应该被保留
        assert "Line 1" in html
        assert "Line 2" in html

    def test_render_text_with_unicode(self):
        """测试 Unicode 字符"""
        renderer = HtmlRenderer()
        elem = TextElement(
            content="测试中文 🌍",
            box=[0, 0, 5, 1],
            font={"size": 16}
        )

        html = renderer.render_text(elem)

        assert "测试中文" in html
        assert "🌍" in html

    def test_render_text_with_empty_font(self):
        """测试空字体属性"""
        renderer = HtmlRenderer()
        elem = TextElement(
            content="Test",
            box=[0, 0, 1, 1],
            font={}
        )

        html = renderer.render_text(elem)

        # 应该使用默认值
        assert "font-size: 16pt" in html
        assert "color: #000000" in html


class TestRenderShape:
    """render_shape 方法测试类"""

    def test_render_rectangle(self):
        """测试渲染矩形"""
        renderer = HtmlRenderer()
        elem = ShapeElement(
            box=[1, 1, 2, 1],
            shape="rectangle",
            fill="#4a90e2"
        )

        html = renderer.render_shape(elem)

        assert "shape-element" in html
        assert "background: #4a90e2" in html
        assert "border-radius: 0;" in html

    def test_render_ellipse(self):
        """测试渲染椭圆"""
        renderer = HtmlRenderer()
        elem = ShapeElement(
            box=[1, 1, 2, 2],
            shape="ellipse",
            fill="#e24a4a"
        )

        html = renderer.render_shape(elem)

        assert "border-radius: 50%" in html
        assert "background: #e24a4a" in html

    def test_render_rounded_rectangle(self):
        """测试渲染圆角矩形"""
        renderer = HtmlRenderer()
        elem = ShapeElement(
            box=[1, 1, 2, 1],
            shape="rounded_rectangle",
            fill="#4ae290"
        )

        html = renderer.render_shape(elem)

        assert "border-radius: 8px" in html
        assert "background: #4ae290" in html

    def test_render_shape_without_fill(self):
        """测试无填充颜色的形状"""
        renderer = HtmlRenderer()
        elem = ShapeElement(
            box=[1, 1, 2, 1],
            shape="rectangle",
            fill=None
        )

        html = renderer.render_shape(elem)

        assert "background: transparent" in html

    def test_render_shape_with_line(self):
        """测试带边框的形状"""
        renderer = HtmlRenderer()
        elem = ShapeElement(
            box=[1, 1, 2, 1],
            shape="rectangle",
            fill="#4a90e2",
            line={"color": "#000000", "width": 2}
        )

        html = renderer.render_shape(elem)

        assert "border: 2pt solid #000000" in html

    def test_render_shape_with_line_default_width(self):
        """测试边框默认宽度"""
        renderer = HtmlRenderer()
        elem = ShapeElement(
            box=[1, 1, 2, 1],
            shape="rectangle",
            fill="#4a90e2",
            line={"color": "#000000"}
        )

        html = renderer.render_shape(elem)

        assert "border: 1pt solid #000000" in html

    def test_render_shape_without_line(self):
        """测试无边框的形状"""
        renderer = HtmlRenderer()
        elem = ShapeElement(
            box=[1, 1, 2, 1],
            shape="rectangle",
            fill="#4a90e2"
        )

        html = renderer.render_shape(elem)

        assert "border:" not in html

    def test_render_shape_position(self):
        """测试形状位置计算"""
        renderer = HtmlRenderer()
        elem = ShapeElement(
            box=[1.5, 2.5, 3, 1.5],
            shape="rectangle",
            fill="#000000"
        )

        html = renderer.render_shape(elem)

        # 1.5 * 96 = 144
        assert "left: 144px" in html
        # 2.5 * 96 = 240
        assert "top: 240px" in html
        # 3 * 96 = 288
        assert "width: 288px" in html
        # 1.5 * 96 = 144
        assert "height: 144px" in html


class TestRenderTable:
    """render_table 方法测试类"""

    def test_render_basic_table(self):
        """测试渲染基本表格"""
        renderer = HtmlRenderer()
        elem = TableElement(
            position=[1, 1],
            col_widths=[2, 2, 2],
            data=[["A", "B", "C"], ["1", "2", "3"]],
            style={}
        )

        html = renderer.render_table(elem)

        assert "table-element" in html
        assert "A" in html
        assert "B" in html
        assert "C" in html
        assert "1" in html
        assert "2" in html
        assert "3" in html

    def test_render_table_with_header_style(self):
        """测试表格表头样式"""
        renderer = HtmlRenderer()
        elem = TableElement(
            position=[1, 1],
            col_widths=[2, 2],
            data=[["H1", "H2"], ["D1", "D2"]],
            style={
                "font_size": 14,
                "header_bg": "#4a90e2",
                "header_color": "#ffffff"
            }
        )

        html = renderer.render_table(elem)

        assert "background: #4a90e2" in html
        assert "color: #ffffff" in html
        assert "font-size: 14pt" in html

    def test_render_table_position(self):
        """测试表格位置"""
        renderer = HtmlRenderer()
        elem = TableElement(
            position=[2, 3],
            col_widths=[1, 1],
            data=[["A", "B"]],
            style={}
        )

        html = renderer.render_table(elem)

        # 2 * 96 = 192
        assert "left: 192px" in html
        # 3 * 96 = 288
        assert "top: 288px" in html

    def test_render_table_with_default_font_size(self):
        """测试默认字体大小"""
        renderer = HtmlRenderer()
        elem = TableElement(
            position=[0, 0],
            col_widths=[1],
            data=[["Cell"]],
            style={}
        )

        html = renderer.render_table(elem)

        assert "font-size: 14pt" in html

    def test_render_table_escapes_content(self):
        """测试表格内容转义"""
        renderer = HtmlRenderer()
        elem = TableElement(
            position=[0, 0],
            col_widths=[1],
            data=[["<script>"]],
            style={}
        )

        html = renderer.render_table(elem)

        assert "&lt;" in html
        assert "<script>" not in html

    def test_render_table_with_single_row(self):
        """测试单行表格"""
        renderer = HtmlRenderer()
        elem = TableElement(
            position=[0, 0],
            col_widths=[1, 2, 3],
            data=[["A", "B", "C"]],
            style={}
        )

        html = renderer.render_table(elem)

        assert "<tr>" in html
        assert "<td>" in html
        assert "A" in html

    def test_render_table_with_many_rows(self):
        """测试多行表格"""
        renderer = HtmlRenderer()
        elem = TableElement(
            position=[0, 0],
            col_widths=[1, 1],
            data=[["R1C1", "R1C2"], ["R2C1", "R2C2"], ["R3C1", "R3C2"]],
            style={}
        )

        html = renderer.render_table(elem)

        assert html.count("<tr>") == 3
        assert html.count("<td>") == 6

    def test_render_table_with_unicode(self):
        """测试表格 Unicode 内容"""
        renderer = HtmlRenderer()
        elem = TableElement(
            position=[0, 0],
            col_widths=[1],
            data=[["测试"]],
            style={}
        )

        html = renderer.render_table(elem)

        assert "测试" in html


class TestRenderImage:
    """render_image 方法测试类"""

    def test_render_image_basic(self, temp_dir):
        """测试渲染基本图片"""
        renderer = HtmlRenderer()
        elem = ImageElement(
            box=[1, 1, 4, 3],
            src="test.png"
        )

        html = renderer.render_image(elem, temp_dir)

        assert "image-element" in html
        assert "test.png" in html
        assert "left: 96px" in html  # 1 * 96
        assert "top: 96px" in html

    def test_render_image_with_base_path(self, temp_dir):
        """测试带基础路径的图片"""
        renderer = HtmlRenderer()
        elem = ImageElement(
            box=[0, 0, 2, 2],
            src="subdir/image.png"
        )

        html = renderer.render_image(elem, temp_dir)

        assert "subdir/image.png" in html

    def test_render_image_without_base_path(self):
        """测试无基础路径的图片"""
        renderer = HtmlRenderer()
        elem = ImageElement(
            box=[0, 0, 2, 2],
            src="/absolute/path/image.png"
        )

        html = renderer.render_image(elem, None)

        assert "/absolute/path/image.png" in html

    def test_render_image_position_calculation(self):
        """测试图片位置计算"""
        renderer = HtmlRenderer()
        elem = ImageElement(
            box=[2.5, 3.5, 4, 3],
            src="test.png"
        )

        html = renderer.render_image(elem, None)

        # 2.5 * 96 = 240
        assert "left: 240px" in html
        # 3.5 * 96 = 336
        assert "top: 336px" in html
        # 4 * 96 = 384
        assert "width: 384px" in html
        # 3 * 96 = 288
        assert "height: 288px" in html


class TestRenderSlide:
    """render_slide 方法测试类"""

    def test_render_slide_basic(self):
        """测试渲染基本幻灯片"""
        renderer = HtmlRenderer()
        slide_data = {
            "background": None,
            "elements": [
                TextElement(content="Test", box=[0, 0, 1, 1], font={})
            ]
        }

        html = renderer.render_slide(slide_data, 0, None)

        assert '<div class="slide"' in html
        assert "幻灯片 1" in html
        assert "Test" in html

    def test_render_slide_with_background_color(self):
        """测试带背景颜色的幻灯片"""
        renderer = HtmlRenderer()
        slide_data = {
            "background": {"color": "#ffffff"},
            "elements": []
        }

        html = renderer.render_slide(slide_data, 0, None)

        assert "background: #ffffff" in html

    def test_render_slide_with_multiple_elements(self):
        """测试包含多个元素的幻灯片"""
        renderer = HtmlRenderer()
        slide_data = {
            "background": None,
            "elements": [
                TextElement(content="Text 1", box=[0, 0, 1, 1], font={}),
                ShapeElement(box=[2, 2, 1, 1], shape="rectangle", fill="#000")
            ]
        }

        html = renderer.render_slide(slide_data, 0, None)

        assert "Text 1" in html
        assert "shape-element" in html

    def test_render_slide_with_different_indices(self):
        """测试不同幻灯片索引"""
        renderer = HtmlRenderer()
        slide_data = {
            "background": None,
            "elements": []
        }

        html0 = renderer.render_slide(slide_data, 0, None)
        html1 = renderer.render_slide(slide_data, 1, None)
        html5 = renderer.render_slide(slide_data, 5, None)

        assert "幻灯片 1" in html0
        assert "幻灯片 2" in html1
        assert "幻灯片 6" in html5

    def test_render_slide_without_background(self):
        """测试无背景的幻灯片"""
        renderer = HtmlRenderer()
        slide_data = {
            "background": None,
            "elements": []
        }

        html = renderer.render_slide(slide_data, 0, None)

        # 应该有 slide div 但没有 background style
        assert '<div class="slide"' in html
        # 不应该有 background: 样式
        assert "background:" not in html

    def test_render_slide_empty_elements(self):
        """测试空元素列表"""
        renderer = HtmlRenderer()
        slide_data = {
            "background": None,
            "elements": []
        }

        html = renderer.render_slide(slide_data, 0, None)

        assert '<div class="slide"' in html
        assert "幻灯片 1" in html

    def test_render_slide_with_render_error(self):
        """测试元素渲染错误处理"""
        renderer = HtmlRenderer()

        # 创建一个会引发错误的元素
        class BadElement:
            box = [0, 0, 1, 1]
            @property
            def type(self):
                raise ValueError("Simulated error")

        slide_data = {
            "background": None,
            "elements": [BadElement()]
        }

        html = renderer.render_slide(slide_data, 0, None)

        # 应该包含错误信息
        assert "渲染错误" in html