#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""Convert knowledge_report.html to Word document using python-docx"""

from docx import Document
from docx.shared import Pt, Inches, Cm, RGBColor
from docx.enum.text import WD_ALIGN_PARAGRAPH
from docx.enum.table import WD_TABLE_ALIGNMENT
from docx.oxml.ns import qn
from html.parser import HTMLParser
import re

class HTMLToDocx:
    def __init__(self):
        self.doc = Document()
        self.setup_styles()
        self.in_cover = False
        self.in_exam = False
        self.in_table = False
        self.current_tr = []
        self.current_cells = []
        self.in_th = False
        self.in_td = False
        self.in_ul = False
        self.in_ol = False
        self.list_counter = 0
        self.current_text = ''
        
        # Page margins
        for section in self.doc.sections:
            section.top_margin = Cm(2.5)
            section.bottom_margin = Cm(2.0)
            section.left_margin = Cm(2.5)
            section.right_margin = Cm(2.5)
    
    def setup_styles(self):
        style = self.doc.styles['Normal']
        font = style.font
        font.name = 'Microsoft YaHei'
        font.size = Pt(11)
        style.element.rPr.rFonts.set(qn('w:eastAsia'), 'Microsoft YaHei')
        
        # Title style
        title_style = self.doc.styles['Title']
        title_style.font.size = Pt(22)
        title_style.font.color.rgb = RGBColor(0x1a, 0x52, 0x76)
        
        # Heading styles
        for i, (size, color) in enumerate([
            (Pt(16), RGBColor(0x2c, 0x3e, 0x50)),  # Heading 1
            (Pt(14), RGBColor(0x2c, 0x3e, 0x50)),  # Heading 2
            (Pt(12), RGBColor(0x34, 0x49, 0x5e)),  # Heading 3
        ], 1):
            h_style = self.doc.styles[f'Heading {i}']
            h_style.font.size = size
            h_style.font.color.rgb = color
            h_style.font.bold = True
            h_style.paragraph_format.space_before = Pt(12)
            h_style.paragraph_format.space_after = Pt(6)
    
    def add_paragraph(self, text, bold=False, indent=True, align=None, size=None, color=None, spacing_after=Pt(6)):
        p = self.doc.add_paragraph()
        run = p.add_run(text)
        run.font.name = 'Microsoft YaHei'
        run._element.rPr.rFonts.set(qn('w:eastAsia'), 'Microsoft YaHei')
        if bold:
            run.bold = True
        if size:
            run.font.size = size
        if color:
            run.font.color.rgb = color
        if indent:
            p.paragraph_format.first_line_indent = Cm(0.75)
        if align:
            p.alignment = align
        p.paragraph_format.space_after = spacing_after
        return p
    
    def add_heading_text(self, text, level=1):
        p = self.doc.add_heading(text, level=level)
        for run in p.runs:
            run.font.name = 'Microsoft YaHei'
            run._element.rPr.rFonts.set(qn('w:eastAsia'), 'Microsoft YaHei')
        return p
    
    def add_table_from_data(self, rows):
        """Add a table from parsed rows"""
        if not rows:
            return
        
        max_cols = max(len(r) for r in rows)
        if max_cols < 2:
            return
            
        table = self.doc.add_table(rows=len(rows), cols=max_cols)
        table.alignment = WD_TABLE_ALIGNMENT.CENTER
        table.style = 'Table Grid'
        
        for i, row_data in enumerate(rows):
            for j, cell_text in enumerate(row_data):
                if j >= max_cols:
                    break
                cell = table.cell(i, j)
                cell.text = str(cell_text)
                for paragraph in cell.paragraphs:
                    paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
                    for run in paragraph.runs:
                        run.font.size = Pt(9)
                        run.font.name = 'Microsoft YaHei'
                        run._element.rPr.rFonts.set(qn('w:eastAsia'), 'Microsoft YaHei')
                        if i == 0:
                            run.bold = True
        
        # Bold first row
        for j in range(max_cols):
            cell = table.cell(0, j)
            for paragraph in cell.paragraphs:
                for run in paragraph.runs:
                    run.bold = True
        
        self.doc.add_paragraph()  # spacing
    
    def process_html(self, html):
        """Parse HTML and build docx"""
        lines = html.split('\n')
        in_code = False
        in_table_data = False
        table_rows = []
        in_div_exam = False
        exam_content = []
        
        i = 0
        while i < len(lines):
            line = lines[i].strip()
            
            # Skip style/head/meta/body tags
            if ('<style>' in line or line.startswith('<style') or 
                '<head>' in line or '</head>' in line or
                '<meta' in line or '<title>' in line or
                '<body>' in line or '</body>' in line or
                '<html>' in line or '</html>' in line or
                '<!DOCTYPE' in line or line.startswith('<?xml') or
                'npm' in line.lower()):
                i += 1
                continue
            
            # Cover page
            if 'class="cover"' in line or 'class="cover ' in line:
                self.in_cover = True
                i += 1
                continue
            if self.in_cover and '</div>' in line:
                self.in_cover = False
                # Add page break after cover
                self.doc.add_page_break()
                i += 1
                continue
            
            # Exam boxes
            if 'class="exam-box"' in line or 'class="exam-box ' in line:
                in_div_exam = True
                self.add_paragraph('', indent=False)  # spacing
                i += 1
                continue
            if in_div_exam and '</div>' in line:
                in_div_exam = False
                self.add_paragraph('', indent=False)
                i += 1
                continue
            
            # Table
            if '<table>' in line:
                table_rows = []
                in_table_data = True
                i += 1
                continue
            if '</table>' in line:
                in_table_data = False
                if table_rows:
                    self.add_table_from_data(table_rows)
                    table_rows = []
                i += 1
                continue
            
            if in_table_data:
                if '<tr>' in line:
                    current_row = []
                    i += 1
                    continue
                if '</tr>' in line:
                    if current_row:
                        table_rows.append(current_row)
                    i += 1
                    continue
                if '<th>' in line or line.startswith('<th'):
                    cell_text = re.sub(r'<[^>]+>', '', line)
                    current_row.append(cell_text.strip())
                    i += 1
                    continue
                if '<td>' in line or line.startswith('<td'):
                    cell_text = re.sub(r'<[^>]+>', '', line)
                    current_row.append(cell_text.strip())
                    i += 1
                    continue
                # Multi-line cell content
                if line and not line.startswith('<'):
                    if current_row:
                        current_row[-1] += ' ' + line.strip()
                i += 1
                continue
            
            # Headers
            h1_match = re.match(r'<h1>(.*?)</h1>', line)
            h2_match = re.match(r'<h2>(.*?)</h2>', line)
            h3_match = re.match(r'<h3>(.*?)</h3>', line)
            h4_match = re.match(r'<h4>(.*?)</h4>', line)
            
            if h1_match:
                text = re.sub(r'<[^>]+>', '', h1_match.group(1))
                if self.in_cover:
                    # This is the cover title
                    p = self.add_paragraph(text, bold=True, indent=False, 
                                          align=WD_ALIGN_PARAGRAPH.CENTER,
                                          size=Pt(22), color=RGBColor(0x1a, 0x52, 0x76))
                else:
                    # Normal H1 - might be exam section title
                    p = self.add_paragraph(text, bold=True, indent=False, size=Pt(16),
                                          color=RGBColor(0x2c, 0x3e, 0x50))
                    p.paragraph_format.space_before = Pt(18)
                    p.paragraph_format.space_after = Pt(10)
                
                i += 1
                continue
            
            if h2_match:
                text = re.sub(r'<[^>]+>', '', h2_match.group(1))
                p = self.doc.add_heading(text, level=2)
                for run in p.runs:
                    run.font.name = 'Microsoft YaHei'
                    run._element.rPr.rFonts.set(qn('w:eastAsia'), 'Microsoft YaHei')
                i += 1
                continue
            
            if h3_match:
                text = re.sub(r'<[^>]+>', '', h3_match.group(1))
                p = self.doc.add_heading(text, level=3)
                for run in p.runs:
                    run.font.name = 'Microsoft YaHei'
                    run._element.rPr.rFonts.set(qn('w:eastAsia'), 'Microsoft YaHei')
                i += 1
                continue
            
            if h4_match:
                text = re.sub(r'<[^>]+>', '', h4_match.group(1))
                p = self.add_paragraph(text, bold=True, indent=False)
                i += 1
                continue
            
            # Lists - ul/ol
            if '<ul>' in line:
                self.in_ul = True
                i += 1
                continue
            if '</ul>' in line:
                self.in_ul = False
                i += 1
                continue
            if '<ol>' in line:
                self.in_ol = True
                self.list_counter = 0
                i += 1
                continue
            if '</ol>' in line:
                self.in_ol = False
                self.list_counter = 0
                i += 1
                continue
            
            if '<li' in line:
                # Extract text
                text = re.sub(r'<[^>]+>', '', line)
                text = text.strip()
                if text:
                    if self.in_ol:
                        self.list_counter += 1
                        prefix = f"{self.list_counter}. "
                    else:
                        prefix = "• "
                    p = self.add_paragraph(prefix + text, indent=False, size=Pt(10.5))
                    p.paragraph_format.left_indent = Cm(1.0)
                i += 1
                continue
            
            # Hint divs
            if 'class="hint"' in line or 'class="hint ' in line:
                text = re.sub(r'<[^>]+>', '', line)
                text = text.strip()
                if text:
                    p = self.add_paragraph('💡 ' + text, indent=False, size=Pt(10))
                    p.paragraph_format.left_indent = Cm(0.5)
                    # Add shading
                    shading = p._element.get_or_add_pPr()
                i += 1
                continue
            
            # Regular paragraph
            if line and not line.startswith('<') and not line.startswith('</'):
                text = re.sub(r'<[^>]+>', '', line)
                text = text.strip()
                if text:
                    # Check if it's a subtitle in cover
                    if self.in_cover:
                        self.add_paragraph(text, indent=False, 
                                         align=WD_ALIGN_PARAGRAPH.CENTER,
                                         color=RGBColor(0x66, 0x66, 0x66))
                    else:
                        self.add_paragraph(text, indent=True)
            
            i += 1
    
    def save(self, path):
        self.doc.save(path)
        print(f"Saved: {path}")

if __name__ == '__main__':
    import sys
    html_path = '/root/.openclaw/workspace/knowledge_report.html'
    docx_path = '/root/.openclaw/workspace/knowledge_report.docx'
    
    with open(html_path, 'r', encoding='utf-8') as f:
        html_content = f.read()
    
    converter = HTMLToDocx()
    converter.process_html(html_content)
    converter.save(docx_path)