"""Paint pass — write IR nodes into the CharGrid as characters.

Depth-first traversal: each node writes its content at its assigned
rect position. Containers recurse into children after drawing their
own structure (borders, etc.).
"""

from __future__ import annotations

import textwrap

from uframe.chars import (
    BOX_CHARS, DIVIDER_CHARS, GAUGE_FILLED, GAUGE_EMPTY,
    STATUS_CHARS, STATUS_COLORS, sparkline_chars,
)
from uframe.grid import CharGrid, CellStyle
from uframe.ir import (
    IRNode, Page, Box, Row, Col, Spacer, Pad,
    Heading, Text, Label, Divider, Link, ListNode, ListItem,
    Gauge, Sparkline, Status, Table,
    Form, Field, Password, Radio, Checkbox, FormButton,
    HeadingLevel, DividerStyle, ListStyle, Align, BorderWeight,
)


def _align_text(text: str, width: int, align: Align) -> str:
    """Align text within a field of the given width."""
    if len(text) >= width:
        return text[:width]
    if align == Align.CENTER:
        return text.center(width)
    elif align == Align.RIGHT:
        return text.rjust(width)
    return text.ljust(width)


def _style_from_node(node: IRNode) -> CellStyle:
    """Create a CellStyle from a node's style attributes."""
    return CellStyle(
        fg=node.style.fg,
        bg=node.style.bg,
        bold=node.style.bold,
        italic=node.style.italic,
        underline=node.style.underline,
    )


def paint(node: IRNode, grid: CharGrid) -> None:
    """Recursively paint an IR node and its children into the grid."""
    x, y, w = node.rect.x, node.rect.y, node.rect.w

    # Ensure grid is tall enough
    grid.grow_height(y + node.rect.h)

    if isinstance(node, Page):
        for child in node.children:
            paint(child, grid)

    elif isinstance(node, Box):
        # Draw the border
        title_style = CellStyle(bold=True, fg=node.style.fg)
        grid.draw_border(x, y, w, node.rect.h,
                         weight=node.weight,
                         title=node.title,
                         title_style=title_style)
        # Paint children inside the border
        for child in node.children:
            paint(child, grid)

    elif isinstance(node, Row):
        for child in node.children:
            paint(child, grid)

    elif isinstance(node, Col):
        for child in node.children:
            paint(child, grid)

    elif isinstance(node, Spacer):
        pass  # Just empty space

    elif isinstance(node, Pad):
        for child in node.children:
            paint(child, grid)

    elif isinstance(node, Heading):
        style = CellStyle(bold=True)
        if node.level == HeadingLevel.H1:
            style.fg = "0f0"  # green
        elif node.level == HeadingLevel.H2:
            style.fg = "0cf"  # cyan
        elif node.level == HeadingLevel.H3:
            style.fg = "88f"  # light blue

        # Underline-style heading
        grid.put_text(x, y, node.text[:w], style=style)

    elif isinstance(node, Text):
        style = _style_from_node(node)

        if node.spans and any(
            s.bold or s.italic or s.underline or s.fg or s.bg
            for s in node.spans
        ):
            # Render with inline spans
            col = x
            row = y
            for span in node.spans:
                span_style = CellStyle(
                    fg=span.fg or style.fg,
                    bg=span.bg or style.bg,
                    bold=span.bold or style.bold,
                    italic=span.italic or style.italic,
                    underline=span.underline or style.underline,
                )
                for ch in span.text:
                    if col >= x + w:
                        col = x
                        row += 1
                    if grid.in_bounds(col, row):
                        grid.put(col, row, ch, style=span_style)
                    col += 1
        else:
            # Simple text with word wrapping
            wrapped = textwrap.wrap(node.content, width=w) if node.content else [""]
            for i, line in enumerate(wrapped):
                if y + i < grid.height:
                    text = _align_text(line, w, node.style.align)
                    grid.put_text(x, y + i, text, style=style)

    elif isinstance(node, Label):
        style = _style_from_node(node)
        key_style = CellStyle(bold=True, fg=style.fg, bg=style.bg)
        # Key: value layout with padding
        key_text = f"{node.key}:"
        pad = max(1, 16 - len(key_text))
        grid.put_text(x, y, key_text, style=key_style)
        grid.put_text(x + len(key_text) + pad, y, node.value, style=style)

    elif isinstance(node, Divider):
        ds = node.divider_style
        char = DIVIDER_CHARS.get(ds.name.lower(), "─")
        style = CellStyle(fg="555")
        for col in range(x, x + w):
            grid.put(col, y, char, style=style)

    elif isinstance(node, Link):
        style = CellStyle(fg="0cf", underline=True)
        # In ASCII mode, display as [text]. In Micron, the emitter wraps with link syntax.
        # Write just the display text — the link metadata goes on cells for Micron emission.
        grid.put_text(x, y, node.display[:w], style=style, link=node.dest)

    elif isinstance(node, ListNode):
        for child in node.children:
            paint(child, grid)

    elif isinstance(node, ListItem):
        style = _style_from_node(node)
        # Parent determines bullet style — use a simple bullet for now
        bullet = "• "
        grid.put_text(x - 2, y, bullet, style=CellStyle(fg="888"))
        # Wrap content
        wrapped = textwrap.wrap(node.content, width=w) if node.content else [""]
        for i, line in enumerate(wrapped):
            if y + i < grid.height:
                grid.put_text(x, y + i, line, style=style)

    elif isinstance(node, Gauge):
        style = _style_from_node(node)
        # Label
        label_text = f"{node.label}  "
        grid.put_text(x, y, label_text, style=CellStyle(bold=True))

        bar_x = x + len(label_text)
        bar_w = min(node.bar_width, w - len(label_text) - 6)

        if bar_w > 0:
            pct = min(node.value / node.max_val, 1.0) if node.max_val > 0 else 0
            filled = int(bar_w * pct)

            # Determine color based on thresholds
            fg = "0f0"  # green
            if node.crit is not None and node.value >= node.crit:
                fg = "f00"  # red
            elif node.warn is not None and node.value >= node.warn:
                fg = "ff0"  # yellow

            for i in range(bar_w):
                if i < filled:
                    grid.put(bar_x + i, y, GAUGE_FILLED, style=CellStyle(fg=fg))
                else:
                    grid.put(bar_x + i, y, GAUGE_EMPTY, style=CellStyle(fg="555"))

            # Percentage
            pct_text = f"  {int(pct * 100)}%"
            grid.put_text(bar_x + bar_w, y, pct_text, style=CellStyle(fg=fg))

    elif isinstance(node, Sparkline):
        style = _style_from_node(node)
        label_text = f"{node.label}  "
        grid.put_text(x, y, label_text, style=CellStyle(bold=True))

        spark_x = x + len(label_text)
        chars = sparkline_chars(node.values, node.spark_width)
        spark_style = CellStyle(fg="0cf")
        for i, ch in enumerate(chars):
            grid.put(spark_x + i, y, ch, style=spark_style)

    elif isinstance(node, Status):
        char = STATUS_CHARS.get(node.state, "◌")
        color = STATUS_COLORS.get(node.state, "888")
        grid.put(x, y, char, style=CellStyle(fg=color))
        grid.put_text(x + 2, y, node.label)

    elif isinstance(node, Table):
        _paint_table(node, grid, x, y, w)

    elif isinstance(node, Form):
        for child in node.children:
            paint(child, grid)

    elif isinstance(node, Field):
        label_style = CellStyle(fg="888")
        field_style = CellStyle(fg="0cf")
        label_text = f"{node.field_name}: "
        grid.put_text(x, y, label_text, style=label_style)
        # Draw [ placeholder_______ ]
        fx = x + len(label_text)
        fw = min(node.field_width, w - len(label_text) - 2)
        grid.put(fx, y, "[", style=field_style)
        placeholder = node.placeholder or node.field_name
        inner = f" {placeholder}".ljust(fw - 1)[:fw - 1]
        grid.put_text(fx + 1, y, inner, style=CellStyle(fg="555"))
        grid.put(fx + fw, y, "]", style=field_style)

    elif isinstance(node, Password):
        label_style = CellStyle(fg="888")
        field_style = CellStyle(fg="0cf")
        label_text = f"{node.field_name}: "
        grid.put_text(x, y, label_text, style=label_style)
        fx = x + len(label_text)
        fw = min(node.field_width, w - len(label_text) - 2)
        grid.put(fx, y, "[", style=field_style)
        inner = " " + "•" * (fw - 2)
        grid.put_text(fx + 1, y, inner[:fw - 1], style=CellStyle(fg="555"))
        grid.put(fx + fw, y, "]", style=field_style)

    elif isinstance(node, Radio):
        label_style = CellStyle(fg="888")
        label_text = f"{node.group}: "
        grid.put_text(x, y, label_text, style=label_style)
        rx = x + len(label_text)
        for i, opt in enumerate(node.options):
            dot = "(•)" if i == 0 else "( )"
            opt_style = CellStyle(fg="0cf" if i == 0 else "888")
            grid.put_text(rx, y, dot, style=opt_style)
            rx += 4
            grid.put_text(rx, y, opt, style=CellStyle())
            rx += len(opt) + 2

    elif isinstance(node, Checkbox):
        check_style = CellStyle(fg="0cf")
        box_char = "[✓]" if node.checked else "[ ]"
        grid.put_text(x, y, box_char, style=check_style)
        grid.put_text(x + 4, y, node.checkbox_label)

    elif isinstance(node, FormButton):
        btn_style = CellStyle(bold=True, fg="0f0")
        btn_text = f"[ {node.button_label} ]"
        grid.put_text(x, y, btn_text, style=btn_style, link=node.dest)

    else:
        # Generic: paint children
        for child in node.children:
            paint(child, grid)


def _paint_table(node: Table, grid: CharGrid, x: int, y: int, w: int) -> None:
    """Paint a box-drawn table with header and data rows."""
    if not node.columns:
        return

    ch = BOX_CHARS[BorderWeight.LIGHT]
    border_style = CellStyle()
    header_style = CellStyle(bold=True)

    num_cols = len(node.columns)

    # Calculate column widths
    # If columns have explicit widths, use them. Otherwise distribute evenly.
    col_widths: list[int] = []
    total_explicit = 0
    auto_count = 0
    for _, cw in node.columns:
        if cw > 0:
            col_widths.append(cw)
            total_explicit += cw
        else:
            col_widths.append(0)
            auto_count += 1

    # Available inner width = total - borders (num_cols + 1 border chars)
    inner_w = w - (num_cols + 1)
    if auto_count > 0:
        auto_each = max(1, (inner_w - total_explicit) // auto_count)
        for i in range(len(col_widths)):
            if col_widths[i] == 0:
                col_widths[i] = auto_each

    # Compute column x positions (after each left border)
    col_x: list[int] = []
    cx = x + 1  # after left border
    for cw in col_widths:
        col_x.append(cx)
        cx += cw + 1  # +1 for separator

    table_w = cx - x  # total table width including right border

    row_y = y

    # ── Top border ──
    grid.put(x, row_y, ch["tl"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
    grid.put(x + table_w - 1, row_y, ch["tr"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
    for ci, cw in enumerate(col_widths):
        for j in range(cw):
            grid.put(col_x[ci] + j, row_y, ch["h"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
        # Column separator on top border
        if ci < num_cols - 1:
            grid.put(col_x[ci] + cw, row_y, ch["t_down"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
    row_y += 1

    # ── Header row ──
    grid.put(x, row_y, ch["v"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
    for ci, (col_name, _) in enumerate(node.columns):
        text = col_name[:col_widths[ci]].ljust(col_widths[ci])
        grid.put_text(col_x[ci], row_y, text, style=header_style)
        sep_x = col_x[ci] + col_widths[ci]
        grid.put(sep_x, row_y, ch["v"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
    row_y += 1

    # ── Header separator ──
    grid.put(x, row_y, ch["t_right"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
    grid.put(x + table_w - 1, row_y, ch["t_left"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
    for ci, cw in enumerate(col_widths):
        for j in range(cw):
            grid.put(col_x[ci] + j, row_y, ch["h"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
        if ci < num_cols - 1:
            grid.put(col_x[ci] + cw, row_y, ch["cross"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
    row_y += 1

    # ── Data rows ──
    cell_style = CellStyle()
    for row_data in node.rows:
        grid.put(x, row_y, ch["v"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
        for ci in range(num_cols):
            cell_text = row_data[ci] if ci < len(row_data) else ""
            text = cell_text[:col_widths[ci]].ljust(col_widths[ci])

            # Check for @color{hex}{text} modifiers in cell content
            if "@" in cell_text:
                spans = []
                import re as _re
                pattern = _re.compile(r"@color\{([0-9a-fA-F]{3})\}\{([^}]*)\}")
                pos = 0
                styled_parts: list[tuple[str, CellStyle]] = []
                for m in pattern.finditer(cell_text):
                    if m.start() > pos:
                        styled_parts.append((cell_text[pos:m.start()], cell_style))
                    styled_parts.append((m.group(2), CellStyle(fg=m.group(1))))
                    pos = m.end()
                if pos < len(cell_text):
                    styled_parts.append((cell_text[pos:], cell_style))

                col_pos = col_x[ci]
                for part_text, part_style in styled_parts:
                    for pch in part_text:
                        if col_pos < col_x[ci] + col_widths[ci]:
                            grid.put(col_pos, row_y, pch, style=part_style)
                            col_pos += 1
                # Pad remaining
                while col_pos < col_x[ci] + col_widths[ci]:
                    grid.put(col_pos, row_y, " ")
                    col_pos += 1
            else:
                grid.put_text(col_x[ci], row_y, text, style=cell_style)

            sep_x = col_x[ci] + col_widths[ci]
            grid.put(sep_x, row_y, ch["v"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
        row_y += 1

    # ── Bottom border ──
    grid.put(x, row_y, ch["bl"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
    grid.put(x + table_w - 1, row_y, ch["br"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
    for ci, cw in enumerate(col_widths):
        for j in range(cw):
            grid.put(col_x[ci] + j, row_y, ch["h"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)
        if ci < num_cols - 1:
            grid.put(col_x[ci] + cw, row_y, ch["t_up"], border_style, is_border=True, border_weight=BorderWeight.LIGHT)