md2txt/md2txt.py

#!/usr/bin/env python3
"""
Convert Markdown into 80-column DOS-compatible plain text.
"""
from __future__ import annotations

import argparse
import re
import sys
import textwrap
from dataclasses import dataclass
from pathlib import Path
from typing import Callable, Dict, Iterable, List, Optional, Tuple

try:
    from pyfiglet import Figlet, FontNotFound
except ImportError:  # pragma: no cover - emit a helpful error at runtime instead
    Figlet = None  # type: ignore[assignment]
    FontNotFound = ValueError  # type: ignore[assignment]


FRONTMATTER_PATTERN = re.compile(r"^---\s*$")
HEADING_PATTERN = re.compile(r"^(#{1,6})\s+(.*)$")
ORDERED_LIST_PATTERN = re.compile(r"^(\s*)(\d+\.)(\s+)(.*)$")
UNORDERED_LIST_PATTERN = re.compile(r"^(\s*)([*+-])(\s+)(.*)$")
BLOCKQUOTE_PATTERN = re.compile(r"^\s{0,3}>(.*)$")
HORIZONTAL_RULE_PATTERN = re.compile(r"^\s*([-*_])(?:\s*\1){2,}\s*$")
INLINE_PARA_RE = re.compile(r"^\s*<p\b([^>]*)>(.*?)</p>\s*$", re.IGNORECASE)
PARA_OPEN_RE = re.compile(r"^\s*<p\b([^>]*)>\s*$", re.IGNORECASE)
PARA_CLOSE_RE = re.compile(r"^\s*</p>\s*$", re.IGNORECASE)
MMD_ATTR_LINE_RE = re.compile(r"^\{\s*:(.+)\}\s*$")
MMD_ATTR_TAIL_RE = re.compile(r"(.*?)\s*\{\s*:(.+?)\}\s*$")


@dataclass
class BlockStyle:
    align: str = "left"
    margin_left: int = 0
    margin_right: int = 0


@dataclass
class StyleSpec:
    align: Optional[str] = None
    margin_left: Optional[int] = None
    margin_right: Optional[int] = None


@dataclass
class BlockRecord:
    start: int
    length: int
    render: Callable[[BlockStyle], List[str]]
    style: BlockStyle


@dataclass
class FrontMatter:
    h1_font: str = "standard"
    h2_font: str = "standard"
    h3_font: str = "standard"


class MarkdownToTxtConverter:
    def __init__(self, width: int = 80, frontmatter: Optional[FrontMatter] = None) -> None:
        self.width = width
        self.frontmatter = frontmatter or FrontMatter()
        self.links: List[Tuple[int, str]] = []
        self.link_indices: Dict[str, int] = {}
        self.figlets: Dict[str, Figlet] = {}
        self._style_stack: List[BlockStyle] = [BlockStyle()]
        self._paragraph_style_spec: Optional[StyleSpec] = None
        self._pending_block_style_spec: Optional[StyleSpec] = None
        self._last_stylable_block: Optional[BlockRecord] = None

    def convert(self, lines: Iterable[str]) -> List[str]:
        output: List[str] = []
        self.links = []
        self.link_indices = {}
        self._style_stack = [BlockStyle()]
        self._paragraph_style_spec = None
        self._pending_block_style_spec = None
        self._last_stylable_block = None

        iterator = iter(lines)
        in_code_block = False
        code_lines: List[str] = []
        indented_code_lines: List[str] = []
        current_paragraph: List[str] = []

        for raw_line in iterator:
            line = raw_line.rstrip("\n")

            if in_code_block:
                if line.strip().startswith("```"):
                    self._emit_block(output, self._flush_code_block(code_lines))
                    code_lines = []
                    in_code_block = False
                else:
                    code_lines.append(line)
                continue

            if indented_code_lines:
                if line.startswith("    "):
                    indented_code_lines.append(line[4:])
                    continue
                if not line.strip():
                    self._emit_block(output, self._flush_code_block(indented_code_lines))
                    indented_code_lines = []
                else:
                    self._emit_block(output, self._flush_code_block(indented_code_lines))
                    indented_code_lines = []

            inline_para = INLINE_PARA_RE.match(line.strip())
            if inline_para:
                self._flush_paragraph(current_paragraph, output)
                current_paragraph = []
                spec = self._style_spec_from_html_attributes(inline_para.group(1) or "")
                self._push_style(spec)
                content = inline_para.group(2)
                if content:
                    current_paragraph.append(content)
                    self._flush_paragraph(current_paragraph, output)
                    current_paragraph = []
                self._pop_style()
                continue

            open_para = PARA_OPEN_RE.match(line)
            if open_para:
                spec = self._style_spec_from_html_attributes(open_para.group(1) or "")
                self._push_style(spec)
                continue

            close_para = PARA_CLOSE_RE.match(line)
            if close_para:
                self._flush_paragraph(current_paragraph, output)
                current_paragraph = []
                self._paragraph_style_spec = None
                self._pop_style()
                continue

            stripped = line.strip()
            attr_match = MMD_ATTR_LINE_RE.match(stripped)
            if attr_match:
                spec = self._parse_style_spec_from_tokens(attr_match.group(1))
                if spec:
                    if current_paragraph:
                        self._paragraph_style_spec = self._merge_specs(self._paragraph_style_spec, spec)
                    elif self._last_stylable_block is not None:
                        self._apply_style_to_last_block(output, spec)
                    else:
                        self._pending_block_style_spec = self._merge_specs(self._pending_block_style_spec, spec)
                continue

            if line.strip().startswith("```"):
                self._flush_paragraph(current_paragraph, output)
                current_paragraph = []
                in_code_block = True
                code_lines = []
                continue

            if line.startswith("    "):
                self._flush_paragraph(current_paragraph, output)
                current_paragraph = []
                indented_code_lines = [line[4:]]
                continue

            heading_match = HEADING_PATTERN.match(line)
            if heading_match:
                self._flush_paragraph(current_paragraph, output)
                current_paragraph = []
                level = len(heading_match.group(1))
                heading_text = heading_match.group(2).strip()
                heading_text, inline_spec = self._extract_trailing_attr(heading_text)
                combined_spec = self._merge_specs(self._pending_block_style_spec, inline_spec)
                style = self._combine_styles(self._current_style(), combined_spec)
                render = lambda s: self._render_heading_lines(level, heading_text, s)
                self._emit_block(output, render(style), stylable=True, render_fn=render, style=style)
                self._pending_block_style_spec = None
                continue

            if HORIZONTAL_RULE_PATTERN.match(line):
                self._flush_paragraph(current_paragraph, output)
                current_paragraph = []
                self._emit_block(output, [self._render_horizontal_rule(self._current_style())])
                continue

            if BLOCKQUOTE_PATTERN.match(line):
                self._flush_paragraph(current_paragraph, output)
                current_paragraph = []
                self._handle_blockquote(line, output)
                continue

            if UNORDERED_LIST_PATTERN.match(line) or ORDERED_LIST_PATTERN.match(line):
                self._flush_paragraph(current_paragraph, output)
                current_paragraph = []
                self._handle_list_line(line, output)
                continue

            if not line.strip():
                self._flush_paragraph(current_paragraph, output)
                output.append("")
                current_paragraph = []
                continue

            current_paragraph.append(line)

        self._flush_paragraph(current_paragraph, output)
        if in_code_block:
            self._emit_block(output, self._flush_code_block(code_lines))
        if indented_code_lines:
            self._emit_block(output, self._flush_code_block(indented_code_lines))

        if self.links:
            if output and output[-1] != "":
                output.append("")
            for index, url in self.links:
                entry = f"[{index}] {url}"
                output.extend(self._wrap_text(entry, initial_indent="", subsequent_indent="", style=BlockStyle()))
            self._last_stylable_block = None

        return output

    def _flush_paragraph(self, paragraph_lines: List[str], output: List[str]) -> None:
        if not paragraph_lines:
            return
        text = " ".join(line.strip() for line in paragraph_lines)
        processed = self._process_inline(text)
        combined_spec = self._merge_specs(self._pending_block_style_spec, self._paragraph_style_spec)
        style = self._combine_styles(self._current_style(), combined_spec)

        def render(target_style: BlockStyle) -> List[str]:
            return self._wrap_text(processed, style=target_style)

        lines = render(style)
        self._emit_block(output, lines, stylable=True, render_fn=render, style=style)
        paragraph_lines.clear()
        self._paragraph_style_spec = None
        self._pending_block_style_spec = None

    def _flush_code_block(self, code_lines: List[str]) -> List[str]:
        if not code_lines:
            return []
        width = max(2, len(str(len(code_lines))))
        formatted: List[str] = []
        for idx, line in enumerate(code_lines, start=1):
            formatted.append(f" {idx:0{width}d} | {line}")
        formatted.append("")
        return formatted

    def _handle_blockquote(self, line: str, output: List[str]) -> None:
        # Normalize a single blockquote line before wrapping.
        depth = 0
        content = line
        while content.lstrip().startswith(">"):
            depth += 1
            content = content.lstrip()[1:]
        content = content.lstrip()
        processed = self._process_inline(content)
        indent_unit = " | "
        indent = indent_unit * max(1, depth)
        wrapped = self._wrap_text(
            processed,
            initial_indent=indent,
            subsequent_indent=indent,
            style=self._current_style(),
        )
        self._emit_block(output, wrapped)

    def _apply_pattern(
        self,
        text: str,
        pattern: re.Pattern[str],
        handler: Callable[[re.Match[str], str], str],
    ) -> str:
        result: List[str] = []
        last = 0
        for match in pattern.finditer(text):
            result.append(text[last:match.start()])
            replacement = handler(match, text)
            result.append(replacement)
            last = match.end()
        result.append(text[last:])
        return "".join(result)

    def _replace_spaced_emphasis(
        self,
        source: str,
        match: re.Match[str],
        *,
        transform: str,
    ) -> str:
        stylized = self._stylize_letters(match.group(1), transform=transform)
        if not stylized:
            return stylized
        return self._apply_emphasis_spacing(source, match.start(), match.end(), stylized)

    def _apply_emphasis_spacing(self, source: str, start: int, end: int, stylized: str) -> str:
        if not stylized:
            return stylized
        prefix = ""
        suffix = ""
        if start > 0:
            before_char = source[start - 1]
            if before_char.isalnum():
                prefix = "  "
        if end < len(source):
            after_char = source[end]
            if after_char.isalnum():
                suffix = "  "
        return f"{prefix}{stylized}{suffix}"

    def _handle_list_line(self, line: str, output: List[str]) -> None:
        ordered = ORDERED_LIST_PATTERN.match(line)
        unordered = UNORDERED_LIST_PATTERN.match(line)
        if ordered:
            indent, marker, spacing, rest = ordered.groups()
        elif unordered:
            indent, marker, spacing, rest = unordered.groups()
        else:  # fall back to raw line
            self._emit_block(output, [line])
            return
        prefix = f"{indent}{marker}{spacing}"
        processed = self._process_inline(rest)
        wrapped = self._wrap_text(
            processed,
            initial_indent=prefix,
            subsequent_indent=" " * len(prefix),
            style=self._current_style(),
        )
        self._emit_block(output, wrapped)

    def _emit_block(
        self,
        output: List[str],
        lines: List[str],
        *,
        stylable: bool = False,
        render_fn: Optional[Callable[[BlockStyle], List[str]]] = None,
        style: Optional[BlockStyle] = None,
    ) -> None:
        if not lines:
            return
        start = len(output)
        output.extend(lines)
        if stylable and render_fn is not None and style is not None:
            self._last_stylable_block = BlockRecord(start, len(lines), render_fn, style)
        else:
            self._last_stylable_block = None

    def _apply_style_to_last_block(self, output: List[str], spec: StyleSpec) -> None:
        if self._last_stylable_block is None:
            return
        new_style = self._combine_styles(self._last_stylable_block.style, spec)
        new_lines = self._last_stylable_block.render(new_style)
        start = self._last_stylable_block.start
        end = start + self._last_stylable_block.length
        output[start:end] = new_lines
        self._last_stylable_block.length = len(new_lines)
        self._last_stylable_block.style = new_style

    def _current_style(self) -> BlockStyle:
        return self._style_stack[-1]

    def _push_style(self, spec: Optional[StyleSpec]) -> None:
        base = self._current_style()
        self._style_stack.append(self._combine_styles(base, spec))

    def _pop_style(self) -> None:
        if len(self._style_stack) > 1:
            self._style_stack.pop()

    def _combine_styles(self, base: BlockStyle, spec: Optional[StyleSpec]) -> BlockStyle:
        if spec is None:
            return BlockStyle(align=base.align, margin_left=base.margin_left, margin_right=base.margin_right)
        return BlockStyle(
            align=spec.align or base.align,
            margin_left=spec.margin_left if spec.margin_left is not None else base.margin_left,
            margin_right=spec.margin_right if spec.margin_right is not None else base.margin_right,
        )

    def _merge_specs(self, first: Optional[StyleSpec], second: Optional[StyleSpec]) -> Optional[StyleSpec]:
        if first is None and second is None:
            return None
        if first is None:
            return second
        if second is None:
            return first
        return StyleSpec(
            align=second.align or first.align,
            margin_left=second.margin_left if second.margin_left is not None else first.margin_left,
            margin_right=second.margin_right if second.margin_right is not None else first.margin_right,
        )

    def _style_spec_from_html_attributes(self, attributes: str) -> Optional[StyleSpec]:
        if not attributes:
            return None
        attr_pattern = re.compile(r"([\w:-]+)\s*=\s*(\".*?\"|'.*?'|\S+)")
        attr_map: Dict[str, str] = {}
        for name, value in attr_pattern.findall(attributes):
            attr_map[name.lower()] = value.strip().strip("\"'")

        spec: Optional[StyleSpec] = None
        align_value = attr_map.get("align")
        if align_value:
            normalized = self._normalize_align(align_value)
            if normalized:
                spec = self._merge_specs(spec, StyleSpec(align=normalized))

        style_value = attr_map.get("style")
        if style_value:
            css_spec = self._style_spec_from_css(style_value)
            spec = self._merge_specs(spec, css_spec)

        return spec

    def _style_spec_from_css(self, css: str) -> Optional[StyleSpec]:
        spec = StyleSpec()
        changed = False
        for declaration in css.split(";"):
            if ":" not in declaration:
                continue
            name, value = declaration.split(":", 1)
            name = name.strip().lower()
            value = value.strip()
            if not value:
                continue
            if name == "text-align":
                normalized = self._normalize_align(value)
                if normalized:
                    spec.align = normalized
                    changed = True
            elif name == "margin":
                left, right, auto_center = self._parse_css_margin_shorthand(value)
                if left is not None:
                    spec.margin_left = left
                    changed = True
                if right is not None:
                    spec.margin_right = right
                    changed = True
                if auto_center:
                    spec.align = "center"
                    changed = True
            elif name == "margin-left":
                parsed = self._parse_space_value(value)
                if parsed is not None:
                    spec.margin_left = parsed
                    changed = True
                elif value.lower() == "auto":
                    spec.align = spec.align or "center"
                    changed = True
            elif name == "margin-right":
                parsed = self._parse_space_value(value)
                if parsed is not None:
                    spec.margin_right = parsed
                    changed = True
                elif value.lower() == "auto":
                    spec.align = spec.align or "center"
                    changed = True
        return spec if changed else None

    def _parse_style_spec_from_tokens(self, token_str: str) -> Optional[StyleSpec]:
        tokens = re.split(r"\s+", token_str.strip())
        spec = StyleSpec()
        changed = False
        for token in tokens:
            token = token.strip()
            if not token:
                continue
            if token.startswith("."):
                align = self._class_to_align(token[1:])
                if align:
                    spec.align = align
                    changed = True
                continue
            if "=" in token:
                key, value = token.split("=", 1)
                key = key.strip().lower().lstrip(".")
                value = value.strip().strip("\"'")
                if key in {"align", "text-align"}:
                    normalized = self._normalize_align(value)
                    if normalized:
                        spec.align = normalized
                        changed = True
                elif key in {"margin", "margin-left", "margin-right"}:
                    if key == "margin":
                        left, right, auto_center = self._parse_css_margin_shorthand(value)
                        if left is not None:
                            spec.margin_left = left
                            changed = True
                        if right is not None:
                            spec.margin_right = right
                            changed = True
                        if auto_center:
                            spec.align = "center"
                            changed = True
                    elif key == "margin-left":
                        parsed = self._parse_space_value(value)
                        if parsed is not None:
                            spec.margin_left = parsed
                            changed = True
                        elif value.lower() == "auto":
                            spec.align = spec.align or "center"
                            changed = True
                    elif key == "margin-right":
                        parsed = self._parse_space_value(value)
                        if parsed is not None:
                            spec.margin_right = parsed
                            changed = True
                        elif value.lower() == "auto":
                            spec.align = spec.align or "center"
                            changed = True
                continue
            align = self._normalize_align(token)
            if align:
                spec.align = align
                changed = True
        return spec if changed else None

    def _parse_css_margin_shorthand(self, value: str) -> Tuple[Optional[int], Optional[int], bool]:
        parts = [part for part in re.split(r"\s+", value.strip()) if part]
        if not parts:
            return None, None, False

        values: List[Optional[int]] = []
        autos: List[bool] = []
        for part in parts:
            if part.lower() == "auto":
                values.append(None)
                autos.append(True)
            else:
                parsed = self._parse_space_value(part)
                values.append(parsed)
                autos.append(False)

        left_auto = False
        right_auto = False
        if len(values) == 1:
            left = right = values[0]
            left_auto = right_auto = autos[0]
        elif len(values) == 2:
            left = right = values[1]
            left_auto = right_auto = autos[1]
        elif len(values) == 3:
            left = right = values[1]
            left_auto = right_auto = autos[1]
        else:
            right = values[1]
            left = values[3]
            right_auto = autos[1]
            left_auto = autos[3]
        auto_center = left_auto and right_auto
        return left, right, auto_center

    def _parse_space_value(self, value: str) -> Optional[int]:
        match = re.match(r"(-?\d+(?:\.\d+)?)", value.strip())
        if not match:
            return None
        number = float(match.group(1))
        return max(0, int(round(number)))

    def _normalize_align(self, value: str) -> Optional[str]:
        normalized = value.strip().lower()
        mapping = {
            "centre": "center",
            "center": "center",
            "left": "left",
            "right": "right",
        }
        return mapping.get(normalized)

    def _class_to_align(self, class_name: str) -> Optional[str]:
        name = class_name.strip().lower().lstrip(".")
        if name in {"center", "text-center", "align-center"}:
            return "center"
        if name in {"left", "text-left", "align-left"}:
            return "left"
        if name in {"right", "text-right", "align-right"}:
            return "right"
        return None

    def _extract_trailing_attr(self, text: str) -> Tuple[str, Optional[StyleSpec]]:
        match = MMD_ATTR_TAIL_RE.match(text)
        if not match:
            return text, None
        clean_text = match.group(1).rstrip()
        spec = self._parse_style_spec_from_tokens(match.group(2))
        return clean_text, spec

    def _render_heading_lines(self, level: int, text: str, style: BlockStyle) -> List[str]:
        if level <= 3:
            figlet_lines = self._figlet_render(level, text)
            if figlet_lines:
                max_figlet_width = max((len(line.rstrip()) for line in figlet_lines), default=0)
                if max_figlet_width <= self._effective_width(style):
                    styled = self._apply_style_to_lines(figlet_lines, style)
                    return styled + [""]
        return self._render_h4_plus(text, style)

    def _render_horizontal_rule(self, style: BlockStyle) -> str:
        margin_left = min(max(style.margin_left, 0), self.width - 1)
        available_width = max(1, self._effective_width(style))
        return " " * margin_left + "-" * available_width

    def _apply_style_to_lines(self, lines: List[str], style: BlockStyle) -> List[str]:
        if not lines:
            return []
        margin_left = min(max(style.margin_left, 0), self.width - 1)
        margin_right = max(style.margin_right, 0)
        available_width = max(1, self.width - margin_left - margin_right)
        result: List[str] = []
        for line in lines:
            if not line:
                result.append("")
                continue
            trimmed = line.rstrip()
            line_len = len(trimmed)
            extra_space = max(0, available_width - line_len)
            if style.align == "center":
                extra_left = extra_space // 2
            elif style.align == "right":
                extra_left = extra_space
            else:
                extra_left = 0
            max_indent = max(0, self.width - line_len)
            indent = min(margin_left + extra_left, max_indent)
            result.append(" " * indent + trimmed)
        return result

    def _process_inline(self, text: str) -> str:
        code_segments: List[str] = []

        def stash_code(match: re.Match[str]) -> str:
            code_segments.append(match.group(0))
            return f"\u0000CODE{len(code_segments) - 1}\u0000"

        text = re.sub(r"`[^`]*`", stash_code, text)

        text = self._apply_pattern(
            text,
            re.compile(r"~~(.*?)~~"),
            lambda m, src: self._stylize_delimited(m.group(1), "-", transform="preserve"),
        )
        text = self._apply_pattern(
            text,
            re.compile(r"\*\*(.*?)\*\*"),
            lambda m, src: self._replace_spaced_emphasis(src, m, transform="upper"),
        )
        text = self._apply_pattern(
            text,
            re.compile(r"(?<!\*)\*(?!\*)(.*?)(?<!\*)\*(?!\*)"),
            lambda m, src: self._replace_spaced_emphasis(src, m, transform="preserve"),
        )

        emphasis_segments: List[str] = []

        def apply_with_placeholder(
            current: str,
            pattern: re.Pattern[str],
            handler: Callable[[re.Match[str]], str],
        ) -> str:
            def replacer(match: re.Match[str]) -> str:
                replacement = handler(match)
                placeholder = f"\u0000EMP{len(emphasis_segments)}\u0000"
                emphasis_segments.append(replacement)
                return placeholder

            return pattern.sub(replacer, current)

        text = apply_with_placeholder(
            text,
            re.compile(r"__(.*?)__"),
            lambda m: self._apply_emphasis_spacing(
                m.string,
                m.start(),
                m.end(),
                self._stylize_delimited(m.group(1), "_", transform="upper", word_repeat=3),
            ),
        )
        text = apply_with_placeholder(
            text,
            re.compile(r"(?<!_)_(?!_)(.*?)(?<!_)_(?!_)"),
            lambda m: self._apply_emphasis_spacing(
                m.string,
                m.start(),
                m.end(),
                self._stylize_delimited(m.group(1), "_", transform="preserve", word_repeat=3),
            ),
        )

        text = re.sub(r"(?<!\!)\[([^\]]+)\]\(([^)]+)\)", self._handle_link, text)
        text = re.sub(r"!\[([^\]]*)\]\(([^)]+)\)", self._handle_image, text)

        for index, replacement in enumerate(emphasis_segments):
            placeholder = f"\u0000EMP{index}\u0000"
            text = text.replace(placeholder, replacement)

        for index, code in enumerate(code_segments):
            placeholder = f"\u0000CODE{index}\u0000"
            text = text.replace(placeholder, code)

        return text

    def _stylize_letters(self, content: str, transform: str = "preserve") -> str:
        if not content:
            return ""
        result: List[str] = []
        previous_alnum = False
        pending_delimiter: str = ""

        def apply_transform(char: str) -> str:
            if transform == "upper":
                return char.upper()
            if transform == "lower":
                return char.lower()
            return char

        for char in content:
            processed = apply_transform(char)
            if processed.isspace():
                if result and result[-1].isalnum():
                    pending_delimiter = "   "
                previous_alnum = False
                continue
            if processed.isalnum():
                if previous_alnum:
                    result.append(" ")
                elif pending_delimiter:
                    result.append(pending_delimiter)
                    pending_delimiter = ""
                elif result:
                    result.append("   ")
                result.append(processed)
                previous_alnum = True
            else:
                if result and result[-1] == " ":
                    result.pop()
                if pending_delimiter:
                    result.append(pending_delimiter.strip())
                    pending_delimiter = ""
                result.append(processed)
                previous_alnum = False
        stylized = "".join(result)
        return stylized.strip()

    def _stylize_delimited(
        self,
        content: str,
        delimiter: str,
        transform: str = "preserve",
        word_repeat: int = 2,
    ) -> str:
        def apply_transform(char: str) -> str:
            if transform == "upper":
                return char.upper()
            if transform == "lower":
                return char.lower()
            return char

        output: List[str] = []
        open_sequence = False
        pending_gap = False

        for char in content:
            if char.isspace():
                if open_sequence:
                    pending_gap = True
                continue

            processed = apply_transform(char)
            if not open_sequence:
                output.append(delimiter)
                open_sequence = True
            else:
                repeat = word_repeat if pending_gap else 1
                output.append(delimiter * repeat)
            output.append(processed)
            pending_gap = False

        if not open_sequence:
            return delimiter * 2

        output.append(delimiter)
        return "".join(output)

    def _handle_link(self, match: re.Match[str]) -> str:
        text, target = match.groups()
        url, _title = self._split_link_target(target)
        index = self._register_link(url)
        return f"[{text}]({index})"

    def _handle_image(self, match: re.Match[str]) -> str:
        alt_text, target = match.groups()
        url, _title = self._split_link_target(target)
        display_text = alt_text or "Image"
        index = self._register_link(url)
        return f"[Image: {display_text}]({index})"

    def _split_link_target(self, value: str) -> Tuple[str, Optional[str]]:
        value = value.strip()
        if not value:
            return "", None
        if " " not in value:
            return value.strip(), None
        url, remainder = value.split(" ", 1)
        remainder = remainder.strip()
        if remainder.startswith('"') and remainder.endswith('"'):
            return url.strip(), remainder.strip('"')
        return url.strip(), remainder

    def _register_link(self, url: str) -> int:
        if url in self.link_indices:
            return self.link_indices[url]
        index = len(self.links) + 1
        self.links.append((index, url))
        self.link_indices[url] = index
        return index

    def _figlet_render(self, level: int, text: str) -> Optional[List[str]]:
        if Figlet is None:
            return None
        font_name = getattr(self.frontmatter, f"h{level}_font", "standard")
        figlet = self.figlets.get(font_name)
        if figlet is None:
            try:
                figlet = Figlet(font=font_name)
            except (FontNotFound, TypeError):
                return None
            self.figlets[font_name] = figlet
        rendered = figlet.renderText(text).rstrip("\n")
        lines = rendered.splitlines()
        trimmed_lines = [line.rstrip("\n") for line in lines]
        if not trimmed_lines or max(len(line.rstrip()) for line in trimmed_lines) > self.width:
            return None
        return [line.rstrip() for line in trimmed_lines]

    def _render_h4_plus(self, text: str, style: BlockStyle) -> List[str]:
        uppercase = text.upper()
        wrapped = self._wrap_text(uppercase, style=style)
        output: List[str] = []
        for line in wrapped:
            line = line.rstrip()
            if not line.strip():
                output.append("")
                continue
            leading = len(line) - len(line.lstrip(" "))
            underline = " " * leading + "-" * len(line.lstrip(" "))
            output.append(line)
            output.append(underline)
        output.append("")
        return output

    def _wrap_text(
        self,
        text: str,
        initial_indent: str = "",
        subsequent_indent: Optional[str] = None,
        style: Optional[BlockStyle] = None,
    ) -> List[str]:
        style = style or BlockStyle()
        margin_left = min(max(style.margin_left, 0), self.width - 1)
        available_width = max(1, self._effective_width(style))

        subsequent = initial_indent if subsequent_indent is None else subsequent_indent
        wrapper = textwrap.TextWrapper(
            width=available_width,
            expand_tabs=False,
            replace_whitespace=False,
            drop_whitespace=False,
            break_on_hyphens=False,
            break_long_words=True,
            initial_indent=initial_indent,
            subsequent_indent=subsequent,
        )
        wrapped = wrapper.wrap(text)
        if not wrapped:
            wrapped = [initial_indent.rstrip()]
        result: List[str] = []
        for line in wrapped:
            line = line.rstrip()
            line_len = len(line)
            extra_space = max(0, available_width - line_len)
            if style.align == "center":
                extra_left = extra_space // 2
            elif style.align == "right":
                extra_left = extra_space
            else:
                extra_left = 0
            max_indent = max(0, self.width - line_len)
            indent = min(margin_left + extra_left, max_indent)
            result.append(" " * indent + line)
        return result

    def _effective_width(self, style: BlockStyle) -> int:
        margin_left = min(max(style.margin_left, 0), self.width - 1)
        remaining = self.width - margin_left
        margin_right = min(max(style.margin_right, 0), max(0, remaining - 1))
        return max(1, self.width - margin_left - margin_right)


def parse_frontmatter(lines: List[str]) -> Tuple[FrontMatter, List[str]]:
    if not lines or not FRONTMATTER_PATTERN.match(lines[0]):
        return FrontMatter(), lines
    frontmatter: Dict[str, str] = {}
    idx = 1
    while idx < len(lines):
        if FRONTMATTER_PATTERN.match(lines[idx]):
            break
        if ":" in lines[idx]:
            key, value = lines[idx].split(":", 1)
            frontmatter[key.strip()] = value.strip()
        idx += 1
    if idx >= len(lines):
        return FrontMatter(), lines
    remaining = lines[idx + 1 :] if idx + 1 < len(lines) else []
    fm = FrontMatter(
        h1_font=frontmatter.get("h1_font", "standard"),
        h2_font=frontmatter.get("h2_font", "standard"),
        h3_font=frontmatter.get("h3_font", "standard"),
    )
    return fm, remaining


def read_lines(path: Path) -> List[str]:
    with path.open("r", encoding="utf-8") as handle:
        return handle.readlines()


def write_output(path: Optional[Path], lines: List[str]) -> None:
    content = "\r\n".join(lines)
    if path is None:
        sys.stdout.write(content + "\r\n")
        return
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(content + "\r\n", encoding="utf-8")


def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(description="Convert Markdown files to 80-column DOS-compatible text.")
    parser.add_argument("input_path", type=Path, help="Path to the Markdown input file.")
    parser.add_argument("-o", "--output", type=Path, help="Optional path to write the resulting text file.")
    parser.add_argument("--width", type=int, default=80, help="Maximum column width (default: 80).")
    return parser


def main(argv: Optional[List[str]] = None) -> int:
    parser = build_parser()
    args = parser.parse_args(argv)
    lines = read_lines(args.input_path)
    frontmatter, content = parse_frontmatter(lines)
    converter = MarkdownToTxtConverter(width=args.width, frontmatter=frontmatter)
    converted_lines = converter.convert(content)
    write_output(args.output, converted_lines)
    return 0


if __name__ == "__main__":
    raise SystemExit(main())