use std::collections::hash_map::DefaultHasher;
use std::fmt::Write as _;
use std::hash::{Hash, Hasher};
use std::process::Command;
use std::{fs, path::Path};

fn main() {
    // Set GIT_HASH env var for compile-time inclusion via option_env!()
    let hash = Command::new("git")
        .args(["rev-parse", "--short", "HEAD"])
        .output()
        .ok()
        .filter(|o| o.status.success())
        .and_then(|o| String::from_utf8(o.stdout).ok())
        .map(|s| s.trim().to_string())
        .unwrap_or_default();

    println!("cargo::rustc-env=GIT_HASH={hash}");
    // Only re-run when HEAD changes
    println!("cargo::rerun-if-changed=.git/HEAD");

    // Compile the TypeScript frontend to static/dist/ (best-effort, see fn).
    build_frontend();

    // The two generated stylesheets. Spacing comes from makeover-geometry and
    // composition from makeover-webview, the same way colour already comes
    // from makeover through theming.rs. Written into static/ rather than a
    // bundle directory because the server serves its stylesheets; both are
    // gitignored, since the crates are the source and a checked-in copy would
    // drift from the pin.
    //
    // No explicit touch selector: density hangs off (hover: none),
    // (pointer: coarse) alone, because the server has no mode class to key it
    // on. GO passes `.ui-mode-mobile` because it has one.
    makeover_build::geometry_css("static/geometry.css", None);
    makeover_build::layout_css("static/layout.css", &makeover_build::Emit::default());

    // The embeds get their own copy of the spacing layer, because they are
    // served into third-party iframes and cannot link a stylesheet. Pointer
    // density only, and no `@media` block: an embed body is `height: 100vh`
    // inside an iframe the host page sized, so growing the gaps on a coarse
    // pointer clips rather than reflows, and the host author never sees it
    // happen. Revisit if embeds ever gain a resize protocol.
    fs::write(
        "static/embed-geometry.css",
        makeover_geometry::geometry_css_vars(makeover_geometry::Density::Pointer),
    )
    .expect("write static/embed-geometry.css");

    println!("cargo::rerun-if-changed=build.rs");

    // The landing shots' own dimensions, so the description can reserve their
    // space. Generated rather than written down; see `shot_dimensions`.
    let shots = shot_dimensions();
    let mut table = String::from(
        "/// Intrinsic size of each landing screenshot, by URL path.\n\
         /// Generated by build.rs from the files themselves.\n\
         pub static SHOT_DIMENSIONS: &[(&str, u32, u32)] = &[\n",
    );
    for (path, w, h) in &shots {
        let _ = writeln!(table, "    ({path:?}, {w}, {h}),");
    }
    table.push_str("];\n");
    fs::write(
        Path::new(&std::env::var("OUT_DIR").expect("OUT_DIR")).join("shot_dimensions.rs"),
        table,
    )
    .expect("write shot_dimensions.rs");

    // The same check goingson and balanced_breakfast run, out of
    // makeover-build rather than a third copy of it. The named-list form:
    // static/ holds the generated stylesheets and a bundler's output beside
    // the hand-written ones, so there is no directory to scan. No tuning
    // widths -- every threshold here is a shell boundary.
    makeover_build::check_breakpoints_files(&HAND_WRITTEN_CSS, &[]);
    makeover_build::check_vocabulary_files(
        &HAND_WRITTEN_CSS,
        &makeover_build::Emit::default(),
        REVIEWED_OVERLAPS,
    );
    makeover_build::check_vocabulary_use(
        &markup_files(),
        &makeover_build::Emit::default(),
        DEAD_VOCABULARY_HIGH_WATER,
    );

    // --- Static asset fingerprinting ---
    // Hash the content of key static files to produce a version suffix.
    // When any watched file changes, URLs in templates get a new ?v= param,
    // busting browser caches automatically.
    let static_files = [
        "static/style.css",
        // The two per-page sheets. Linked from page templates rather than
        // from the head, which is why they were outside the fingerprint and
        // served stale to any browser holding a cached copy.
        "static/wizard.css",
        "static/media-player.css",
        // Same case again, found 2026-08-15: linked from a <noscript> in the
        // carousel partial rather than from the head, so it was outside the
        // fingerprint and a change to it served stale to any browser holding a
        // cached copy. The visitors it exists for are the ones least likely to
        // hard-refresh.
        "static/no-js.css",
        "static/htmx.min.js",
        // The morph extension, vendored from quasi. quasi-webview's Shell emits
        // hx-ext="morph" and points at this path by default; htmx falls back to
        // innerHTML silently when the extension is absent, so a 404 here is a
        // destructive swap rather than a missing feature.
        "static/idiomorph-ext.min.js",
        "static/upload.js",
        "static/passkey.js",
        "static/insertions.js",
    ];

    let mut hasher = DefaultHasher::new();
    for path in &static_files {
        println!("cargo::rerun-if-changed={path}");
        if let Ok(content) = fs::read(path) {
            content.hash(&mut hasher);
        }
    }
    // Fold the emitted frontend bundles into the version so `?v=` busts when
    // the TypeScript changes. Read-only: the inputs under frontend/src are the
    // watched trigger (in build_frontend); watching the outputs would loop.
    hash_dir_js(Path::new("static/dist"), &mut hasher);
    // Same treatment for the two generated stylesheets: read-only, so a bump
    // of makeover-geometry or makeover-webview busts `?v=` without the build
    // script watching a file it writes itself.
    for path in [
        "static/geometry.css",
        "static/layout.css",
        "static/embed-geometry.css",
    ] {
        if let Ok(content) = fs::read(path) {
            content.hash(&mut hasher);
        }
    }
    let static_hash = format!("{:016x}", hasher.finish());
    let version = &static_hash[..8];

    // The head's own assets are no longer a generated partial: crate::shell
    // builds them into quasi-webview's Shell, which is what a described screen
    // renders through, so both halves of the converted site emit one head. All
    // that crosses the build boundary now is the version.
    println!("cargo::rustc-env=STATIC_VERSION={version}");

    // Per-page island loader macro. Heavy/page-specific islands (media player,
    // uploader, ...) load on the pages that use them via
    // `{% import "_island.html" as island %}{% call island::island("name") %}`,
    // cache-busted by the same content hash as the head assets.
    let island_partial = r#"{% macro island(name) -%}
<script type="module" src="/static/dist-__VER__/islands/{{ name }}.js"></script>
{%- endmacro %}
"#
    .replace("__VER__", version);
    write_if_changed(Path::new("templates/_island.html"), &island_partial);

    // Per-page stylesheet loader, same idea as the island macro. wizard.css and
    // media-player.css are linked by the pages that need them rather than by
    // the shell, so this is how they get the content hash.
    let sheet_partial = r#"{% macro sheet(name) -%}
<link rel="stylesheet" href="/static/{{ name }}?v=__VER__">
{%- endmacro %}
"#
    .replace("__VER__", version);
    write_if_changed(Path::new("templates/_sheet.html"), &sheet_partial);
}

/// Intrinsic dimensions of the landing screenshots, read from the files.
///
/// A picture that cannot say how big it is cannot have its space reserved, so
/// the browser gives it none until the bytes land and then takes its full
/// height at once. That was measured at a 478px jump per frame on the landing
/// page and 0.087 CLS for the document (2026-08-14).
///
/// Read here rather than written down, because these files are regenerated by
/// `scripts/capture-landing-carousel.mjs` and a hand-maintained number would be
/// wrong the first time anyone re-shot them -- silently, since a wrong reserve
/// looks like a right one until the image lands.
///
/// WebP only, which is what the capture script emits. A file this cannot parse
/// is skipped rather than guessed at: `None` reserves nothing, which is the
/// behaviour before this existed, while a wrong number reserves the wrong room.
fn shot_dimensions() -> Vec<(String, u32, u32)> {
    let dir = Path::new("static/images/shots");
    println!("cargo::rerun-if-changed=static/images/shots");
    let mut out = Vec::new();
    let Ok(entries) = fs::read_dir(dir) else {
        return out;
    };
    for entry in entries.flatten() {
        let path = entry.path();
        if path.extension().and_then(|e| e.to_str()) != Some("webp") {
            continue;
        }
        let Ok(bytes) = fs::read(&path) else { continue };
        let Some((w, h)) = webp_dimensions(&bytes) else {
            continue;
        };
        if let Some(name) = path.file_name().and_then(|n| n.to_str()) {
            out.push((format!("/static/images/shots/{name}"), w, h));
        }
    }
    out.sort();
    out
}

/// Canvas size from a WebP header, for the three chunk layouts that exist.
///
/// Header offsets only -- nothing is decoded. `None` for anything unrecognised,
/// which the caller treats as "this picture does not know its size".
fn webp_dimensions(b: &[u8]) -> Option<(u32, u32)> {
    if b.len() < 30 || &b[0..4] != b"RIFF" || &b[8..12] != b"WEBP" {
        return None;
    }
    match &b[12..16] {
        // Lossy. Three-byte frame tag, then the 3-byte sync code, then two
        // 14-bit dimensions.
        b"VP8 " => {
            let w = u16::from_le_bytes([b[26], b[27]]) & 0x3fff;
            let h = u16::from_le_bytes([b[28], b[29]]) & 0x3fff;
            Some((u32::from(w), u32::from(h)))
        }
        // Lossless. One signature byte, then 14 bits of width-1 and 14 of
        // height-1 packed into the next four.
        b"VP8L" => {
            let bits = u32::from_le_bytes([b[21], b[22], b[23], b[24]]);
            Some(((bits & 0x3fff) + 1, ((bits >> 14) & 0x3fff) + 1))
        }
        // Extended. Canvas size as two 24-bit little-endian minus-ones.
        b"VP8X" => {
            let w = u32::from_le_bytes([b[24], b[25], b[26], 0]) + 1;
            let h = u32::from_le_bytes([b[27], b[28], b[29], 0]) + 1;
            Some((w, h))
        }
        _ => None,
    }
}

/// How many generated classes may go unused before the build fails.
///
/// One-sided: over this fails, under it warns and asks for the seal to be
/// lowered. A build that broke on deleting dead CSS would teach the wrong
/// lesson, so the number only ever ratchets down.
///
/// Measured against [`markup_files`]. The stylesheets are deliberately out -- a
/// class in `style.css` is that class being styled, not that class being
/// emitted, and counting them would mark the whole vocabulary used by
/// definition. `static/dist` is out for a subtler reason: it is `tsc` output of
/// `frontend/src`, so including both counts one class-writing line twice, and
/// the source is the half a human edits.
///
/// The server's markup is spread wider than either desktop app's -- 200-odd
/// Askama templates, the hand-written scripts in `static/`, the TypeScript they
/// are being replaced by, and the Rust that writes markup directly -- which is
/// the whole reason this seal took a pass of its own rather than landing beside
/// the check that reads the stylesheets.
///
/// # 18 to 20, 2026-08-14: `picture-img` and `picture-caption`
///
/// The one direction this number is allowed to move is down, so a rise wants an
/// argument rather than a nudge. These two are not dead vocabulary: they are
/// emitted by `quasi-webview` at request time, from a description, and this
/// scanner reads *this repo's* files. Markup written by a dependency is
/// invisible to it by construction.
///
/// That category already existed and was already counted here. `figure-value`,
/// `figure-caption` and `figure-change` sit in the same set for the same
/// reason, and the nine `cell-*` classes beside them are the described table.
/// The carousel port (`c0b63ea9`) is the first widget to add to it.
///
/// So the seal still measures what it was built to measure -- CSS generated for
/// markup nobody writes -- and the honest ratchet is downward as the
/// description layer takes over more of the site, at which point these classes
/// stop being reachable from templates *and* stay used. If this number ever
/// needs raising for a class MNW's own markup should have been writing, that is
/// the defect this exists to catch and the answer is the markup, not the seal.
///
/// # 20 to 23, 2026-08-15: `track-entry`, `track-slot`, `track-tick`
///
/// The same category again, and the third entry in it. The track vocabulary
/// arrived in quasi 0.6.0 (`describe a time axis`) and 0.8.0 (`label a track by
/// its unit`); this server had been pinned to quasi 0.5 and could not resolve at
/// all, so the classes had never been weighed here. Forward-fixing the pin is
/// what surfaced them.
///
/// Emitted by `quasi-webview` from a description, like the eighteen above them,
/// and invisible to a scanner reading this repo's files for the same reason. No
/// template should be writing them.
const DEAD_VOCABULARY_HIGH_WATER: usize = 23;

/// Every file that can carry a class name.
///
/// Sorted within each group, so two machines read the same set in the same
/// order. It makes no difference to the count and every difference to reading a
/// diff of the warning.
fn markup_files() -> Vec<std::path::PathBuf> {
    let mut files = Vec::new();
    for (dir, extension) in [
        ("templates", "html"),
        ("static", "js"),
        ("frontend/src", "ts"),
        ("src", "rs"),
    ] {
        let mut found = Vec::new();
        collect(Path::new(dir), extension, &mut found);
        found.sort();
        files.extend(found);
    }
    files
}

/// Every file under `dir` with this extension, recursively.
fn collect(dir: &Path, extension: &str, out: &mut Vec<std::path::PathBuf>) {
    let Ok(entries) = fs::read_dir(dir) else {
        return;
    };
    for entry in entries.flatten() {
        let path = entry.path();
        if path.is_dir() {
            // The bundler's output, which is `frontend/src` compiled. Reading
            // both would count the same line twice.
            if path.file_name().is_some_and(|name| name == "dist") {
                continue;
            }
            collect(&path, extension, out);
        } else if path.extension().is_some_and(|ext| ext == extension) {
            out.push(path);
        }
    }
}

/// The hand-written stylesheets. Ordered, so the guard reports the same way
/// twice. `geometry.css` and `layout.css` are excluded: they are generated.
///
/// `no-js.css` joined the list on 2026-08-15. It had been missed since it was
/// written: it is hand-authored CSS served to real visitors, so the breakpoint
/// and vocabulary guards apply to it exactly as they do to the other three, and
/// a sheet outside the list is a sheet that can diverge without the build
/// noticing. It is also what `tests/frontend_payload.rs` weighs, and a seal
/// that skipped a sheet would let bytes move between sheets and read as a
/// deletion.
const HAND_WRITTEN_CSS: [&str; 4] = [
    "static/style.css",
    "static/wizard.css",
    "static/media-player.css",
    "static/no-js.css",
];

/// Write `contents` to `path` only if it differs, to avoid needless rebuilds.
fn write_if_changed(path: &Path, contents: &str) {
    let needs_write = fs::read_to_string(path).map_or(true, |existing| existing != contents);
    if needs_write {
        fs::write(path, contents)
            .unwrap_or_else(|e| panic!("failed to write {}: {e}", path.display()));
    }
}

/// Compile the TypeScript frontend (`frontend/`) to browser ESM in
/// `static/dist/` via `npm run build` (which runs `tsc`).
///
/// Self-contained: on a fresh checkout or a new build host (no `node_modules`)
/// it runs `npm ci` first, so there is no manual install gate before a deploy.
/// Best-effort and non-fatal otherwise, an absent Node or a compile error only
/// emits a `cargo::warning` and leaves the Rust build to succeed against
/// whatever `static/dist/` already holds. Set `MNW_SKIP_FRONTEND_BUILD=1` to
/// opt out entirely (e.g. a Node-less CI that doesn't need the JS).
fn build_frontend() {
    // Re-run the whole build script when the TS sources or its config change.
    println!("cargo::rerun-if-changed=frontend/src");
    println!("cargo::rerun-if-changed=frontend/package.json");
    println!("cargo::rerun-if-changed=frontend/package-lock.json");
    println!("cargo::rerun-if-changed=frontend/tsconfig.json");

    if std::env::var_os("MNW_SKIP_FRONTEND_BUILD").is_some() {
        println!("cargo::warning=frontend build skipped (MNW_SKIP_FRONTEND_BUILD set)");
        return;
    }
    // Fresh checkout / new build host: install deps once (clean, from the
    // lockfile) so the frontend build needs no manual `npm install` gate before
    // a deploy. Skipped once node_modules exists; needs network on this run.
    if !Path::new("frontend/node_modules").is_dir() {
        match Command::new("npm")
            .args(["ci"])
            .current_dir("frontend")
            .status()
        {
            Ok(s) if s.success() => {}
            Ok(s) => {
                println!(
                    "cargo::warning=npm ci failed (exit {:?}); skipping frontend build (serving existing static/dist)",
                    s.code()
                );
                return;
            }
            Err(e) => {
                println!(
                    "cargo::warning=could not run npm ({e}); is Node installed? skipping frontend build (serving existing static/dist)"
                );
                return;
            }
        }
    }
    match Command::new("npm")
        .args(["run", "build"])
        .current_dir("frontend")
        .status()
    {
        Ok(s) if s.success() => {}
        Ok(s) => println!(
            "cargo::warning=frontend build failed (npm run build exit {:?}); serving stale static/dist",
            s.code()
        ),
        Err(e) => println!(
            "cargo::warning=could not run npm for the frontend build ({e}); is Node installed? \
             skipping (serving existing static/dist)"
        ),
    }
}

/// Recursively hash every `.js` file under `dir` into `hasher`, in a
/// deterministic order. Missing directory is a no-op (first build before the
/// frontend has been compiled).
fn hash_dir_js(dir: &Path, hasher: &mut DefaultHasher) {
    let Ok(entries) = fs::read_dir(dir) else {
        return;
    };
    let mut paths: Vec<_> = entries.flatten().map(|e| e.path()).collect();
    paths.sort();
    for path in paths {
        if path.is_dir() {
            hash_dir_js(&path, hasher);
        } else if path.extension().and_then(|e| e.to_str()) == Some("js")
            && let Ok(content) = fs::read(&path)
        {
            content.hash(hasher);
        }
    }
}

/// Class-and-property overlaps with the generated stylesheet that have been
/// read and kept.
///
/// Three kinds, and only the first is what the check is really for.
///
/// **Different selector arms.** `.badge { color }` and `.card { color }`:
/// makeover colours the tone and disabled arms, the server colours the base and
/// its own variants (`.badge.ai-tier-*`, `.badge--founder-*`). Neither touches
/// the other's arm. The check collapses arms, because separating them would
/// need a selector matcher and a checker that guesses wrong about specificity
/// fails correct builds, so the judgement is recorded here.
///
/// **A deliberate pairing.** `.progress-fill { background }` is a different
/// element rather than a different arm: the media scrubber's fill, which lives
/// inside `.progress-bar` and never matches the generated
/// `.progress > .progress-fill`. It already carried a `respec-ok` comment
/// saying so.
///
/// `.tab { box-shadow }` and `.chosen { box-shadow }` are the third kind and the
/// awkward one -- one rule, two entries, because the check reads every class in
/// a selector and `.tab.chosen` is both. This file zeroes the base `button`
/// shadow on a tab, and unlayered CSS outranks `@layer makeover` whatever the
/// specificity, so the generated `.tab.chosen` bevel cannot apply on its own.
/// The chosen arm takes `box-shadow: revert-layer`, which hands the property
/// back to the layer rather than naming a value. Two arms, one of which is a
/// deferral rather than an override, so both entries stay.
///
/// **A divergence taken on purpose.** `.table-row { display }` is `grid` here
/// against makeover's `table-row`, which is the same build-time grid story
/// goingson is on.
///
/// `.tab { background }` was here and is gone. `.tab.is-selected` set
/// `--surface-raised` and `--bevel-raised`, byte for byte what the generated
/// `.tab.chosen` sets: a second name for makeover's own state, which is the
/// defect makeover-webview 0.27.0 exists to prevent. The tabs carry `chosen`
/// now, in four templates and in `frontend/src/core/tabs.ts`, and the rule is
/// deleted. The caret's two entries went the same way, one release later:
/// makeover-webview 0.31.0 emits the leading space and the reserved box itself.
///
/// An entry that stops colliding fails the build, so this list cannot outlive
/// what it describes.
const REVIEWED_OVERLAPS: &[(&str, &str)] = &[
    ("badge", "color"),
    // A carousel showing one frame at a time, 2026-08-14. This was
    // `("picture-img", "display")` until makeover-layout 0.23.0 described the
    // showing itself; the frames are wrapped in `.showing-frame` now and the old
    // entry stopped colliding, which this list is built to notice.
    //
    // The two arms are the same rule at two moments, and that is the whole of
    // why the overlap is kept. Makeover collapses the stack on `[data-ready]`,
    // which is the only honest default for a renderer that cannot know whether
    // a page has script: ship every child, take them away once something binds
    // them. This site collapses it from first paint instead, because rendering
    // three frames and collapsing them was a measured 141px -> 58px jump that
    // every visitor with JS paid, and `no-js.css` from a <noscript> opens the
    // stack for the few without. That trade is this landing page's to make and
    // a generated stylesheet has no way to reach <noscript>.
    ("showing-frame", "display"),
    ("current", "display"),
    ("card", "color"),
    ("chosen", "box-shadow"),
    ("progress-fill", "background"),
    ("tab", "box-shadow"),
    ("tab", "color"),
    ("tab", "cursor"),
    ("table-row", "display"),
];