"""Correct Devanagari text rendering: HarfBuzz shaping + FreeType rasterization.

Pillow's bundled build has no Raqm, so ImageDraw.text() renders Devanagari
unshaped -- conjuncts break apart and pre-base matras (ि) land on the wrong
side. Everything here goes through HarfBuzz so the glyph stream is what a
real text engine would produce.
"""
from __future__ import annotations

import functools
from dataclasses import dataclass

import freetype
import numpy as np
import uharfbuzz as hb
from PIL import Image

# FreeType 26.6 fixed point -> pixels
F26_6 = 64.0


@dataclass
class ShapedGlyph:
    gid: int
    x_off: float
    y_off: float
    x_adv: float
    cluster: int


class Face:
    """A font face wired up for both HarfBuzz (shaping) and FreeType (raster)."""

    def __init__(self, path: str, px: int, face_index: int = 0):
        self.path = path
        self.px = px
        with open(path, "rb") as fh:
            data = fh.read()
        self.hb_face = hb.Face(data, face_index)
        self.hb_font = hb.Font(self.hb_face)
        # HarfBuzz works in font units scaled to px; match FreeType's 26.6 grid.
        self.hb_font.scale = (px * 64, px * 64)
        hb.ot_font_set_funcs(self.hb_font)

        self.ft = freetype.Face(path, index=face_index)
        self.ft.set_pixel_sizes(0, px)

    def shape(self, text: str, script: str = "Deva", language: str = "hi",
              features: dict | None = None) -> list[ShapedGlyph]:
        buf = hb.Buffer()
        buf.add_str(text)
        buf.direction = "ltr"
        buf.script = script
        buf.language = language
        # guess_segment_properties would also work, but being explicit means a
        # missing script tag can't silently disable Devanagari shaping rules.
        hb.shape(self.hb_font, buf, features)
        return [
            ShapedGlyph(i.codepoint, p.x_offset / F26_6, p.y_offset / F26_6,
                        p.x_advance / F26_6, i.cluster)
            for i, p in zip(buf.glyph_infos, buf.glyph_positions)
        ]

    def covers(self, text: str) -> bool:
        """True if every non-space codepoint has a real glyph in this face."""
        for ch in text:
            if ch.isspace():
                continue
            if self.ft.get_char_index(ch) == 0:
                return False
        return True


def render_line(face: Face, text: str, pad: int = 8) -> tuple[Image.Image, dict]:
    """Render one line to a tight grayscale coverage mask (255 = ink).

    Returns the mask plus metrics describing where the baseline ended up, so
    callers can compose without re-deriving it.
    """
    glyphs = face.shape(text)
    if not glyphs:
        return Image.new("L", (1, 1), 0), {"baseline": 0, "width": 0}

    # Pass 1: measure the real ink box. Devanagari routinely overshoots the
    # nominal ascender (ै, ॉ) and descender (ु, ृ), so trusting font metrics
    # alone clips diacritics -- which is precisely what we cannot afford.
    pen_x = 0.0
    x0 = y0 = 1e9
    x1 = y1 = -1e9
    placed = []
    for g in glyphs:
        face.ft.load_glyph(g.gid, freetype.FT_LOAD_RENDER | freetype.FT_LOAD_TARGET_NORMAL)
        bmp = face.ft.glyph.bitmap
        left = face.ft.glyph.bitmap_left
        top = face.ft.glyph.bitmap_top
        gx = pen_x + g.x_off + left
        gy = -(g.y_off) - top  # y grows downward in image space
        if bmp.width and bmp.rows:
            buf = np.array(bmp.buffer, dtype=np.uint8)
            # FreeType rows are padded to `pitch`; slice the real width back out.
            arr = buf.reshape(bmp.rows, bmp.pitch)[:, : bmp.width].copy()
            placed.append((arr, gx, gy))
            x0 = min(x0, gx); y0 = min(y0, gy)
            x1 = max(x1, gx + bmp.width); y1 = max(y1, gy + bmp.rows)
        pen_x += g.x_adv

    if not placed:
        return Image.new("L", (1, 1), 0), {"baseline": 0, "width": 0}

    w = int(np.ceil(x1 - x0)) + 2 * pad
    h = int(np.ceil(y1 - y0)) + 2 * pad
    canvas = np.zeros((h, w), dtype=np.uint16)

    for arr, gx, gy in placed:
        px = int(round(gx - x0)) + pad
        py = int(round(gy - y0)) + pad
        sub = canvas[py : py + arr.shape[0], px : px + arr.shape[1]]
        if sub.shape != arr.shape:  # defensive: rounding at the edge
            continue
        np.maximum(sub, arr, out=sub)

    mask = Image.fromarray(np.clip(canvas, 0, 255).astype(np.uint8), "L")
    return mask, {"baseline": int(round(-y0)) + pad, "width": w, "height": h,
                  "advance": pen_x, "n_glyphs": len(glyphs)}


@functools.lru_cache(maxsize=64)
def load_face(path: str, px: int, index: int = 0) -> Face:
    return Face(path, px, index)