# SPDX-License-Identifier: MIT
"""Tiny inline-SVG chart writer for Engineering Notes.

Emits markup that notes.css styles and notes.js makes interactive:
thin 2 px lines, 8 px markers with a surface ring, solid hairline grid,
one y-axis, selective end labels, per-column hit targets with tooltips,
and a table-view twin for every chart (see `table`).

`inject(page, name, markup)` replaces the block between
<!-- fig:name --> and <!-- /fig:name --> so figures are rebuilt from data
at author time and the published page stays static.
"""
from __future__ import annotations

import html
import math
import re
from pathlib import Path


def esc(s) -> str:
    return html.escape(str(s), quote=True)


def fmt_num(v: float) -> str:
    if v == 0:
        return "0"
    a = abs(v)
    if a >= 1e6 and a == int(a) and a % 1e6 == 0:
        return f"{v / 1e6:g}M"
    if a >= 1000:
        return f"{v:,.0f}"
    if a >= 1:
        return f"{v:g}"
    return f"{v:g}"


class Scale:
    def __init__(self, lo, hi, a, b, log=False):
        self.lo, self.hi, self.a, self.b, self.log = lo, hi, a, b, log

    def __call__(self, v):
        f = math.log10 if self.log else (lambda z: z)
        return self.a + (f(v) - f(self.lo)) / (f(self.hi) - f(self.lo)) * (self.b - self.a)


class Frame:
    """Plot area, axes and grid. Charts draw into `out`."""

    def __init__(self, width, height, label, margins=(58, 132, 26, 46)):
        self.w, self.h = width, height
        self.ml, self.mr, self.mt, self.mb = margins
        self.pw = width - self.ml - self.mr
        self.ph = height - self.mt - self.mb
        self.out = [f'<svg class="ch" viewBox="0 0 {width} {height}" role="img" aria-label="{esc(label)}">']

    def x_scale(self, lo, hi, log=False):
        self.x = Scale(lo, hi, self.ml, self.ml + self.pw, log)
        return self.x

    def y_scale(self, lo, hi, log=False):
        self.y = Scale(lo, hi, self.mt + self.ph, self.mt, log)
        return self.y

    def grid_y(self, ticks, fmt=fmt_num):
        o = self.out
        o.append('<g class="grid">')
        for t in ticks:
            o.append(f'<line x1="{self.ml}" x2="{self.ml + self.pw}" y1="{self.y(t):.1f}" y2="{self.y(t):.1f}"/>')
        o.append("</g>")
        for t in ticks:
            o.append(f'<text x="{self.ml - 8}" y="{self.y(t) + 4:.1f}" text-anchor="end">{esc(fmt(t))}</text>')

    def grid_x(self, ticks, fmt=fmt_num, lines=True):
        o = self.out
        if lines:
            o.append('<g class="grid">')
            for t in ticks:
                o.append(f'<line x1="{self.x(t):.1f}" x2="{self.x(t):.1f}" y1="{self.mt}" y2="{self.mt + self.ph}"/>')
            o.append("</g>")
        for t in ticks:
            o.append(f'<text x="{self.x(t):.1f}" y="{self.mt + self.ph + 18}" text-anchor="middle">{esc(fmt(t))}</text>')

    def x_labels(self, labels):
        for i, lab in labels:
            self.out.append(f'<text x="{self.x(i):.1f}" y="{self.mt + self.ph + 18}" text-anchor="middle">{esc(lab)}</text>')

    def baseline(self):
        y = self.mt + self.ph
        self.out.append(f'<line class="axis" x1="{self.ml}" x2="{self.ml + self.pw}" y1="{y}" y2="{y}"/>')

    def titles(self, x_title="", y_title=""):
        if x_title:
            self.out.append(f'<text class="muted" x="{self.ml + self.pw / 2}" y="{self.h - 6}" text-anchor="middle">{esc(x_title)}</text>')
        if y_title:
            self.out.append(f'<text class="muted" x="4" y="{self.mt - 12}">{esc(y_title)}</text>')

    def note(self, x, y, text, anchor="start", cls="muted"):
        self.out.append(f'<text class="{cls}" x="{x:.1f}" y="{y:.1f}" text-anchor="{anchor}">{esc(text)}</text>')

    def vline(self, xv, text="", cls="axis"):
        x = self.x(xv)
        self.out.append(f'<line class="{cls}" x1="{x:.1f}" x2="{x:.1f}" y1="{self.mt}" y2="{self.mt + self.ph}"/>')
        if text:
            self.note(x + 5, self.mt + 11, text)

    def hline(self, yv, text="", cls="axis"):
        y = self.y(yv)
        self.out.append(f'<line class="{cls}" x1="{self.ml}" x2="{self.ml + self.pw}" y1="{y:.1f}" y2="{y:.1f}"/>')
        if text:
            self.note(self.ml + 6, y - 6, text)

    def cursor(self):
        self.out.append(f'<line class="cursor" x1="0" x2="0" y1="{self.mt}" y2="{self.mt + self.ph}"/>')

    def svg(self):
        return "\n".join(self.out + ["</svg>"])


def draw_lines(fr: Frame, xs, series, end_labels=True, hover_marks=True):
    """Lines sharing x positions; end markers; nudged end labels."""
    ends = []
    for s in series:
        pts = [(fr.x(x), fr.y(v)) for x, v in zip(xs, s["values"]) if v is not None]
        d = "M" + " L".join(f"{a:.1f},{b:.1f}" for a, b in pts)
        fr.out.append(f'<path class="line s{s["slot"]}" d="{d}"/>')
        ex, ey = pts[-1]
        fr.out.append(f'<circle class="dot s{s["slot"]}" cx="{ex:.1f}" cy="{ey:.1f}" r="4"/>')
        if end_labels and s.get("label", True):
            ends.append([ey, s.get("end", s["name"]), ex, ey])
    ends.sort()
    for k in range(1, len(ends)):
        if ends[k][0] - ends[k - 1][0] < 14:
            ends[k][0] = ends[k - 1][0] + 14
    for ly, name, ex, ey in ends:
        if abs(ly - ey) > 2:
            fr.out.append(f'<path class="lead" d="M{ex + 5:.1f},{ey:.1f} L{ex + 10:.1f},{ly:.1f}"/>')
        fr.out.append(f'<text class="ink" x="{ex + 12:.1f}" y="{ly + 4:.1f}">{esc(name)}</text>')


def column_hits(fr: Frame, xs, series, title, fmt, hover_marks=True):
    """One full-height hit column per x (midpoints between neighbours)."""
    px = [fr.x(x) for x in xs]
    for i, x in enumerate(xs):
        if hover_marks:
            for s in series:
                v = s["values"][i]
                if v is not None:
                    fr.out.append(f'<circle class="dot hl s{s["slot"]}" data-col="{i}" cx="{px[i]:.1f}" cy="{fr.y(v):.1f}" r="4.5"/>')
        left = fr.ml if i == 0 else (px[i - 1] + px[i]) / 2
        right = fr.ml + fr.pw if i == len(xs) - 1 else (px[i] + px[i + 1]) / 2
        rows = ";".join(f'{s["slot"]}|{s["name"]}|{fmt(s["values"][i])}' for s in series if s["values"][i] is not None)
        fr.out.append(
            f'<rect class="hit" x="{left:.1f}" y="{fr.mt}" width="{max(right - left, 1):.1f}" height="{fr.ph}" '
            f'data-col="{i}" data-cx="{px[i]:.1f}" data-title="{esc(title(i, x))}" data-rows="{esc(rows)}"/>'
        )


def point_hit(fr: Frame, cx, cy, col, title, rows, r=12):
    fr.out.append(
        f'<circle class="hit" cx="{cx:.1f}" cy="{cy:.1f}" r="{r}" data-col="{col}" '
        f'data-title="{esc(title)}" data-rows="{esc(rows)}"/>'
    )


def columns(fr: Frame, cats, values, slot=1, fmt=fmt_num, title=lambda i, c: c, highlight=None, slots=None, metric="Value"):
    """Vertical columns from the baseline, <=24 px wide, 4 px rounded cap."""
    n = len(cats)
    band = fr.pw / n
    w = min(24, band * 0.6)
    y0 = fr.mt + fr.ph
    for i, (c, v) in enumerate(zip(cats, values)):
        cx = fr.ml + band * (i + 0.5)
        top = fr.y(v)
        h = y0 - top
        r = min(4, h)
        s = slots[i] if slots else (slot if highlight is None or i in highlight else 0)
        d = (f"M{cx - w / 2:.1f},{y0} L{cx - w / 2:.1f},{top + r:.1f} Q{cx - w / 2:.1f},{top:.1f} {cx - w / 2 + r:.1f},{top:.1f} "
             f"L{cx + w / 2 - r:.1f},{top:.1f} Q{cx + w / 2:.1f},{top:.1f} {cx + w / 2:.1f},{top + r:.1f} L{cx + w / 2:.1f},{y0} Z")
        fr.out.append(f'<path class="s{s}" d="{d}" stroke="none"/>')
        fr.out.append(f'<text class="ink" x="{cx:.1f}" y="{top - 7:.1f}" text-anchor="middle">{esc(fmt(v))}</text>')
        fr.out.append(f'<text x="{cx:.1f}" y="{y0 + 18}" text-anchor="middle">{esc(c)}</text>')
        fr.out.append(
            f'<rect class="hit" x="{cx - band / 2:.1f}" y="{fr.mt}" width="{band:.1f}" height="{fr.ph}" data-col="{i}" '
            f'data-title="{esc(title(i, c))}" data-rows="{esc(f"{s}|{metric}|{fmt(v)}")}"/>'
        )


def legend(series: list[dict]) -> str:
    items = "".join(f'<span class="k{s["slot"]}"><i></i>{esc(s["name"])}</span>' for s in series)
    return f'<div class="legend">{items}</div>'


def table(caption: str, head: list[str], rows: list[list], numeric_from: int = 1) -> str:
    def cls(j):
        return ' class="n"' if j >= numeric_from else ""

    th = "".join(f'<th scope="col"{cls(j)}>{esc(h)}</th>' for j, h in enumerate(head))
    body = []
    for r in rows:
        cells = [f'<th scope="row">{esc(r[0])}</th>'] + [f"<td{cls(j + 1)}>{esc(c)}</td>" for j, c in enumerate(r[1:])]
        body.append("<tr>" + "".join(cells) + "</tr>")
    return (
        f'<div class="table-scroll"><table class="data"><caption>{esc(caption)}</caption>'
        f"<thead><tr>{th}</tr></thead><tbody>{''.join(body)}</tbody></table></div>"
    )


def figure(*, code: str, plot: str, caption: str, legend_html: str = "", data_html: str = "", wide=False, fid="") -> str:
    """The standard figure frame: LCARS bar, plot, legend, caption, table view."""
    data = f"<details><summary>Table view</summary>{data_html}</details>" if data_html else ""
    idattr = f' id="{fid}"' if fid else ""
    return (
        f'<figure class="fig{" fig--wide" if wide else ""}"{idattr}>'
        f'<div class="media__bar"><span class="lamp"></span><span class="lamp"></span><span class="lamp"></span>'
        f"<span>{esc(code)}</span></div>"
        f'<div class="fig__plot">{plot}</div>{legend_html}'
        f"<figcaption>{caption}</figcaption>{data}</figure>"
    )


def inject(page: Path, name: str, markup: str) -> None:
    text = page.read_text(encoding="utf-8")
    pat = re.compile(rf"(<!-- fig:{re.escape(name)} -->)(.*?)(<!-- /fig:{re.escape(name)} -->)", re.S)
    if not pat.search(text):
        raise SystemExit(f"marker fig:{name} not found in {page}")
    text = pat.sub(lambda m: m.group(1) + "\n" + markup + "\n" + m.group(3), text)
    page.write_text(text, encoding="utf-8")