"""Route-A production engine, shard 3/4.
Copied verbatim from routeA_pilot/ncc_engine.py + inkbox.py, plus a
multi-peak extractor needed for the column-wise monotone DP (recipe #5).
"""
import numpy as np
from PIL import Image


def _fast_len(n):
    best = 2 * n
    p5 = 1
    while p5 < best:
        p3 = p5
        while p3 < best:
            p2 = p3
            while p2 < n:
                p2 *= 2
            if p2 < best:
                best = p2
            p3 *= 3
        p5 *= 5
    return best


class ImgCtx:
    """FFT numerator + integral-image denominator, image transform cached."""

    def __init__(self, img):
        img = np.asarray(img, dtype=np.float64)
        self.H, self.W = img.shape
        self.Hf, self.Wf = _fast_len(self.H), _fast_len(self.W)
        pad = np.zeros((self.Hf, self.Wf))
        pad[:self.H, :self.W] = img
        # complex64 spectrum: halves memory and FFT time; the denominator stays
        # float64 (it needs the cancellation headroom of s2 - s1^2/n).
        self.F = np.fft.rfft2(pad.astype(np.float32))
        ii = np.zeros((self.H + 1, self.W + 1))
        ii2 = np.zeros((self.H + 1, self.W + 1))
        np.cumsum(np.cumsum(img, 0), 1, out=ii[1:, 1:])
        np.cumsum(np.cumsum(img * img, 0), 1, out=ii2[1:, 1:])
        self.ii, self.ii2 = ii, ii2
        del pad

    def ncc(self, tpl):
        """valid-mode NCC map.  Bit-identical to the pilot's ncc() (verified
        max|diff| = 0); the template transform is done in two stages so only
        the h non-zero rows are row-transformed, and the denominator is built
        in place -- 1.4x faster, same numbers."""
        h, w = tpl.shape
        if h > self.H or w > self.W:
            return None
        tz = tpl - tpl.mean()
        tnorm = float(np.sqrt((tz * tz).sum()))
        if tnorm < 1e-8:
            return None
        T1 = np.fft.rfft(tz.astype(np.float32), n=self.Wf, axis=1)
        Tp = np.zeros((self.Hf, T1.shape[1]), dtype=np.complex64)
        Tp[:h] = T1
        G = np.fft.fft(Tp, axis=0)
        np.conj(G, out=G)
        G *= self.F
        corr = np.fft.irfft2(G, s=(self.Hf, self.Wf))
        ny, nx = self.H - h + 1, self.W - w + 1
        num = corr[:ny, :nx]
        ii, ii2 = self.ii, self.ii2
        s1 = ii[h:h + ny, w:w + nx] - ii[0:ny, w:w + nx] - ii[h:h + ny, 0:nx] + ii[0:ny, 0:nx]
        var = ii2[h:h + ny, w:w + nx] - ii2[0:ny, w:w + nx] - ii2[h:h + ny, 0:nx] + ii2[0:ny, 0:nx]
        n = h * w
        s1 *= s1
        s1 /= n
        var -= s1
        np.clip(var, 0, None, out=var)
        # Degenerate-window guard.  The pilot's `denom > 1e-8` is not a real
        # floor: a window of blank paper has local variance ~0 (exactly 0 after
        # decimation), so the numerator's FFT round-off gets divided by almost
        # nothing and clips to NCC = 1.0 -- a phantom perfect match on empty
        # paper.  Require instead that the window carry actual contrast:
        # local sd > 0.5 grey level AND > 1% of the template's sd.
        ok = var > max(0.25 * n, 1e-4 * tnorm * tnorm)
        np.sqrt(var, out=var)
        var *= tnorm
        var = var.astype(np.float32)
        out = np.zeros_like(num)
        np.divide(num, var, out=out, where=ok)
        np.clip(out, -1.0, 1.0, out=out)
        return out


def load_gray(path):
    return np.asarray(Image.open(path).convert('L'), dtype=np.float64)


def resize_tpl(pil_gray, s):
    w, h = pil_gray.size
    nw, nh = max(4, int(round(w * s))), max(4, int(round(h * s)))
    return np.asarray(pil_gray.resize((nw, nh), Image.LANCZOS), dtype=np.float64)


def top_peaks(m, th, tw, k=6):
    """Top-k spatially separated peaks of a valid-mode NCC map.
    Block-max NMS on cells of half template size, then refine inside the cell."""
    H, W = m.shape
    by = max(4, th // 2)
    bx = max(4, tw // 2)
    ny = (H + by - 1) // by
    nx = (W + bx - 1) // bx
    pad = np.full((ny * by, nx * bx), -2.0, dtype=m.dtype)
    pad[:H, :W] = m
    blocks = pad.reshape(ny, by, nx, bx).max(axis=(1, 3))
    flat = blocks.ravel()
    cand = np.argsort(flat)[::-1][:60]
    used = np.zeros((ny, nx), bool)
    out = []
    for idx in cand:
        cy, cx = divmod(int(idx), nx)
        if used[max(0, cy - 1):cy + 2, max(0, cx - 1):cx + 2].any():
            continue
        sub = m[cy * by:min(H, (cy + 1) * by), cx * bx:min(W, (cx + 1) * bx)]
        if sub.size == 0:
            continue
        j = int(np.argmax(sub))
        yy, xx = divmod(j, sub.shape[1])
        out.append((float(sub[yy, xx]), int(cx * bx + xx), int(cy * by + yy)))
        used[cy, cx] = True
        if len(out) >= k:
            break
    return out


def ink_bbox_arr(g, frac=0.03):
    """verbatim from routeA_pilot/inkbox.py"""
    h, w = g.shape
    bg = np.percentile(g, 85)
    thr = bg - 0.45 * (bg - np.percentile(g, 2))
    m = g < thr
    cs = m.sum(0).astype(float)
    rs = m.sum(1).astype(float)
    if cs.max() < 1 or rs.max() < 1:
        return (0, 0, w, h), 0
    def span(p):
        t = max(1.0, frac * p.max())
        idx = np.where(p >= t)[0]
        return int(idx[0]), int(idx[-1]) + 1
    x0, x1 = span(cs)
    y0, y1 = span(rs)
    if x1 - x0 < 4: x0, x1 = 0, w
    if y1 - y0 < 4: y0, y1 = 0, h
    return (x0, y0, x1, y1), int(m[y0:y1, x0:x1].sum())


def iou(a, b):
    ax, ay, aw, ah = a[0], a[1], a[2] - a[0], a[3] - a[1]
    bx, by, bw, bh = b[0], b[1], b[2] - b[0], b[3] - b[1]
    ix = max(0.0, min(ax + aw, bx + bw) - max(ax, bx))
    iy = max(0.0, min(ay + ah, by + bh) - max(ay, by))
    it = ix * iy
    return it / (aw * ah + bw * bh - it + 1e-9)