import docx
from docx.document import Document

from .debugger import Debugger
from .parser_ import Parser
from .toc_processor import TocProcessor
from .renderer import Renderer
from .styles import apply_document_styles
from .profiles import (
    preprocess_markdown,
    find_formula_refs,
    get_profile,
    DEFAULT_HEADING_NUMBERING,
    HEADING_NUMBERING_MODES,
    DEFAULT_TOC_MODE,
    TOC_MODES,
    DEFAULT_TABLE_CONTINUATION,
    TABLE_CONTINUATION_MODES,
)
from .label_pass import (
    assign_numbers,
    set_active_registry,
    resolve_reference,
    resolve_pending_in_renderables,
)
from .renderable.heading import Heading
from .renderable.toc import ToC
from .renderable.table import Table


class Converter:
    """Converts markdown file to docx file (MIREA TZ)."""

    def __init__(self, input_path: str, output_path: str,
                 template_path: str = None, debug: bool = False,
                 doc_type: str = "coursework",
                 heading_numbering: str = DEFAULT_HEADING_NUMBERING,
                 emdash_to_hyphen: bool = False,
                 toc_mode: str = DEFAULT_TOC_MODE,
                 table_continuation: str = DEFAULT_TABLE_CONTINUATION):
        if heading_numbering not in HEADING_NUMBERING_MODES:
            raise ValueError(
                f"heading_numbering must be one of {HEADING_NUMBERING_MODES}, "
                f"got {heading_numbering!r}"
            )
        if toc_mode not in TOC_MODES:
            raise ValueError(
                f"toc_mode must be one of {TOC_MODES}, got {toc_mode!r}"
            )
        if table_continuation not in TABLE_CONTINUATION_MODES:
            raise ValueError(
                f"table_continuation must be one of {TABLE_CONTINUATION_MODES}, "
                f"got {table_continuation!r}"
            )
        self._output_path = output_path
        self._doc_type = doc_type
        self._heading_numbering = heading_numbering
        self._emdash_to_hyphen = emdash_to_hyphen
        self._toc_mode = toc_mode
        self._table_continuation = table_continuation
        self._profile = get_profile(doc_type)
        self._document: Document = docx.Document(template_path)
        self._document._body.clear_content()
        apply_document_styles(self._document, self._profile.style_preset)
        self._debugger = Debugger(self._document) if debug else None
        with open(input_path, encoding="utf-8") as f:
            raw = f.read()
        self._raw_markdown = raw
        self._preprocessed = preprocess_markdown(raw, emdash_to_hyphen=emdash_to_hyphen)
        self.parser = Parser(self._document, self._preprocessed)

    def convert(self):
        renderables = list(self.parser.parse())
        from .biblio_processor import fold_bibliography
        renderables = fold_bibliography(
            renderables, self._document._body, raw_markdown=self._preprocessed
        )

        # Resolve heading numbering mode + TOC mode + table continuation
        for r in renderables:
            if isinstance(r, Heading):
                r.apply_numbering_mode(self._heading_numbering)
            elif isinstance(r, ToC):
                r.set_heading_numbering(self._heading_numbering)
                r.set_toc_mode(self._toc_mode)
            elif isinstance(r, Table):
                r.set_continuation_mode(self._table_continuation)

        formula_refs = find_formula_refs(self._raw_markdown)
        registry = assign_numbers(
            renderables, formula_refs,
            numbering_scope=self._profile.numbering_scope,
        )
        set_active_registry(registry)
        resolve_pending_in_renderables(renderables, resolve_reference)

        renderer = Renderer(self._document, self._debugger,
                            numbered_equations=formula_refs,
                            skip_numbering=True,
                            numbering_scope=self._profile.numbering_scope)
        renderer.process(renderables)
        TocProcessor().process(renderables)
        set_active_registry(None)

    @property
    def document(self) -> Document:
        return self._document

    @property
    def raw_markdown(self) -> str:
        return self._raw_markdown

    @property
    def doc_type(self) -> str:
        return self._doc_type

    @property
    def heading_numbering(self) -> str:
        return self._heading_numbering