# -*- coding: utf-8 -*-
import io
import mistune
from bs4 import BeautifulSoup
from docx import Document
from docx.shared import Pt
from config import APP_CONFIG


class DocxBuildError(RuntimeError):
    """Raised when markdown cannot be rendered into a valid DOCX document."""


class DocxRenderer(mistune.HTMLRenderer):
    def __init__(self):
        super().__init__()
        self.doc = Document()
        self.h_counters = [0] * 6
        self.is_first_h1 = True
        try:
            style = self.doc.styles['Normal']
            style.font.name = APP_CONFIG["docx_styles"]["font_name"]
            style.font.size = Pt(APP_CONFIG["docx_styles"]["font_size_pt"])
        except: 
            pass

    def _render_rich_text(self, p, html_text):
        if not html_text.strip(): 
            return
            
        soup = BeautifulSoup(html_text, 'html.parser')
        for element in soup.children:
            if isinstance(element, str): 
                p.add_run(element)
            elif element.name in ['strong', 'b']: 
                p.add_run(element.get_text()).bold = True
            elif element.name in ['em', 'i']: 
                p.add_run(element.get_text()).italic = True
            elif element.name == 'code':
                run = p.add_run(element.get_text())
                run.font.name = APP_CONFIG["docx_styles"]["code_font"]
                run.font.size = Pt(APP_CONFIG["docx_styles"]["code_size_pt"])
            else: 
                p.add_run(element.get_text())

    def heading(self, text, level):
        clean_text = BeautifulSoup(text, 'html.parser').get_text().strip()
        lower_text = clean_text.lower()
        skip_keywords = APP_CONFIG["blacklists"]["meta_sections"]
        
        if any(kw in lower_text for kw in skip_keywords) or (level == 1 and self.is_first_h1):
            if level == 1: 
                self.is_first_h1 = False
            self.doc.add_heading(clean_text, level=1)
            return ''

        if level == 1: 
            self.is_first_h1 = False
            
        idx = level - 1
        if 0 <= idx < 6:
            for j in range(idx):
                if self.h_counters[j] == 0: 
                    self.h_counters[j] = 1
                    
            self.h_counters[idx] += 1
            for i in range(idx + 1, 6): 
                self.h_counters[i] = 0
                
            num_str = ".".join(map(str, self.h_counters[0:idx+1]))
            self.doc.add_heading(f"{num_str} {clean_text}", level=level)
        else: 
            self.doc.add_heading(clean_text, level=level)
        return ''

    def paragraph(self, text):
        if text.strip(): 
            self._render_rich_text(self.doc.add_paragraph(), text)
        return ''

    def block_code(self, code, info=None):
        run = self.doc.add_paragraph().add_run(code)
        run.font.name = APP_CONFIG["docx_styles"]["code_font"]
        run.font.size = Pt(APP_CONFIG["docx_styles"]["code_size_pt"])
        return ''

    def block_quote(self, text):
        p = self.doc.add_paragraph()
        self._render_rich_text(p, text)
        try: 
            p.style = 'Intense Quote' if 'Intense Quote' in self.doc.styles else 'Normal'
        except: 
            pass
        return ''

    def list(self, text, ordered, **attrs): 
        return text

    def list_item(self, text):
        if text.strip():
            p = self.doc.add_paragraph()
            p.style = 'List Bullet'
            self._render_rich_text(p, text)
        return ''

    def table(self, text):
        soup = BeautifulSoup(text, 'html.parser')
        rows = soup.find_all('tr')
        if not rows: 
            return ''
            
        max_cols = max(len(row.find_all(['td', 'th'])) for row in rows)
        if max_cols == 0: 
            return ''
            
        table = self.doc.add_table(rows=len(rows), cols=max_cols)
        try: 
            table.style = 'Table Grid'
        except: 
            pass
            
        for i, row in enumerate(rows):
            for j, cell in enumerate(row.find_all(['td', 'th'])):
                if j < max_cols: 
                    table.cell(i, j).text = cell.get_text(strip=True)
        self.doc.add_paragraph()
        return ''

    def thematic_break(self):
        self.doc.add_paragraph('_' * 50)
        return ''

    def image(self, src, alt="", title=None):
        self.doc.add_paragraph(f"[Image: {alt or src}]")
        return ''

def text_to_docx(markdown_content):
    """Render markdown strictly; never disguise renderer failures as success."""
    try:
        renderer = DocxRenderer()
        mistune.create_markdown(renderer=renderer, plugins=['table'])(str(markdown_content or ''))
        doc = renderer.doc
        if not doc.paragraphs and not doc.tables:
            raise DocxBuildError("DOCX renderer produced no document content.")
        stream = io.BytesIO()
        doc.save(stream)
        stream.seek(0)
        return stream
    except DocxBuildError:
        raise
    except Exception as exc:
        raise DocxBuildError(f"DOCX rendering failed: {exc}") from exc