.pragma library

// Copyright (C) 2026 Danilo M. <danix@danix.xyz>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.

// Pure helpers for the notes module, tested by test_notes.js under node.
// Everything here is a value in and a value out: no file, no process.

function titleOf(note) {
    return (note && typeof note.title === "string") ? note.title : "";
}

function notesOf(db) {
    return (db && Array.isArray(db.notes)) ? db.notes : [];
}

// The db object, or null when the text cannot be read as one. An empty or
// missing file is an empty store, not an error. Anything else that does not
// parse, or parses to something without a notes array, is null: a writer must
// refuse on null rather than replace a file it did not understand, which is
// what a conflicted db.json (merge markers from an autostash pop) is.
function valid(text) {
    const t = String(text === undefined || text === null ? "" : text);
    if (t.trim() === "") return { notes: [] };
    let v = null;
    try { v = JSON.parse(t); } catch (e) { v = null; }
    if (!v || typeof v !== "object" || Array.isArray(v) || !Array.isArray(v.notes))
        return null;
    return v;
}

// db.json for display: the object, or an empty store when nothing readable is
// there, so a truncated or hand-edited file shows "no notes" rather than
// failing to load the page.
function parse(text) {
    return valid(text) || { notes: [] };
}

// Pretty, 2-space, trailing newline. notes.sh reads db.json through jq, which
// does not care about the layout.
function stringify(db) {
    return JSON.stringify(db, null, 2) + "\n";
}

// Notes newest first. `file` is epoch seconds held as a string; a missing or
// non-numeric one is unusable and goes last, in input order. A copy: the
// caller's array is never reordered.
function sorted(notes) {
    const usable = [], unusable = [];
    for (const n of (notes || [])) {
        const t = Number(n && n.file);
        (isFinite(t) && t > 0 ? usable : unusable).push(n);
    }
    usable.sort((a, b) => Number(b.file) - Number(a.file));
    return usable.concat(unusable);
}

// "dd/mm/yyyy hh:mm" in local time from an epoch-seconds string, "" for
// anything unusable, so a row with no date shows blank rather than NaN.
function formatDate(file) {
    const t = Number(file);
    if (!isFinite(t) || t <= 0) return "";
    const d = new Date(t * 1000);
    const p = n => String(n).padStart(2, "0");
    return p(d.getDate()) + "/" + p(d.getMonth() + 1) + "/" + d.getFullYear()
        + " " + p(d.getHours()) + ":" + p(d.getMinutes());
}

// The next id: the highest numeric id plus one, as a string. notes.sh stores
// ids as strings and looks a note up with `select(.id == $i)`, comparing
// string to string, so a number here would stop the CLI finding a note the
// page wrote.
function nextId(notes) {
    let max = 0;
    for (const n of (notes || [])) {
        const i = parseInt(n && n.id, 10);
        if (isFinite(i) && i > max) max = i;
    }
    return String(max + 1);
}

// Title substring, case-insensitive; an empty query keeps all.
function filter(notes, query) {
    const q = String(query === undefined || query === null ? "" : query).trim().toLowerCase();
    if (q === "") return notes || [];
    return (notes || []).filter(n => titleOf(n).toLowerCase().indexOf(q) >= 0);
}

// A new db with a note appended. title and file are stored as strings; the id
// comes from nextId. Every other key carries through and the input is not
// mutated.
function addNote(db, title, file) {
    const notes = notesOf(db);
    const entry = { id: nextId(notes), title: String(title === undefined ? "" : title),
                    file: String(file === undefined ? "" : file) };
    return Object.assign({}, db, { notes: notes.concat([entry]) });
}

// A new db with one note's title replaced. An id that is not there leaves the
// notes untouched.
function updateNote(db, id, title) {
    const notes = notesOf(db).map(n =>
        n.id === id ? Object.assign({}, n, { title: String(title === undefined ? "" : title) }) : n);
    return Object.assign({}, db, { notes: notes });
}

// A new db without the note this id names.
function removeNote(db, id) {
    return Object.assign({}, db, { notes: notesOf(db).filter(n => n.id !== id) });
}

// A new db with git.lastpull set, as a string, the way notes.sh's gitsync
// writes it. It is what notes.sh -l reads to decide whether to pull again.
function setLastpull(db, now) {
    return Object.assign({}, db, { git: Object.assign({}, db.git, { lastpull: String(now) }) });
}