--[[--
The dashboard's widgets. Each takes the board context, a tile size in pixels
and the widget's props, and returns content of exactly that size.

A widget lays itself out for the box it gets: one with several layouts tries
them from richest to most compact and keeps the first that fits (see
BoardUI.pick), so every widget works at every size on every screen. The
dimensions and spacing are in dp and mirror the design mocks one for one.
]]

local datetime = require("datetime")
local T = require("ffi/util").template
local _ = require("gettext")

local BoardColour = require("bookorbit_board_colour")
local BoardData = require("bookorbit_board_data")
local BoardStore = require("bookorbit_board_store")
local BoardMetrics = require("bookorbit_board_metrics")
local BoardUI = require("bookorbit_board_ui")

local INK = BoardMetrics.INK
local px, lh1, lh = BoardMetrics.px, BoardMetrics.lh1, BoardMetrics.lh
local text, runs, vstack, hstack, flex, space = BoardUI.text, BoardUI.runs, BoardUI.vstack, BoardUI.hstack, BoardUI.flex, BoardUI.space
local icon, bar, rect, pick = BoardUI.icon, BoardUI.bar, BoardUI.rect, BoardUI.pick

local W = {}
local BoardWidgets = { W = W }

local function clamp(v, lo, hi)
    if v < lo then return lo end
    if v > hi then return hi end
    return v
end

local function thin() return math.max(1, px(0.75)) end

local function firstAuthor(book)
    return book and type(book.authors) == "table" and book.authors[1] or nil
end

-- A font size that fills `room` px of height, as the mocks compute it.
local function fillSize(room, lo, hi)
    return clamp(math.floor(room / 1.36 / BoardMetrics.get().dp), lo, hi)
end

-- The label row every tile starts with: bold label left, an optional widget
-- right, at least 4dp between them. A label too long for a narrow tile steps
-- down a size or two before it is cut; a tile's layouts share it, so this
-- never changes which layout wins.
local function head(iw, label, right, o)
    o = o or {}
    local rw = right and right:getSize().w or 0
    local room = right and (iw - rw - px(4)) or iw
    local size = 13
    local lab = BoardUI.text(label, { s = size, b = true, col = o.col })
    while lab:getSize().w > room and size > 11 do
        size = size - 1
        lab = BoardUI.text(label, { s = size, b = true, col = o.col })
    end
    if lab:getSize().w > room then
        lab = BoardUI.text(label, { s = size, b = true, col = o.col, w = math.max(1, room) })
    end
    return BoardUI.spread(iw, lab, right, lh1(13))
end

-- An empty widget's hint in the lines it needs, at the largest of `sizes`
-- that fits `room`, so a short tile neither cuts it nor reserves lines it
-- leaves empty. o: sizes, i, serif, col.
local function hint(str, iw, room, o)
    o = o or {}
    local f = BoardUI.fitTitle(str, { i = o.i, serif = o.serif }, iw, o.sizes or { 13, 12, 11 }, 4, room)
    return text(str, { s = f.s, i = o.i, serif = o.serif, col = o.col or INK.g4, lines = f.lines > 1 and f.lines or nil, w = iw })
end

local function dots(flags, size, gap, o)
    local items = {}
    for i = 1, 7 do
        table.insert(items, BoardUI.dot(size, flags[i] == true, o))
    end
    return hstack({ gap = gap }, items)
end

local function cover(ctx, book, w, h, o)
    o = o or {}
    return BoardUI.cover(book, w, h, {
        path = book and book.cover_path,
        loading = book and book.cover_state == "loading",
        border = o.border or thin(),
        border_col = o.border_col or BoardColour.coverEdge(ctx, INK.gb),
        dim = o.dim,
    })
end

local function offlineDim(ctx, book)
    return not ctx.d.online and book and not book.on_device
end

-- ------------------------------------------------------- continue reading
-- disabled draws it like the full Download pill offline: gray, so it does
-- not look like a button that works.
local function roundButton(ctx, d, icon_name, filled, ink, disabled)
    local bg = disabled and INK.g4 or ink and INK.white or INK.black
    return BoardUI.circle(d, { bg = bg }, icon(icon_name, math.floor(d * (filled and 0.36 or 0.42) + 0.5), {
        col = disabled and "g6" or ink and "black" or "white", fill = filled, sw = 2.25,
    }))
end

W.hero = function(ctx, w, hh)
    local d = ctx.d
    local book = d.continue_reading[1]
    local total = #d.continue_reading
    local tall = hh >= px(170)
    local pad = px(tall and 16 or 12)
    local iw, ih = w - 2 * pad, hh - 2 * pad

    if not book then
        local variants = {}
        local copies = { _("Three picks from your library"), _("Pick a book to start"), _("Start here") }
        local picks = d.shelves["random"] or {}
        for n = 3, 0, -1 do
            for ci, copy in ipairs(copies) do
                table.insert(variants, function()
                    local ch = tall and math.min(ih - px(4), px(150)) or ih
                    local cw = math.floor(ch * 2 / 3 + 0.5)
                    local g2 = px(8)
                    local btn_d = math.min(px(tall and 48 or 52), ih)
                    local covers = {}
                    for i = 1, math.min(n, #picks) do
                        table.insert(covers, cover(ctx, picks[i], cw, ch, { border = math.max(1, px(1)), border_col = INK.g6 }))
                    end
                    local tw = math.max(1, iw - (n * cw + (n - 1) * g2) - btn_d - px(28))
                    local label = (ci == 1 and n ~= 3) and _("Picks from your library") or copy
                    return hstack({ w = w, h = hh }, {
                        space(pad, 1),
                        vstack({ w = tw }, {
                            text(_("Start reading"), { s = 11, b = true, col = BoardColour.onInk(ctx, INK.gb, "hero"), w = tw }),
                            space(nil, px(3)),
                            text(label, { s = 16, b = true, col = INK.white, lines = 2, w = tw }),
                        }),
                        space(px(14), 1),
                        hstack({ gap = g2, valign = "bottom" }, covers),
                        space(px(14), 1),
                        BoardUI.hit(roundButton(ctx, btn_d, "shuffle", false, true), { kind = "shuffle" }),
                        flex(0),
                    })
                end)
            end
        end
        if tall then
            local function stacked(n)
                return function()
                    local g2 = px(8)
                    local btn_h = px(38)
                    local ch = math.min(px(120), ih - lh1(11) - px(3) - 2 * lh(16) - px(10) - px(10) - btn_h)
                    local cw = math.min(math.floor(ch * 2 / 3 + 0.5), math.floor((iw - (n - 1) * g2) / n))
                    local covers = {}
                    for i = 1, math.min(n, #picks) do
                        table.insert(covers, cover(ctx, picks[i], cw, math.floor(cw * 1.5 + 0.5), { border = math.max(1, px(1)), border_col = INK.g6 }))
                    end
                    local shuffle = BoardUI.box({ w = BoardUI.runs({ _("Shuffle") }, { s = 14 }):getSize().w + px(16) + px(13) + px(16) + px(8), h = btn_h, radius = math.floor(btn_h / 2), bg = INK.white },
                        hstack({ h = btn_h, gap = px(8) }, { space(px(13), 1), icon("shuffle", px(16), { sw = 2.25 }), text(_("Shuffle"), { s = 14, b = true }) }))
                    return vstack({ w = w, h = hh, pad = pad }, {
                        text(_("Start reading"), { s = 11, b = true, col = BoardColour.onInk(ctx, INK.gb, "hero"), w = iw }),
                        space(nil, px(3)),
                        text(_("Pick a book from your library to begin"), { s = 16, b = true, col = INK.white, lines = 2, w = iw }),
                        flex(px(10)),
                        hstack({ gap = g2, valign = "bottom" }, covers),
                        space(nil, px(10)),
                        shuffle,
                    })
                end
            end
            table.insert(variants, 1, stacked(3))
            table.insert(variants, stacked(2))
        end
        return pick(variants)
    end

    local pct = tonumber(book.progressPercentage) or 0
    local play_icon = book.on_device and "play" or "download"

    if not tall then
        local ch = ih
        local btn_d = math.min(px(56), ch)
        -- The cover gives way before the title and progress: a tall, narrow
        -- tile keeps at least 110dp for them.
        local cw2 = math.min(math.floor(ch * 2 / 3 + 0.5), math.max(px(36), w - 2 * pad - btn_d - px(28) - px(110)))
        local cover_h = math.min(ch, math.floor(cw2 * 1.5 + 0.5))
        local tw2 = math.max(1, w - 2 * pad - cw2 - btn_d - px(28))
        local function label(lv)
            if lv == 2 then
                return total > 1 and T(_("Continue reading · %1 of %2"), 1, total) or _("Continue reading")
            end
            if lv == 1 then return _("Continue reading") end
        end
        local function meta(mv)
            local m = { { t = BoardData.pctLabel(book) or "0%", b = true, col = INK.white } }
            if mv == 2 and book.minutes_left then
                table.insert(m, { t = " · " .. T(_("%1 left"), BoardData.formatDuration(book.minutes_left)), col = BoardColour.onInk(ctx, INK.gc, "hero") })
            elseif mv == 1 and book.minutes_left then
                table.insert(m, { t = " · " .. T(_("%1 left"), BoardData.formatShortDuration(book.minutes_left)), col = BoardColour.onInk(ctx, INK.gc, "hero") })
            end
            return m
        end
        local variants = {}
        for _i, lm in ipairs({ { 2, 2 }, { 1, 2 }, { 2, 1 }, { 1, 1 }, { 1, 0 }, { 0, 1 }, { 0, 0 } }) do
            table.insert(variants, function()
                local lab = label(lm[1])
                local avail = ch - (lab and (lh1(11) + px(3)) or 0) - px(7) - lh1(12)
                local tf = BoardUI.fitTitle(book.title, { b = true }, tw2, { 18, 16, 15 }, 2, avail)
                local m = runs(meta(lm[2]), { s = 12 })
                local mw = math.min(math.floor(tw2 * 0.62 + 0.5), m:getSize().w + px(2), math.max(1, tw2 - px(30)))
                m = runs(meta(lm[2]), { s = 12, w = mw, data = true })
                return hstack({ w = w, h = hh }, {
                    space(pad, 1),
                    cover(ctx, book, cw2, cover_h, { border = math.max(1, px(1)), border_col = INK.g4 }),
                    space(px(14), 1),
                    vstack({ w = tw2, h = ch }, {
                        flex(0),
                        lab and text(lab, { s = 11, b = true, col = BoardColour.onInk(ctx, INK.gb, "hero"), w = tw2 }) or false,
                        lab and space(nil, px(3)) or false,
                        text(book.title, { s = tf.s, b = true, col = INK.white, lines = tf.lines, w = tw2, data = true }),
                        space(nil, px(7)),
                        hstack({ w = tw2, gap = px(10) }, { bar(math.max(px(20), tw2 - mw - px(10)), px(5), pct, { track = BoardColour.inkTrack(ctx, INK.g5, "hero"), fill = INK.white, r = px(2.5) }), m }),
                        flex(0),
                    }),
                    space(px(14), 1),
                    BoardUI.hit(roundButton(ctx, btn_d, play_icon, book.on_device, true, not book.on_device and not d.online), { kind = "book", book = book, resume = true, list = { label = _("Continue reading"), books = d.continue_reading } }),
                    flex(0),
                })
            end)
        end
        return pick(variants)
    end

    local offline = not d.online
    local function btn(short)
        local disabled = not book.on_device and offline
        local fg = disabled and INK.g6 or INK.black
        local label = book.on_device and (short and _("Resume") or _("Resume reading")) or _("Download")
        local inner = hstack({ h = px(40), gap = px(8) }, {
            space(px(13) - px(8), 1),
            icon(play_icon, px(book.on_device and 14 or 16), { col = disabled and "g6" or "black", fill = book.on_device, sw = 2.25 }),
            text(label, { s = 14, b = true, col = fg }),
            space(px(16) - px(8), 1),
        })
        return BoardUI.hit(BoardUI.box({ w = inner:getSize().w, h = px(40), radius = px(20), bg = disabled and INK.g4 or INK.white }, inner),
            { kind = "book", book = book, resume = true, list = { label = _("Continue reading"), books = d.continue_reading } })
    end
    local function ghost()
        return BoardUI.hit(BoardUI.circle(px(40), { border = math.max(1, px(1.5)), border_col = INK.white }, icon("ellipsis", px(18), { col = "white", sw = 2.5 })),
            { kind = "book-actions", book = book })
    end
    local function pager()
        if total <= 1 then return nil end
        return hstack({ gap = px(2) }, { text(T(_("%1 / %2"), 1, total), { s = 12, col = BoardColour.onInk(ctx, INK.gb, "hero") }), icon("chevron-right", px(15), { col = BoardColour.onInkHex(ctx, "gb", "hero"), sw = 2.5 }) })
    end
    local function meta(full)
        local m = { { t = tostring(math.floor(pct + 0.5)) .. "%", b = true, col = INK.white } }
        if book.minutes_left then
            local dur = full and BoardData.formatDuration(book.minutes_left) or BoardData.formatShortDuration(book.minutes_left)
            table.insert(m, { t = " · " .. T(_("%1 left"), dur), col = BoardColour.onInk(ctx, INK.gc, "hero") })
        end
        return m
    end
    local function side(opt)
        return function()
            local cover_h = ih
            local cover_w = math.min(math.floor(cover_h * 2 / 3 + 0.5), math.floor(iw * 0.4 + 0.5))
            local gutter = px(16)
            local tw = iw - cover_w - gutter
            local label_gap = px(opt.compact and 4 or 8)
            local author_gap = px(opt.compact and 4 or 6)
            local progress_gap = px(opt.compact and 4 or 10)
            local meta_gap = px(opt.compact and 4 or 8)
            local action_gap = px(opt.compact and 8 or 12)
            local fixed = lh1(12) + label_gap + author_gap + lh1(15) + progress_gap + px(6) + meta_gap + lh1(13) + action_gap + px(40)
            local tf = BoardUI.fitTitle(book.title, { b = true }, tw, { 26, 23, 20, 18, 16 }, 3, cover_h - fixed)
            local actions = opt.ghost and hstack({ gap = px(8) }, { btn(opt.short), ghost() }) or btn(opt.short)
            local label = text(_("Continue reading"), { s = 12, b = true, col = BoardColour.onInk(ctx, INK.gb, "hero") })
            return hstack({ w = w, h = hh, valign = "top" }, {
                space(pad, 1),
                -- A cover narrower than the column's height is centred in it,
                -- not hung above a band of empty tile.
                vstack({ w = cover_w, h = hh, pad = { pad, 0, pad, 0 } }, { flex(0), cover(ctx, book, cover_w, math.min(cover_h, math.floor(cover_w * 1.5 + 0.5)), { border = math.max(1, px(1)), border_col = INK.g4 }), flex(0) }),
                space(gutter, 1),
                vstack({ w = tw, h = hh, pad = { pad, 0, pad, 0 }, strict_padding = true }, {
                    opt.pager and BoardUI.spread(tw, label, pager()) or label,
                    space(nil, label_gap),
                    text(book.title, { s = tf.s, b = true, col = INK.white, lines = tf.lines, w = tw, data = true }),
                    space(nil, author_gap),
                    text(firstAuthor(book) or "", { s = 15, col = BoardColour.onInk(ctx, INK.gd, "hero"), w = tw, data = true }),
                    flex(progress_gap),
                    bar(tw, px(6), pct, { track = BoardColour.inkTrack(ctx, INK.g5, "hero"), fill = INK.white, r = px(3) }),
                    space(nil, meta_gap),
                    runs(meta(opt.full_meta), { s = 13, w = tw }),
                    space(nil, action_gap),
                    actions,
                }),
            })
        end
    end
    -- Short and narrow (2x2 on a 6" reader): the cover keeps the full height,
    -- and Resume becomes a round button beside the progress.
    local function sideCompact(opt)
        return function()
            local cover_h = ih
            local cover_w = math.min(math.floor(cover_h * 2 / 3 + 0.5), math.floor(iw * 0.42 + 0.5))
            local gutter = px(14)
            local tw = iw - cover_w - gutter
            local btn_d = px(40)
            local author_h = opt.author and (px(4) + lh1(13)) or 0
            local fixed = lh1(12) + px(6) + px(8) + btn_d
            local tf = BoardUI.fitTitle(book.title, { b = true }, tw, { 18, 16, 15 }, 3, cover_h - fixed - author_h)
            local bar_w = tw - btn_d - px(10)
            return hstack({ w = w, h = hh, valign = "top" }, {
                space(pad, 1),
                -- A cover narrower than the column's height is centred in it,
                -- not hung above a band of empty tile.
                vstack({ w = cover_w, h = hh, pad = { pad, 0, pad, 0 } }, { flex(0), cover(ctx, book, cover_w, math.min(cover_h, math.floor(cover_w * 1.5 + 0.5)), { border = math.max(1, px(1)), border_col = INK.g4 }), flex(0) }),
                space(gutter, 1),
                vstack({ w = tw, h = hh, pad = { pad, 0, pad, 0 }, strict_padding = true }, {
                    text(_("Continue reading"), { s = 12, b = true, col = BoardColour.onInk(ctx, INK.gb, "hero"), w = tw }),
                    space(nil, px(6)),
                    text(book.title, { s = tf.s, b = true, col = INK.white, lines = tf.lines, w = tw, data = true }),
                    opt.author and space(nil, px(4)) or false,
                    opt.author and text(firstAuthor(book) or "", { s = 13, col = BoardColour.onInk(ctx, INK.gd, "hero"), w = tw, data = true }) or false,
                    flex(px(8)),
                    hstack({ w = tw, gap = px(10) }, {
                        vstack({ w = bar_w }, {
                            text(tostring(math.floor(pct + 0.5)) .. "%", { s = 13, b = true, col = INK.white, w = bar_w }),
                            space(nil, px(5)),
                            bar(bar_w, px(6), pct, { track = BoardColour.inkTrack(ctx, INK.g5, "hero"), fill = INK.white, r = px(3) }),
                        }),
                        BoardUI.hit(roundButton(ctx, btn_d, play_icon, book.on_device, true, not book.on_device and not d.online), { kind = "book", book = book, resume = true, list = { label = _("Continue reading"), books = d.continue_reading } }),
                    }),
                }),
            })
        end
    end
    local function stacked(opt)
        return function()
            local bottom_h = px(6) + px(8) + lh1(13) + px(12) + px(40)
            local top_h = ih - lh1(12) - px(8) - bottom_h - px(8)
            local cover_h = math.max(px(40), math.min(top_h, px(120)))
            local cover_w = math.floor(cover_h * 2 / 3 + 0.5)
            local tw = iw - cover_w - px(12)
            local tf = BoardUI.fitTitle(book.title, { b = true }, tw, { 20, 18, 16, 15 }, 3, cover_h - (opt.author and (lh1(13) + px(4)) or 0))
            local label = text(_("Continue reading"), { s = 12, b = true, col = BoardColour.onInk(ctx, INK.gb, "hero") })
            return vstack({ w = w, h = hh, pad = pad, strict_padding = true }, {
                opt.pager and BoardUI.spread(iw, label, pager()) or label,
                space(nil, px(8)),
                hstack({ gap = px(12), valign = "top" }, {
                    cover(ctx, book, cover_w, cover_h, { border = math.max(1, px(1)), border_col = INK.g4 }),
                    vstack({ w = tw }, {
                        text(book.title, { s = tf.s, b = true, col = INK.white, lines = tf.lines, w = tw, data = true }),
                        opt.author and space(nil, px(4)) or false,
                        opt.author and text(firstAuthor(book) or "", { s = 13, col = BoardColour.onInk(ctx, INK.gd, "hero"), w = tw, data = true }) or false,
                    }),
                }),
                flex(px(8)),
                bar(iw, px(6), pct, { track = BoardColour.inkTrack(ctx, INK.g5, "hero"), fill = INK.white, r = px(3) }),
                space(nil, px(8)),
                runs(meta(opt.full_meta), { s = 13, w = iw }),
                space(nil, px(12)),
                opt.ghost and hstack({ gap = px(8) }, { btn(opt.short), ghost() }) or btn(opt.short),
            })
        end
    end
    -- The last resort on a short tile: no cover, the title and the round
    -- button beside the progress.
    local function mini()
        return function()
            local btn_d = px(40)
            local bar_w = iw - btn_d - px(10)
            local tf = BoardUI.fitTitle(book.title, { b = true }, iw, { 18, 16, 15 }, 2, ih - lh1(12) - px(6) - px(8) - btn_d)
            return vstack({ w = w, h = hh, pad = pad, strict_padding = true }, {
                text(_("Continue reading"), { s = 12, b = true, col = BoardColour.onInk(ctx, INK.gb, "hero"), w = iw }),
                space(nil, px(6)),
                text(book.title, { s = tf.s, b = true, col = INK.white, lines = tf.lines, w = iw, data = true }),
                flex(px(8)),
                hstack({ w = iw, gap = px(10) }, {
                    vstack({ w = bar_w }, {
                        text(tostring(math.floor(pct + 0.5)) .. "%", { s = 13, b = true, col = INK.white, w = bar_w }),
                        space(nil, px(5)),
                        bar(bar_w, px(6), pct, { track = BoardColour.inkTrack(ctx, INK.g5, "hero"), fill = INK.white, r = px(3) }),
                    }),
                    BoardUI.hit(roundButton(ctx, btn_d, play_icon, book.on_device, true, not book.on_device and not d.online), { kind = "book", book = book, resume = true, list = { label = _("Continue reading"), books = d.continue_reading } }),
                }),
            })
        end
    end
    return pick({
        side({ pager = true, ghost = true, full_meta = true }),
        side({ pager = true, ghost = false, short = true, full_meta = true }),
        side({ pager = false, ghost = false, short = true, full_meta = false }),
        side({ pager = false, ghost = false, short = true, full_meta = false, compact = true }),
        sideCompact({ author = true }),
        sideCompact({ author = false }),
        stacked({ pager = true, ghost = true, author = true, full_meta = true }),
        stacked({ pager = true, ghost = false, author = true, full_meta = true }),
        stacked({ pager = false, ghost = false, short = true, author = true, full_meta = false }),
        stacked({ pager = false, ghost = false, short = true, author = false, full_meta = false }),
        mini(),
    })
end

-- -------------------------------------------------------------- statistics
W.streak = function(ctx, w, hh)
    local d = ctx.d
    local pad = px(12)
    local iw = w - 2 * pad
    local n = d.streak.current
    local wide = w > px(200)
    local val_s = fillSize(hh - 2 * pad - lh1(13) - px(18), 20, wide and 40 or 36)
    local function count(width)
        if n > 0 then
            return runs({ { t = tostring(n), b = true, s = val_s }, { t = " " .. (n == 1 and _("day") or _("days")), col = INK.g4 } }, { s = 13, w = width })
        end
        local rs = math.min(val_s, 18)
        if width then rs = BoardUI.fitSize(_("Read today"), { s = rs, b = true }, width, 12) end
        return runs({ { t = _("Read today"), b = true, s = rs } }, { s = 13, w = width })
    end
    local dot_size = px(wide and 11 or 9)
    local dot_gap = wide and px(7) or math.max(px(3), math.floor((iw - 7 * px(9)) / 6))
    return pick({
        function()
            local dot_row = dots(d.streak_week, dot_size, dot_gap, { col = BoardColour.ink(ctx, INK.black) })
            return vstack({ w = w, h = hh, pad = pad }, {
                head(iw, _("Streak"), icon("flame", px(17), BoardColour.icon(ctx, 2.25))),
                flex(0),
                count(iw),
                flex(0),
                wide and BoardUI.spread(iw, dot_row, text(T(_("best %1"), d.streak.longest), { s = 12, col = INK.g4 })) or dot_row,
            })
        end,
        -- A short row: the week beside the count.
        function()
            return vstack({ w = w, h = hh, pad = pad }, {
                head(iw, _("Streak"), icon("flame", px(17), BoardColour.icon(ctx, 2.25))),
                flex(0),
                BoardUI.spread(iw, count(nil), dots(d.streak_week, dot_size, dot_gap, { col = BoardColour.ink(ctx, INK.black) })),
            })
        end,
        function()
            return vstack({ w = w, h = hh, pad = pad }, {
                head(iw, _("Streak"), icon("flame", px(17), BoardColour.icon(ctx, 2.25))),
                flex(0),
                count(iw),
            })
        end,
    })
end

W.week = function(ctx, w, hh)
    local d = ctx.d
    local pad = px(12)
    local iw = w - 2 * pad
    local max = 1
    for _i, v in ipairs(d.week) do max = math.max(max, v) end
    local bar_w = math.min(px(22), math.floor((iw - 6 * px(6)) / 7))
    local gap = math.floor((iw - 7 * bar_w) / 6)
    local base = math.max(1, px(1))
    local function chart(chart_h)
        local bars = {}
        for i, v in ipairs(d.week) do
            local h = v > 0 and math.max(px(3), math.floor((chart_h - px(2)) * v / max + 0.5)) or px(2)
            local col = v > 0 and (i == 7 and BoardColour.ink(ctx, INK.black) or BoardColour.mid(ctx, INK.g8)) or BoardColour.track(ctx, INK.gc)
            table.insert(bars, BoardUI.rect(bar_w, h, col))
        end
        return vstack({ w = iw }, {
            hstack({ w = iw, h = chart_h - base, gap = gap, valign = "bottom" }, bars),
            rect(iw, base, INK.black),
        })
    end
    local function initials()
        local cells = {}
        for i, t in ipairs(d.week_initials) do
            table.insert(cells, text(t, { s = 11, b = i == 7, col = i == 7 and INK.black or INK.g4, w = bar_w, align = "center" }))
        end
        return hstack({ gap = gap }, cells)
    end
    local long = d.week_min > 0 and BoardData.formatDuration(d.week_min) or _("Nothing yet")
    local short = d.week_min > 0 and BoardData.formatShortDuration(d.week_min) or _("Nothing yet")
    -- A layout only counts when its bars get at least this much height.
    local min_chart = px(12)
    local variants = {}
    -- The total beside the title, then the bars over their weekday initials.
    local beside_h = hh - 2 * pad - lh1(13) - px(8) - lh1(11) - px(4)
    for _i, total in ipairs(beside_h >= min_chart and { long, short } or {}) do
        table.insert(variants, function()
            return vstack({ w = w, h = hh, pad = pad }, {
                head(iw, _("This week"), text(total, { s = 13, b = true })),
                space(nil, px(8)),
                chart(beside_h),
                space(nil, px(4)),
                initials(),
            })
        end)
    end
    -- A single column: the total under the title, initials only with room.
    for _i, with_initials in ipairs({ true, false }) do
        local chart_h = hh - 2 * pad - 2 * lh1(13) - px(6) - (with_initials and (px(4) + lh1(11)) or 0)
        if chart_h >= min_chart or not with_initials then
            table.insert(variants, function()
                return vstack({ w = w, h = hh, pad = pad }, {
                    head(iw, _("This week"), nil),
                    text(short, { s = 13, b = true, w = iw }),
                    space(nil, px(6)),
                    chart(chart_h),
                    with_initials and space(nil, px(4)) or false,
                    with_initials and initials() or false,
                })
            end)
        end
    end
    return pick(variants)
end

W.today = function(ctx, w, hh)
    local d = ctx.d
    local pad = px(12)
    local iw = w - 2 * pad
    local val_s = fillSize(hh - 2 * pad - lh1(13) - px(20), 18, 30)
    local function value()
        return d.today_min > 0
            and runs({ { t = tostring(d.today_min), b = true, s = val_s }, { t = " " .. _("min"), col = INK.g4 } }, { s = 14, w = iw })
            or runs({ { t = _("Not yet"), b = true, s = math.min(val_s, 20) } }, { s = 14, w = iw })
    end
    -- A short row drops the weekly average.
    return pick({
        function()
            return vstack({ w = w, h = hh, pad = pad }, {
                head(iw, _("Today"), icon("clock", px(17), BoardColour.icon(ctx, 2.25))),
                flex(0),
                value(),
                flex(0),
                text(T(_("avg %1 min"), math.floor(d.week_min / 7 + 0.5)), { s = 12, col = INK.g4, w = iw }),
            })
        end,
        function()
            return vstack({ w = w, h = hh, pad = pad }, {
                head(iw, _("Today"), icon("clock", px(17), BoardColour.icon(ctx, 2.25))),
                flex(0),
                value(),
            })
        end,
    })
end

-- Goal pace: how the year's goal is tracking, not only the count.
W.goalpace = function(ctx, w, hh)
    local d = ctx.d
    local g = d.goal
    local pad = px(12)
    local iw = w - 2 * pad
    local goal = g.books or 0
    local done = g.done or 0
    if goal <= 0 then
        local function empty(str)
            return function()
                return vstack({ w = w, h = hh, pad = pad }, {
                    head(iw, T(_("%1 goal"), g.year), icon("target", px(16), BoardColour.icon(ctx, 2.25))),
                    space(nil, px(6)),
                    hint(str, iw, hh - 2 * pad - lh1(13) - px(6)),
                })
            end
        end
        return pick({ empty(_("Set a reading goal in BookOrbit to track your pace.")), empty(_("Set a goal in BookOrbit.")) })
    end
    local expected = goal * d.day_of_year / 365
    local projected = math.floor(done * 365 / math.max(1, d.day_of_year) + 0.5)
    local met = done >= goal
    local statuses
    if done == 0 then
        statuses = { _("First book starts it"), _("Starting out"), _("New") }
    elseif met then
        statuses = { T(_("Goal met · on pace for %1"), projected), T(_("on pace for %1"), projected), _("Goal met") }
    elseif done >= expected then
        local ahead = math.floor(done - expected + 0.5)
        statuses = { T(_("%1 ahead of pace"), ahead), T(_("%1 ahead"), ahead) }
    else
        local behind = math.floor(expected - done + 0.5)
        statuses = { T(_("%1 behind pace"), behind), T(_("%1 behind"), behind) }
    end
    local behind = not met and done > 0 and done < expected
    local trophy = icon(met and "trophy" or "target", px(16), BoardColour.icon(ctx, 2.25))
    local function goalBar()
        local scale = math.max(goal, projected, done, 1)
        local goal_x = math.floor(iw * goal / scale + 0.5)
        local tick_w = math.max(1, px(2))
        local tick = met
            and BoardUI.box({ w = tick_w + 2 * math.max(1, px(1)), h = px(14) + 2 * math.max(1, px(1)), border = math.max(1, px(1)), bg = INK.white })
            or rect(tick_w, px(14), INK.black)
        return BoardUI.overlay(iw, px(14), {
            { widget = bar(iw, px(6), math.floor(100 * done / scale + 0.5), { track = BoardColour.track(ctx, INK.gd), fill = BoardColour.ink(ctx, INK.black), r = px(3) }), x = 0, y = px(4) },
            { widget = tick, x = math.min(iw - px(2), goal_x) - (met and math.max(1, px(1)) or 0), y = met and -math.max(1, px(1)) or 0 },
        })
    end
    local val_s = fillSize(hh - 2 * pad - lh1(13) - lh1(12) - px(10), 20, 32)
    local variants = {}
    for _i, st in ipairs(statuses) do
        for _i, unit in ipairs({ T(_(" of %1 books"), goal), T(_(" of %1"), goal) }) do
            table.insert(variants, function()
                return vstack({ w = w, h = hh, pad = pad }, {
                    head(iw, T(_("%1 goal"), g.year), trophy),
                    flex(0),
                    BoardUI.spread(iw, runs({ { t = tostring(done), b = true, s = 24 }, { t = unit, col = INK.g4 } }, { s = 13 }),
                        text(st, { s = 12, b = behind, col = behind and INK.black or INK.g4 })),
                    space(nil, px(4)),
                    goalBar(),
                })
            end)
        end
    end
    for _i, st in ipairs(statuses) do
        for _i, unit in ipairs({ T(_(" of %1 books"), goal), T(_(" of %1"), goal) }) do
            table.insert(variants, function()
                return vstack({ w = w, h = hh, pad = pad }, {
                    head(iw, T(_("%1 goal"), g.year), trophy),
                    flex(0),
                    runs({ { t = tostring(done), b = true, s = val_s }, { t = unit, col = INK.g4 } }, { s = 13, w = iw }),
                    space(nil, px(5)),
                    text(st, { s = 12, b = behind, col = behind and INK.black or INK.g4, w = iw }),
                })
            end)
        end
    end
    -- A short row: the count with its status beside it, then the count alone.
    for _i, st in ipairs(statuses) do
        table.insert(variants, function()
            return vstack({ w = w, h = hh, pad = pad }, {
                head(iw, T(_("%1 goal"), g.year), trophy),
                flex(0),
                BoardUI.spread(iw, runs({ { t = tostring(done), b = true, s = 20 }, { t = T(_(" of %1"), goal), col = INK.g4 } }, { s = 13 }),
                    text(st, { s = 12, b = behind, col = behind and INK.black or INK.g4 })),
            })
        end)
    end
    table.insert(variants, function()
        return vstack({ w = w, h = hh, pad = pad }, {
            head(iw, T(_("%1 goal"), g.year), trophy),
            flex(0),
            runs({ { t = tostring(done), b = true, s = 20 }, { t = T(_(" of %1"), goal), col = INK.g4 } }, { s = 13, w = iw }),
        })
    end)
    return pick(variants)
end

-- A year of reading days, one square a day, shaded by minutes read.
W.heatmap = function(ctx, w, hh)
    local d = ctx.d
    local pad = px(12)
    local iw = w - 2 * pad
    local g = math.max(1, px(1.5))
    local legend_h = lh1(11)
    local month_h = lh1(11)
    local grid_h = hh - 2 * pad - lh1(13) - px(8) - month_h - px(3) - px(8) - legend_h
    local weeks = 52
    local cell = math.min(math.floor((iw - (weeks - 1) * g) / weeks), math.floor((grid_h - 6 * g) / 7))
    if cell < px(6.5) then
        cell = math.max(px(4), math.min(px(9), math.floor((grid_h - 6 * g) / 7)))
        weeks = math.min(52, math.floor((iw + g) / (cell + g)))
    end
    local offset = (52 - weeks) * 7
    local total, days_read, best, best_i = 0, 0, 0, nil
    for i = offset + 1, #d.heatmap do
        local v = d.heatmap[i] or 0
        total = total + v
        if v > 0 then days_read = days_read + 1 end
        if v > best then best, best_i = v, i end
    end
    local ramp = BoardColour.ramp(ctx, { INK.ge, INK.gb, INK.g8, INK.g4, INK.black })
    local function level(v)
        if v == nil then return nil end
        if v <= 0 then return ramp[1] end
        if v < 30 then return ramp[2] end
        if v < 60 then return ramp[3] end
        if v < 120 then return ramp[4] end
        return ramp[5]
    end
    local grid_w = weeks * cell + (weeks - 1) * g
    local radius = math.max(1, px(1.5))
    local today_i = nil
    for i = 1, #d.heatmap do if d.heatmap[i] ~= nil then today_i = i end end
    local function gridEl()
        local cells = {}
        for wk = 0, weeks - 1 do
            for day = 0, 6 do
                local i = offset + wk * 7 + day + 1
                local col = level(d.heatmap[i])
                if col then
                    table.insert(cells, { x = wk * (cell + g), y = day * (cell + g), col = col, ring = i == today_i })
                end
            end
        end
        return BoardUI.cellGrid(grid_w, 7 * cell + 6 * g, cell, radius, cells)
    end
    local function monthsEl()
        local layers = {}
        local prev_m, prev_x = nil, -999
        for wk = 0, weeks - 1 do
            local t = d.heatmap_start + (offset + wk * 7) * 86400
            local m = tonumber(os.date("%m", t))
            local x = wk * (cell + g)
            if prev_m and m ~= prev_m and x - prev_x >= px(26) and x + px(24) <= grid_w then
                table.insert(layers, { widget = text(BoardData.shortMonth(t), { s = 11, col = INK.g4 }), x = x, y = 0 })
                prev_x = x
            end
            prev_m = m
        end
        return BoardUI.overlay(grid_w, month_h, layers)
    end
    local sw = math.max(px(8), math.min(cell, px(11)))
    local function swatches(words)
        local items = {}
        if words then table.insert(items, text(_("Less"), { s = 11, col = INK.g4 })); table.insert(items, space(px(2), 1)) end
        for _i, v in ipairs({ 0, 20, 45, 90, 200 }) do table.insert(items, rect(sw, sw, level(v), radius)) end
        if words then table.insert(items, space(px(2), 1)); table.insert(items, text(_("More"), { s = 11, col = INK.g4 })) end
        return hstack({ gap = px(3) }, items)
    end
    local function bestEl()
        if not best_i then return text(_("Your reading days fill in here"), { s = 11, col = INK.g4 }) end
        local t = d.heatmap_start + (best_i - 1) * 86400
        return runs({ { t = _("Best day") .. " " }, { t = BoardData.formatShortDuration(best), b = true, col = INK.black },
            { t = ", " .. BoardData.shortWeekday(t) .. " " .. tonumber(os.date("%d", t)) .. " " .. BoardData.shortMonth(t) } }, { s = 11, col = INK.g4 })
    end
    local function legend(lv)
        if lv == -1 then return space(grid_w, legend_h) end
        if lv == 0 then return hstack({ w = grid_w, h = legend_h }, { flex(0), swatches(true) }) end
        return BoardUI.spread(grid_w, bestEl(), swatches(lv == 2), legend_h)
    end
    local label = weeks >= 52 and _("Year in reading") or T(_("Past %1 months"), math.floor(weeks / 4.35 + 0.5))
    local used = lh1(13) + px(8) + month_h + px(3) + 7 * cell + 6 * g + px(8) + legend_h
    local figs = {
        { T(_("%1 h"), math.floor(total / 60 + 0.5)), _("read") },
        { tostring(days_read), _("days") },
        { tostring(d.streak.longest), _("best streak") },
        { T(_("%1 min"), math.floor(total / math.max(1, days_read) + 0.5)), _("a reading day") },
    }
    local function build(lv, nf, head_totals)
        return function()
            local fig_row = nil
            if nf > 0 then
                local items = {}
                for i = 1, nf do
                    if i > 1 then table.insert(items, flex(0)) end
                    table.insert(items, vstack({}, { text(figs[i][1], { s = 20, b = true }), text(figs[i][2], { s = 11, col = INK.g4 }) }))
                end
                fig_row = hstack({ w = grid_w }, items)
            end
            local totals = nil
            if head_totals and total > 0 then
                totals = runs({ { t = T(_("%1 h"), math.floor(total / 60 + 0.5)), b = true }, { t = " · " .. T(_("%1 days"), days_read), col = INK.g4 } }, { s = 13 })
            end
            return vstack({ w = w, h = hh, pad = pad, align = "center" }, {
                head(iw, label, totals),
                space(nil, px(8)),
                monthsEl(), space(nil, px(3)), gridEl(),
                flex(px(8)),
                fig_row or false,
                fig_row and flex(px(8)) or false,
                legend(lv),
            })
        end
    end
    local room_for_figs = total > 0 and hh - 2 * pad - used >= lh1(20) + lh1(11) + px(6)
    local variants = {}
    for _i, nf in ipairs(room_for_figs and { 4, 3, 0 } or { 0 }) do
        for _i, lv in ipairs({ 2, 1, 0, -1 }) do table.insert(variants, build(lv, nf, nf == 0)) end
    end
    table.insert(variants, build(-1, 0, false))
    return pick(variants)
end

W.calendar = function(ctx, w, hh)
    local d = ctx.d
    local pad = px(12)
    local iw = w - 2 * pad
    local now = d.now
    local t = os.date("*t", now)
    local first = os.time({ year = t.year, month = t.month, day = 1, hour = 12 })
    local lead = tonumber(os.date("%w", first))
    local days = tonumber(os.date("%d", os.time({ year = t.year, month = t.month + 1, day = 0, hour = 12 })))
    local today = t.day
    -- Which days of this month had reading, from the heatmap's minutes.
    local read = {}
    for day = 1, today do
        local key_t = os.time({ year = t.year, month = t.month, day = day, hour = 12 })
        local idx = math.floor((key_t - d.heatmap_start) / 86400 + 0.5) + 1
        read[day] = (d.heatmap[idx] or 0) > 0
    end
    local read_count = 0
    for _i, v in pairs(read) do if v then read_count = read_count + 1 end end
    local gap = px(3)
    local month_rows = math.ceil((lead + days) / 7)
    local head_row_h = lh1(11) + px(3)
    local avail_h = hh - 2 * pad - lh1(13) - px(8)
    local month_cell = math.min(math.floor((avail_h - (month_rows - 1) * gap) / month_rows), math.floor((iw - 6 * gap) / 7))
    local numbered = month_cell >= px(24)
    if numbered then
        avail_h = avail_h - head_row_h
        month_cell = math.min(math.floor((avail_h - (month_rows - 1) * gap) / month_rows), math.floor((iw - 6 * gap) / 7))
    end
    local strip = month_cell < px(14)
    local per_row = strip and 16 or 7
    local rows = strip and 2 or month_rows
    local offset = strip and 0 or lead
    local cell = strip and math.min(math.floor((iw - 15 * gap) / 16), math.floor((avail_h - gap) / 2)) or month_cell
    local grid_w = per_row * cell + (per_row - 1) * gap
    local radius = px(numbered and 4 or 2)
    local cells = {}
    local labels = {}
    local outline = math.max(1, px(1))
    for i = 0, rows * per_row - 1 do
        local day = i - offset + 1
        if day >= 1 and day <= days then
            local x, y = (i % per_row) * (cell + gap), math.floor(i / per_row) * (cell + gap)
            local is_read = read[day] == true
            if is_read then
                table.insert(cells, { x = x, y = y, col = day == today and BoardColour.deep(ctx, INK.black) or BoardColour.ink(ctx, INK.g6) })
            else
                table.insert(cells, { x = x, y = y, col = day > today and INK.gd or INK.gb, border = outline })
            end
            if numbered and not strip then
                table.insert(labels, { widget = text(tostring(day), { s = 11, b = day == today, col = is_read and INK.white or (day > today and INK.g8 or INK.g4), w = cell, align = "center" }),
                    x = x, y = y + math.floor((cell - lh1(11)) / 2) })
            end
        end
    end
    local grid_h = rows * cell + (rows - 1) * gap
    table.insert(labels, 1, { widget = BoardUI.cellGrid(grid_w, grid_h, cell, radius, cells) })
    local grid = BoardUI.overlay(grid_w, grid_h, labels)
    local header = nil
    if numbered and not strip then
        local items = {}
        for i = 1, 7 do
            local wd_t = os.time({ year = 2026, month = 10, day = 3 + i, hour = 12 }) -- Sunday 4 Oct 2026
            table.insert(items, text(BoardData.shortWeekday(wd_t):sub(1, 1), { s = 11, col = INK.g4, w = cell, align = "center" }))
        end
        header = vstack({ w = grid_w, h = head_row_h }, { hstack({ gap = gap }, items) })
    end
    return vstack({ w = w, h = hh, pad = pad, align = "center" }, {
        head(iw, BoardData.longMonth(now), text(T(_("%1 days read"), read_count), { s = 12, col = INK.g4 })),
        space(nil, px(8)),
        header or false,
        grid,
        flex(0),
    })
end

-- ------------------------------------------------------------------- lists
W.also = function(ctx, w, hh)
    local d = ctx.d
    local pad = px(12)
    local iw = w - 2 * pad
    local books = {}
    for i = 2, #d.continue_reading do table.insert(books, d.continue_reading[i]) end
    local avail = hh - 2 * pad - lh1(13) - px(6)
    local n = math.max(0, math.min(#books, math.floor(avail / px(46))))
    local row_h = n > 0 and math.min(px(64), math.floor(avail / n)) or px(56)
    local cover_h = math.min(px(44), row_h - px(8))
    local cover_w = math.floor(cover_h * 2 / 3 + 0.5)
    local tw = iw - cover_w - px(10)
    local rows = {}
    for i = 1, n do
        local b = books[i]
        local pct = tonumber(b.progressPercentage) or 0
        local sep = i > 1 and rect(iw, math.max(1, px(0.75)), INK.gc) or nil
        local row_inner_h = row_h - (sep and math.max(1, px(0.75)) or 0)
        -- At least 38dp, wider when a cloud and "100%" need it; the bar gives way.
        local pct_text = text(BoardData.pctLabel(b) or "0%", { s = 12, b = true })
        local content_w = pct_text:getSize().w + ((not b.on_device) and (px(12) + px(3)) or 0)
        local right_w = math.max(px(38), content_w)
        local right = hstack({ w = right_w }, {
            flex(0),
            (not b.on_device) and icon("cloud", px(12), { col = "g4", sw = 2.25 }) or false,
            (not b.on_device) and space(px(3), 1) or false,
            pct_text,
        })
        table.insert(rows, sep or false)
        table.insert(rows, BoardUI.hit(hstack({ w = iw, h = row_inner_h, gap = px(10) }, {
            cover(ctx, b, cover_w, cover_h, { border = thin(), dim = offlineDim(ctx, b) }),
            vstack({ w = tw }, {
                text(b.title, { s = 14, b = true, w = tw, data = true }),
                space(nil, px(5)),
                hstack({ w = tw, gap = px(8) }, { bar(tw - right_w - px(8), px(4), pct, { track = BoardColour.track(ctx, INK.gc), fill = BoardColour.ink(ctx, INK.black), r = px(2) }), right }),
            }),
        }), { kind = "book", book = b, resume = ctx.tap_resumes, list = { label = _("Continue reading"), books = d.continue_reading } }))
    end
    local all = hstack({ gap = px(2) }, { text(T(_("All %1"), d.counts.in_progress or #d.continue_reading), { s = 13, b = true }), icon("chevron-right", px(15), { sw = 2.5 }) })
    local body = n > 0 and vstack({ w = iw }, rows) or text(_("Books you start show up here."), { s = 13, col = INK.g4, w = iw })
    return vstack({ w = w, h = hh, pad = pad }, {
        head(iw, _("Also reading"), all),
        space(nil, px(6)),
        body,
        flex(0),
    })
end

W.highlight = function(ctx, w, hh)
    local d = ctx.d
    local hl = d.highlight
    local pad = px(14)
    local iw = w - 2 * pad
    if not hl then
        local str = _("Your highlights come back here, one a day.")
        local o = { sizes = { 15, 14, 13, 12 }, i = true, serif = true, col = INK.g3 }
        return pick({
            function()
                return vstack({ w = w, h = hh, pad = pad }, {
                    icon("quote", px(20), { fill = true, sw = 1, col = BoardColour.artHex(ctx, "#000000", "deep") }),
                    space(nil, px(8)),
                    hint(str, iw, hh - 2 * pad - px(20) - px(8), o),
                })
            end,
            function() return vstack({ w = w, h = hh, pad = pad }, { hint(str, iw, hh - 2 * pad, o) }) end,
        })
    end
    local tall = hh > px(200)
    local p3 = hh < px(130) and px(12) or pad
    local iw3 = w - 2 * p3
    local attr_h = lh1(12) + (tall and (px(2) + lh1(12)) or 0)
    local qs = hh < px(130) and 14 or 15
    local function quote(budget)
        local lines = math.max(1, math.floor(budget / lh(qs)))
        return text(hl.text, { s = qs, i = true, serif = true, lines = lines > 1 and lines or nil, w = iw3, col = INK.g1, data = true })
    end
    local label = function()
        return hstack({ w = iw3, h = lh1(12), gap = px(6) }, { icon("quote", px(14), { fill = true, sw = 1, col = BoardColour.artHex(ctx, "#000000", "deep") }), text(_("Highlight of the day"), { s = 12, b = true, col = INK.g4 }), flex(0) })
    end
    return pick({
        function()
            return vstack({ w = w, h = hh, pad = p3 }, {
                label(),
                space(nil, px(6)),
                quote(hh - 2 * p3 - lh1(12) - px(6) - px(6) - attr_h),
                flex(px(6)),
                text(hl.bookTitle or "", { s = 12, b = true, w = iw3, data = true }),
                tall and space(nil, px(2)) or false,
                tall and text(hl.chapterTitle or "", { s = 12, col = INK.g4, w = iw3, data = true }) or false,
            })
        end,
        -- A short row: the quote and its book, without the label.
        function()
            return vstack({ w = w, h = hh, pad = p3 }, {
                quote(hh - 2 * p3 - px(6) - lh1(12)),
                flex(px(6)),
                text(hl.bookTitle or "", { s = 12, b = true, w = iw3, data = true }),
            })
        end,
        function()
            return vstack({ w = w, h = hh, pad = p3 }, { flex(0), quote(hh - 2 * p3), flex(0) })
        end,
    })
end

-- ---------------------------------------------------------------- shelves
local SHELF_TITLES = {
    ["want-to-read"] = function() return _("Want to read") end,
    ["up-next-in-series"] = function() return _("Up next in series") end,
    ["random"] = function() return _("Discover") end,
    ["recently-added"] = function() return _("Recently added") end,
    ["in-progress"] = function() return _("In progress") end,
    ["pick-back-up"] = function() return _("Pick back up") end,
    ["finished"] = function() return _("Finished this year") end,
}
local SHELF_EMPTY = {
    ["want-to-read"] = function() return _("Mark books Want to read and they wait here.") end,
    ["pick-back-up"] = function() return _("Books you put down a while ago show up here.") end,
    ["finished"] = function() return _("Books you finish this year gather here.") end,
}
-- Shelves with no catalog list to open: no See all.
local SHELF_NO_LIST = { ["want-to-read"] = true }
BoardWidgets.shelfTitle = function(props)
    if props.title then return props.title end
    local f = SHELF_TITLES[props.source]
    return f and f() or _("Shelf")
end

W.shelf = function(ctx, w, hh, props, item)
    local d = ctx.d
    local pad = px(12)
    local iw = w - 2 * pad
    local fetched = d.shelves[BoardStore.shelfKey(props)]
    local books = fetched or {}
    local title_size = 11
    local cap_h = px(6) + lh1(title_size)
    local cover_h = math.max(1, hh - 2 * pad - lh1(13) - px(10) - cap_h)
    local cover_w = math.min(iw, math.floor(cover_h * 2 / 3 + 0.5))
    cover_h = math.min(cover_h, math.floor(cover_w * 1.5 + 0.5))
    local min_gap = px(12)
    -- A half-width shelf holds three covers; one as wide as the board takes
    -- as many as fit, so a two-column board does not spread three apart.
    local geometry = ctx.menu and ctx.menu._board_geometry
    local full_width = item and geometry and item.cw >= geometry.cols
    local max_books = (not full_width and (item and item.cw or 2) <= 2) and 3 or math.huge
    local n = math.min(max_books, math.max(1, math.floor((iw + min_gap) / (cover_w + min_gap))))
    -- A gap of a quarter of a cover takes one more, smaller cover instead.
    if n < max_books and iw - (n * cover_w + (n - 1) * min_gap) > cover_w * 0.25 then
        n = n + 1
        cover_w = math.floor((iw - (n - 1) * min_gap) / n)
        cover_h = math.min(cover_h, math.floor(cover_w * 1.5 + 0.5))
    end
    local gap = n > 1 and math.floor((iw - n * cover_w) / (n - 1)) or 0
    local finished = props.source == "finished" and not props.title
    local title = finished and T(_("Finished in %1"), d.goal.year) or BoardWidgets.shelfTitle(props)
    local right
    if props.shuffle then
        right = BoardUI.hit(hstack({ w = px(36), h = lh1(13) }, { flex(0), icon("shuffle", px(17), { sw = BoardColour.icon(ctx, 2.25).sw, col = d.online and BoardColour.artHex(ctx, "#000000") or "ga" }) }),
            d.online and { kind = "shuffle" } or { kind = "noop" })
    elseif finished then
        right = hstack({ gap = px(2) }, { text(tostring(d.goal.done or 0), { s = 13, b = true }), icon("chevron-right", px(15), { sw = 2.5 }) })
    elseif not SHELF_NO_LIST[props.source] then
        right = hstack({ gap = px(2) }, { text(_("See all"), { s = 13, b = true }), icon("chevron-right", px(15), { sw = 2.5 }) })
    end
    if #books == 0 then
        -- A shelf added since the last refresh has no books yet, which is not
        -- the same as an empty one.
        local message
        if d.loading or (not fetched and d.online) then
            message = _("Loading…")
        elseif not fetched then
            message = _("Connect to Wi-Fi to fill this shelf.")
        else
            local empty = SHELF_EMPTY[props.source]
            message = empty and empty() or _("Nothing here yet.")
        end
        return vstack({ w = w, h = hh, pad = pad }, {
            head(iw, title, nil),
            space(nil, px(8)),
            text(message, { s = 13, col = INK.g4, lines = 3, w = iw }),
            flex(0),
        })
    end
    local cards = {}
    for i = 1, math.min(n, #books) do
        local b = books[i]
        table.insert(cards, BoardUI.hit(vstack({ w = cover_w }, {
            cover(ctx, b, cover_w, cover_h, { border = thin(), dim = offlineDim(ctx, b) }),
            space(nil, px(6)),
            text(b.title, { s = title_size, b = true, w = cover_w, data = true }),
        }), { kind = "detail", book_id = b.id, list = { label = title, books = books } }))
    end
    return vstack({ w = w, h = hh, pad = pad, strict_padding = true }, {
        head(iw, title, right),
        space(nil, px(10)),
        hstack({ gap = gap, valign = "top" }, cards),
        flex(0),
    })
end

-- --------------------------------------------------------------- shortcuts
local LINKS = {
    library = { "book-copy", function() return _("Library") end, function(d) return d.counts.library end, function() return _("books") end },
    series = { "layers-2", function() return _("Series") end, function(d) return d.counts.series end, function() return _("series") end },
    authors = { "feather", function() return _("Authors") end, function(d) return d.counts.authors end, function() return _("authors") end },
    collections = { "folder-open", function() return _("Collections") end, function(d) return d.counts.collections end,
        function(n) return n == 1 and _("collection") or _("collections") end },
    scopes = { "aperture", function() return _("SmartScopes") end, function(d) return d.counts.scopes end, function() return _("scopes") end },
    device = { "tablet", function() return _("On device") end, function(d) return d.counts.device end,
        function(n) return _.ngettext("book here", "books here", n) end },
    search = { "search", function() return _("Search") end, function() return nil end, function() return "" end },
}
BoardWidgets.LINKS = LINKS

local function fanWidth(cover_h, count)
    local cw = math.floor(cover_h * 2 / 3 + 0.5)
    return cw + math.floor(cw * 0.6 + 0.5) * (math.min(3, count) - 1)
end

local function fan(ctx, books, cover_h)
    local cw = math.floor(cover_h * 2 / 3 + 0.5)
    local step = math.floor(cw * 0.6 + 0.5)
    local list = {}
    for i = 1, math.min(3, #books) do table.insert(list, books[i]) end
    if #list == 0 then return space(1, cover_h) end
    local ring = math.max(1, px(1.5))
    local width = cw + step * (#list - 1)
    -- The first book sits on top at the right. Each cover carries a white ring
    -- drawn outside its box, so the fan measures exactly its covers.
    local layers = {}
    for i = #list, 1, -1 do
        local x = (#list - i) * step
        table.insert(layers, { widget = rect(cw + 2 * ring, cover_h + 2 * ring, BoardColour.halo(ctx, INK.white)), x = x - ring, y = -ring })
        table.insert(layers, { widget = cover(ctx, list[i], cw, cover_h, { border = thin(), border_col = BoardColour.coverEdge(ctx, INK.g9) }), x = x, y = 0 })
    end
    return BoardUI.overlay(width, cover_h, layers)
end

local function formatCount(n)
    if not n then return "" end
    local s = tostring(math.floor(n))
    local out = s:reverse():gsub("(%d%d%d)", "%1,"):reverse()
    return (out:gsub("^,", ""))
end

W.link = function(ctx, w, hh, props)
    local d = ctx.d
    local spec = LINKS[props.link] or LINKS.library
    local pad = px(12)
    local iw = w - 2 * pad
    local ih = hh - 2 * pad
    local n = spec[3](d)
    local label = spec[2]()
    -- The name stays whole: the chevron gives way first, then the icon, then
    -- the name steps down a size or two.
    local function headEl()
        local need = text(label, { s = 13, b = true }):getSize().w
        local icon_w = px(15) + px(5)
        local chevron = w >= px(150) and icon("chevron-right", px(14), { sw = 2.5, col = "g6" }) or nil
        local cw = chevron and (chevron:getSize().w + px(5)) or 0
        if chevron and need > iw - icon_w - cw then chevron, cw = nil, 0 end
        local with_icon = need <= iw - icon_w
        local lab_w = iw - (with_icon and icon_w or 0) - cw
        local size = 13
        while need > lab_w and size > 11 do
            size = size - 1
            need = text(label, { s = size, b = true }):getSize().w
        end
        return hstack({ w = iw, h = lh1(13), gap = px(5) }, {
            with_icon and icon(spec[1], px(15), BoardColour.icon(ctx, 2.25)) or false,
            text(label, { s = size, b = true, w = lab_w }),
            chevron or false,
        })
    end
    local room = ih - lh1(13)
    local val_s = fillSize(room - lh1(11) - px(4), 18, 30)
    local unit = spec[4](n)
    if props.link == "device" then
        local storage = d.storage
        local function count()
            local cs = math.min(val_s, 24)
            local parts = function(size) return { { t = tostring(n or 0), b = true, s = size }, { t = "  " .. unit, col = INK.g4 } } end
            while cs > 16 and runs(parts(cs), { s = 11 }):getSize().w > iw do cs = cs - 2 end
            return runs(parts(cs), { s = 11, w = iw })
        end
        -- The storage bar only on a row with room for it.
        return pick({
            function()
                local items = { headEl(), flex(0), count() }
                if storage then
                    local label2 = text(T(_("%1 GB free"), string.format("%.1f", storage.free_gb):gsub("%.0$", "")), { s = 11, col = INK.g4 })
                    local used = math.floor(100 * (storage.total_gb - storage.free_gb) / storage.total_gb + 0.5)
                    table.insert(items, space(nil, px(5)))
                    table.insert(items, hstack({ w = iw, gap = px(8) }, { bar(iw - label2:getSize().w - px(8), px(6), used, { track = BoardColour.track(ctx, INK.gd), fill = BoardColour.ink(ctx, INK.black), r = px(3) }), label2 }))
                end
                return vstack({ w = w, h = hh, pad = pad }, items)
            end,
            function() return vstack({ w = w, h = hh, pad = pad }, { headEl(), flex(0), count() }) end,
        })
    end
    if props.link == "search" then
        local recents = table.concat(d.recent_searches or {}, ", ")
        local border = math.max(1, px(1.25))
        local variants = {}
        -- Recent searches go first when the tile is short; the field keeps its
        -- placeholder only while it is tall enough to hold the text.
        for _i, with_recents in ipairs(recents ~= "" and { true, false } or { false }) do
            for _j, ph in ipairs({ _("Title, author"), _("Books"), false }) do
                table.insert(variants, function()
                    local below = with_recents and (px(6) + lh1(11)) or 0
                    local field_h = math.min(px(34), room - below - px(4))
                    -- Below 28dp the field is a sliver, not a control.
                    if field_h < px(28) then BoardUI.problem("short", "search field h=" .. field_h) end
                    local field = BoardUI.box({ w = iw, h = field_h, radius = math.floor(field_h / 2), border = border, border_col = INK.g6 },
                        hstack({ w = iw - 2 * border, h = field_h - 2 * border, gap = px(6) }, {
                            space(px(10) - px(6), 1),
                            icon("search", math.min(px(14), field_h - 2 * border), { sw = 2.5, col = "g4" }),
                            ph and text(ph, { s = 12, col = INK.g4 }) or false,
                            flex(0),
                        }))
                    return vstack({ w = w, h = hh, pad = pad }, {
                        headEl(), flex(0), field,
                        with_recents and space(nil, px(6)) or false,
                        with_recents and text(recents, { s = 11, i = true, col = INK.g4, w = iw, data = true }) or false,
                    })
                end)
            end
        end
        -- A short row: the hint (or the recent searches) without a field.
        table.insert(variants, function()
            return vstack({ w = w, h = hh, pad = pad }, {
                headEl(), flex(0),
                text(recents ~= "" and recents or _("Title, author"), { s = 12, i = recents ~= "", col = INK.g4, w = iw, data = true }),
            })
        end)
        return pick(variants)
    end
    local names
    if props.link == "collections" then names = d.names.collections end
    if props.link == "scopes" then names = d.names.scopes end
    if props.link == "authors" then
        names = {}
        local seen = {}
        local pool = {}
        for _i, src in ipairs({ "recently-added", "random" }) do
            for _i, b in ipairs(d.shelves[src] or {}) do table.insert(pool, b) end
        end
        for _i, b in ipairs(pool) do
            local a = firstAuthor(b)
            if a then
                local last = a:match("(%S+)%s*$") or a
                if not seen[last] then seen[last] = true; table.insert(names, last) end
            end
            if #names >= 4 then break end
        end
    end
    if names then
        local function count()
            local cs = math.min(val_s, 24)
            local parts = function(size) return { { t = formatCount(n or 0), b = true, s = size }, { t = "  " .. unit, col = INK.g4 } } end
            while cs > 16 and runs(parts(cs), { s = 11 }):getSize().w > iw do cs = cs - 2 end
            return runs(parts(cs), { s = 11, w = iw })
        end
        -- The names only on a row with room for them.
        return pick({
            function()
                return vstack({ w = w, h = hh, pad = pad }, {
                    headEl(), flex(0), count(),
                    #names > 0 and space(nil, px(4)) or false,
                    #names > 0 and text(table.concat(names, ", "), { s = 12, i = true, serif = true, col = INK.g3, w = iw, data = true }) or false,
                })
            end,
            function() return vstack({ w = w, h = hh, pad = pad }, { headEl(), flex(0), count() }) end,
        })
    end
    local books = props.link == "series" and (d.shelves["up-next-in-series"] or {}) or (d.shelves["recently-added"] or d.shelves["random"] or {})
    local count_col = vstack({}, { text(formatCount(n or 0), { s = val_s, b = true }), text(unit, { s = 11, col = INK.g4 }) })
    local fan_room = iw - count_col:getSize().w - px(8)
    local fh = math.max(px(30), math.min(px(66), room - px(6), math.floor(fan_room / 2.2 * 1.5)))
    -- Rounding can make the fan a pixel wider than its room; past the
    -- smallest covers it holds fewer books, then none.
    local shown = {}
    for i = 1, math.min(3, #books) do shown[i] = books[i] end
    while fh > px(30) and #shown > 0 and fanWidth(fh, #shown) > fan_room do fh = fh - 1 end
    while #shown > 0 and fanWidth(fh, #shown) > fan_room do table.remove(shown) end
    books = shown
    return vstack({ w = w, h = hh, pad = pad }, {
        headEl(), flex(0),
        hstack({ w = iw, valign = "bottom" }, { count_col, flex(px(4)), fan(ctx, books, fh) }),
    })
end

-- ------------------------------------------------------------------ device
W.clock = function(ctx, w, hh)
    local d = ctx.d
    local pad = px(12)
    local iw = w - 2 * pad
    return pick({
        function()
            local val_s = fillSize(hh - 2 * pad - lh1(13) * 2 - px(6), 20, 40)
            while val_s > 20 and text(d.clock, { s = val_s, b = true }):getSize().w > iw do val_s = val_s - 2 end
            return vstack({ w = w, h = hh, pad = pad }, {
                text(d.clock, { s = val_s, b = true, w = iw, col = INK.white }),
                flex(0),
                text(d.weekday, { s = 13, b = true, w = iw, col = INK.white }),
                text(d.day_month, { s = 13, w = iw, col = BoardColour.onInk(ctx, INK.gc) }),
            })
        end,
        -- A short row: the time over the date.
        function()
            local val_s = fillSize(hh - 2 * pad - lh1(13) - px(4), 20, 40)
            while val_s > 20 and text(d.clock, { s = val_s, b = true }):getSize().w > iw do val_s = val_s - 2 end
            return vstack({ w = w, h = hh, pad = pad }, {
                text(d.clock, { s = val_s, b = true, w = iw, col = INK.white }),
                flex(0),
                text(d.day_month, { s = 13, b = true, w = iw, col = INK.white }),
            })
        end,
    })
end

W.sync = function(ctx, w, hh)
    local d = ctx.d
    local pad = px(12)
    local iw = w - 2 * pad
    local on = d.online
    local when = d.last_sync_at and BoardData.relativeDay(os.date("!%Y-%m-%dT%H:%M:%SZ", d.last_sync_at), d.now) or _("not yet")
    local title = on and (d.last_sync_at and _("Synced") or _("Sync")) or _("Offline")
    local opts = on and { { when, 16 }, { when, 14 }, { when, 12 } } or { { T(_("saved %1"), d.updated or ""), 16 }, { T(_("saved %1"), d.updated or ""), 14 }, { d.updated or "", 16 }, { d.updated or "", 13 } }
    local variants = {}
    for _i, o in ipairs(opts) do
        table.insert(variants, function()
            return vstack({ w = w, h = hh, pad = pad }, {
                head(iw, title, icon(on and "cloud-check" or "cloud-off", px(17), BoardColour.icon(ctx, 2.25))),
                flex(0),
                text(o[1], { s = o[2], b = true, w = iw }),
                space(nil, px(6)),
                hstack({ gap = px(5) }, { icon(on and "refresh-cw" or "wifi", px(14), BoardColour.icon(ctx, 2.5)), text(on and _("Sync now") or _("Connect"), { s = 12, b = true }) }),
            })
        end)
    end
    -- A short row: the tile is still the button.
    for _i, o in ipairs(opts) do
        table.insert(variants, function()
            return vstack({ w = w, h = hh, pad = pad }, {
                head(iw, title, icon(on and "cloud-check" or "cloud-off", px(17), BoardColour.icon(ctx, 2.25))),
                flex(0),
                text(o[1], { s = o[2], b = true, w = iw }),
            })
        end)
    end
    return pick(variants)
end

-- Quick settings without opening KOReader's menu.
-- When in the day this reader reads: minutes started in each local hour
-- over the last 90 days, and the part of the day that holds the most.
local DAY_PARTS = {
    { function() return _("Mornings") end, 5, 12 },
    { function() return _("Afternoons") end, 12, 17 },
    { function() return _("Evenings") end, 17, 22 },
    { function() return _("Late nights") end, 22, 29 },
}
local function dayPart(hours)
    local best, best_min = nil, 0
    for _i, part in ipairs(DAY_PARTS) do
        local m = 0
        for hr = part[2], part[3] - 1 do m = m + (hours[hr % 24 + 1] or 0) end
        if m > best_min then best, best_min = part[1](), m end
    end
    return best
end

W.hours = function(ctx, w, hh)
    local d = ctx.d
    local pad = px(12)
    local iw = w - 2 * pad
    local hours = d.hours or {}
    local part = dayPart(hours)
    local function sunMoon() return icon("sun-moon", px(17), BoardColour.icon(ctx, 2.25)) end
    if not part then
        return vstack({ w = w, h = hh, pad = pad }, {
            head(iw, _("When you read"), sunMoon()),
            space(nil, px(6)),
            text(_("Read on this device and your hours show up here."), { s = 13, col = INK.g4, lines = 3, w = iw }),
        })
    end
    local max, peak = 1, 0
    for i = 1, 24 do max = math.max(max, hours[i] or 0) end
    for i = 2, 24 do
        if (hours[i] or 0) > (hours[peak + 1] or 0) then peak = i - 1 end
    end
    local gap = math.max(1, px(2))
    local bar_w = math.max(1, math.floor((iw - 23 * gap) / 24))
    local chart_w = 24 * bar_w + 23 * gap
    local cell_w = 6 * (bar_w + gap)
    local base = math.max(1, px(1))
    local function chart(chart_h)
        local bars = {}
        for i = 1, 24 do
            local v = hours[i] or 0
            if v > 0 then
                local h = math.max(px(2), math.floor((chart_h - px(2)) * v / max + 0.5))
                table.insert(bars, BoardUI.rect(bar_w, h, i - 1 == peak and BoardColour.ink(ctx, INK.black) or BoardColour.mid(ctx, INK.g8)))
            else
                table.insert(bars, space(bar_w, 0))
            end
        end
        return vstack({ w = chart_w }, {
            hstack({ w = chart_w, h = chart_h - base, gap = gap, valign = "bottom" }, bars),
            rect(chart_w, base, INK.black),
        })
    end
    local function axis()
        local cells = {}
        for i, t in ipairs({ "0", "6", "12", "18" }) do
            table.insert(cells, text(t, { s = 11, col = INK.g4, w = i < 4 and cell_w or chart_w - 3 * cell_w }))
        end
        return hstack({ w = chart_w }, cells)
    end
    local peak_label = T(_("Most at %1"), datetime.secondsToHour(BoardData.dayStart(d.now or os.time()) + peak * 3600,
        G_reader_settings:isTrue("twelve_hour_clock")))
    local min_chart = px(12)
    local box = { w = w, h = hh, pad = pad }
    local variants = {}
    -- Tall: the part of the day large, the peak hour under it, then the bars.
    local tall_h = hh - 2 * pad - lh1(13) - px(4) - lh1(20) - px(2) - lh1(12) - px(10) - px(4) - lh1(11)
    if tall_h >= px(40) then
        table.insert(variants, function()
            return vstack(box, {
                head(iw, _("When you read"), sunMoon()),
                space(nil, px(4)),
                text(part, { s = 20, b = true, w = iw }),
                space(nil, px(2)),
                text(peak_label, { s = 12, col = INK.g4, w = iw }),
                space(nil, px(10)),
                chart(tall_h),
                space(nil, px(4)),
                axis(),
            })
        end)
    end
    -- One row: the part of the day beside the title.
    local beside_h = hh - 2 * pad - lh1(13) - px(8) - px(4) - lh1(11)
    if beside_h >= min_chart then
        table.insert(variants, function()
            return vstack(box, {
                head(iw, _("When you read"), text(part, { s = 13, b = true })),
                space(nil, px(8)),
                chart(beside_h),
                space(nil, px(4)),
                axis(),
            })
        end)
    end
    table.insert(variants, function()
        return vstack(box, {
            head(iw, _("When you read"), text(part, { s = 13, b = true })),
            space(nil, px(8)),
            chart(math.max(min_chart, hh - 2 * pad - lh1(13) - px(8))),
        })
    end)
    return pick(variants)
end

-- Session records from this device's statistics.
W.records = function(ctx, w, hh)
    local d = ctx.d
    local r = d.records
    local pad = px(12)
    local iw = w - 2 * pad
    local function award() return icon("award", px(17), BoardColour.icon(ctx, 2.25)) end
    if not r then
        return vstack({ w = w, h = hh, pad = pad }, {
            head(iw, _("Reading records"), award()),
            space(nil, px(6)),
            hint(_("Your records appear as you read on this device."), iw, hh - 2 * pad - lh1(13) - px(6)),
        })
    end
    local function stats(short)
        local dur = short and BoardData.formatShortDuration or BoardData.formatDuration
        return {
            { dur(r.longest_min), _("longest session") },
            { tostring(r.pages_per_hour), _("pages an hour") },
            { dur(r.avg_min), _("average session") },
            { formatCount(r.sessions), _("sessions") },
        }
    end
    local function cell(st, cw, vs)
        return vstack({ w = cw }, {
            text(st[1], { s = vs, b = true, w = cw }),
            space(nil, px(2)),
            text(st[2], { s = 11, col = INK.g4, w = cw }),
        })
    end
    local g = px(12)
    local half = math.floor((iw - g) / 2)
    local variants = {}
    -- Two by two when the tile is tall enough, else one row of two.
    for _i, v in ipairs({ { 22, false }, { 20, true }, { 18, true } }) do
        table.insert(variants, function()
            local st = stats(v[2])
            return vstack({ w = w, h = hh, pad = pad }, {
                head(iw, _("Reading records"), award()),
                flex(px(8)),
                hstack({ gap = g, valign = "top" }, { cell(st[1], half, v[1]), cell(st[2], iw - half - g, v[1]) }),
                flex(px(10)),
                hstack({ gap = g, valign = "top" }, { cell(st[3], half, v[1]), cell(st[4], iw - half - g, v[1]) }),
            })
        end)
    end
    for _i, v in ipairs({ { 20, false }, { 18, true }, { 16, true }, { 14, true }, { 13, true } }) do
        table.insert(variants, function()
            local st = stats(v[2])
            return vstack({ w = w, h = hh, pad = pad }, {
                head(iw, _("Reading records"), award()),
                flex(px(v[1] <= 14 and 4 or 6)),
                hstack({ gap = g, valign = "top" }, { cell(st[1], half, v[1]), cell(st[2], iw - half - g, v[1]) }),
            })
        end)
    end
    return pick(variants)
end

W.toggles = function(ctx, w, hh)
    local d = ctx.d
    local pad = px(10)
    local iw, ih = w - 2 * pad, hh - 2 * pad
    local small = w < px(200)
    -- A row of five whose labels do not fit even at 10 is drawn as the grid.
    local label_s
    if not small then
        local names = { _("Wi-Fi"), _("Light"), _("Night"), _("Rotate"), _("Sync") }
        local cw5 = math.floor(iw / (d.light ~= nil and 5 or 4))
        for _i, size in ipairs({ 12, 11, 10 }) do
            local widest = 0
            for _j, name in ipairs(names) do
                local t = text(name, { s = size, b = true })
                widest = math.max(widest, t:getSize().w)
                if t.free then t:free() end
            end
            if widest <= cw5 - px(2) then label_s = size; break end
        end
        small = label_s == nil
    end
    -- Light opens KOReader's brightness dialog. In the 2x2 grid it takes
    -- Rotate's place, the least used of the five.
    local has_light = d.light ~= nil
    local items = { { "wifi", _("Wi-Fi"), d.online, "wifi" } }
    if has_light then table.insert(items, { "sun", _("Light"), false, "frontlight" }) end
    table.insert(items, { "moon", _("Night"), G_reader_settings:isTrue("night_mode"), "night" })
    if not (has_light and small) then table.insert(items, { "rotate-cw-square", _("Rotate"), false, "rotate" }) end
    table.insert(items, { "refresh-cw", _("Sync"), false, "sync" })
    local function circleBtn(size, it)
        local on = it[3]
        return BoardUI.hit(BoardUI.circle(size, { bg = on and BoardColour.ink(ctx, INK.black) or INK.white, border = on and 0 or math.max(1, px(1.5)) },
            icon(it[1], math.floor(size * 0.46 + 0.5), { col = on and "white" or "black", sw = 2.25 })), { kind = it[4] })
    end
    if small then
        local bd = math.min(math.floor((iw - px(8)) / 2), math.floor((ih - px(8)) / 2))
        return vstack({ w = w, h = hh, align = "center" }, {
            flex(0),
            hstack({ gap = px(8) }, { circleBtn(bd, items[1]), circleBtn(bd, items[2]) }),
            space(nil, px(8)),
            hstack({ gap = px(8) }, { circleBtn(bd, items[3]), circleBtn(bd, items[4]) }),
            flex(0),
        })
    end
    local cw = math.floor(iw / #items)
    local bd = math.min(px(44), ih - lh1(12) - px(6), cw - px(8))
    local cells = {}
    for _i, it in ipairs(items) do
        table.insert(cells, vstack({ w = cw, align = "center" }, {
            circleBtn(bd, it),
            space(nil, px(5)),
            text(it[2], { s = label_s, b = it[3], w = cw, align = "center" }),
        }))
    end
    return hstack({ w = w, h = hh }, { space(pad, 1), hstack({}, cells), flex(0) })
end

-- Frontlight and warmth, set without leaving the dashboard.
local function stepButton(d, name)
    return BoardUI.circle(d, { bg = INK.white, border = math.max(1, px(1.5)) }, icon(name, math.floor(d * 0.5 + 0.5), { sw = 2.75 }))
end
BoardWidgets.stepButton = stepButton

W.light = function(ctx, w, hh)
    local lt = ctx.d.light
    local pad = px(12)
    local iw, ih = w - 2 * pad, hh - 2 * pad
    if not lt then
        return vstack({ w = w, h = hh, pad = pad }, {
            head(iw, _("Light"), icon("sun", px(16), BoardColour.icon(ctx, 2.25))),
            space(nil, px(6)),
            hint(_("This device has no frontlight."), iw, hh - 2 * pad - lh1(13) - px(6), { sizes = { 12, 11 } }),
        })
    end
    local function compact(bd, s)
        return function()
            return vstack({ w = w, h = hh, pad = pad }, {
                head(iw, _("Light"), icon("sun", px(16), BoardColour.icon(ctx, 2.25))),
                flex(0),
                hstack({ w = iw }, {
                    BoardUI.hit(stepButton(bd, "minus"), { kind = "light", what = "brightness", delta = -5 }),
                    flex(px(4)), text(lt.brightness .. "%", { s = s, b = true }), flex(px(4)),
                    BoardUI.hit(stepButton(bd, "plus"), { kind = "light", what = "brightness", delta = 5 }),
                }),
            })
        end
    end
    local function full(with_label)
        return function()
            local rows_n = lt.warmth and 2 or 1
            local avail = ih - lh1(13) - px(6)
            local rh = math.min(px(38), math.floor((avail - (rows_n - 1) * px(5)) / rows_n))
            local bd = math.min(px(32), rh)
            local function stepper(name, val, what, fam)
                local vw = px(36)
                local bw = iw - px(18) - 2 * bd - vw - 4 * px(8)
                return hstack({ w = iw, h = rh, gap = px(8) }, {
                    icon(name, px(18), BoardColour.icon(ctx, 2.25, fam)),
                    BoardUI.hit(stepButton(bd, "minus"), { kind = "light", what = what, delta = -5 }),
                    bar(math.max(px(16), bw), px(8), val, { track = BoardColour.track(ctx, INK.gd, fam), fill = BoardColour.ink(ctx, INK.black, fam), r = px(4) }),
                    BoardUI.hit(stepButton(bd, "plus"), { kind = "light", what = what, delta = 5 }),
                    text(tostring(val), { s = 13, b = true, w = vw, align = "right" }),
                })
            end
            local label = rows_n == 2 and _("Brightness · Warmth") or _("Brightness")
            return vstack({ w = w, h = hh, pad = pad }, {
                head(iw, _("Light"), with_label and text(label, { s = 12, col = INK.g4 }) or nil),
                flex(0),
                stepper("sun", lt.brightness, "brightness", "gold"),
                rows_n == 2 and space(nil, px(5)) or false,
                rows_n == 2 and stepper("thermometer-sun", lt.warmth, "warmth", "orange") or false,
            })
        end
    end
    return pick({ full(true), full(false), compact(px(32), 20), compact(px(28), 17), compact(px(24), 15), compact(px(22), 13) })
end

-- ------------------------------------------------------------ new widgets
-- Finish forecast: when the current book ends at the reader's own pace.
W.forecast = function(ctx, w, hh)
    local d = ctx.d
    local f = d.forecast
    local pad = px(12)
    local iw, ih = w - 2 * pad, hh - 2 * pad
    local tall = hh >= px(160)
    if not f then
        local variants = {}
        for _i, long in ipairs({ true, false }) do
            table.insert(variants, function()
                return vstack({ w = w, h = hh, pad = pad }, {
                    head(iw, long and _("Finish forecast") or _("Finish"), icon("hourglass", px(16), BoardColour.icon(ctx, 2.25))),
                    space(nil, px(6)),
                    text(long and _("Read a little on this device and a finish date shows up here.") or _("Read a little"), { s = 13, col = INK.g4, lines = 3, w = iw }),
                })
            end)
        end
        return pick(variants)
    end
    local function strip(tw)
        local n = math.min(8, f.days_out + 1)
        local g = px(4)
        local cw = math.floor((tw - (n - 1) * g) / n)
        local cells = {}
        for i = 1, n do
            local is_end, is_today = i == n, i == 1
            local t = d.now + (i - 1) * 86400
            table.insert(cells, vstack({ w = cw, align = "center" }, {
                rect(cw, px(8), is_end and BoardColour.ink(ctx, INK.black) or (is_today and BoardColour.mid(ctx, INK.g6) or BoardColour.track(ctx, INK.gc)), px(4)),
                space(nil, px(3)),
                text(BoardData.shortWeekday(t):sub(1, 1), { s = 11, b = is_end or is_today, col = (is_end or is_today) and INK.black or INK.g4, w = cw, align = "center" }),
            }))
        end
        return hstack({ gap = g }, cells)
    end
    local function bottomText(level)
        if level == 2 then return T(_("%1 left at ~%2 min a day"), BoardData.formatDuration(f.minutes_left), math.floor(f.per_day + 0.5)) end
        if level == 1 then return T(_("%1 left"), BoardData.formatDuration(f.minutes_left)) end
        if level == 0 then return T(_("%1 left"), BoardData.formatShortDuration(f.minutes_left)) end
    end
    local function dayEl(fmt, tw)
        if fmt == "long" then
            return runs({ { t = f.day, b = true, s = tall and 26 or 22 }, { t = "  " .. f.date, col = INK.g4 } }, { s = 13, w = tw })
        elseif fmt == "mid" then
            return text(f.day, { s = 22, b = true, w = tw })
        end
        return text(f.short .. " " .. f.date:match("^(%d+)"), { s = 20, b = true, w = tw })
    end
    local function build(cfg)
        return function()
            local bottom = cfg.bottom >= 0 and text(bottomText(cfg.bottom), { s = 12, col = INK.g4, w = iw }) or nil
            if cfg.cover == "side" then
                local cover_w = math.floor(ih * 2 / 3 + 0.5)
                local tw = iw - cover_w - px(12)
                return hstack({ w = w, h = hh, valign = "top" }, {
                    space(pad, 1),
                    vstack({ w = tw, h = hh, pad = { pad, 0, pad, 0 } }, {
                        head(tw, cfg.label, nil),
                        flex(0),
                        dayEl(cfg.day, tw),
                        cfg.strip and space(nil, px(8)) or false, cfg.strip and strip(tw) or false,
                        cfg.bottom >= 0 and space(nil, px(4)) or false,
                        cfg.bottom >= 0 and text(bottomText(cfg.bottom), { s = 12, col = INK.g4, w = tw }) or false,
                    }),
                    space(px(12), 1),
                    vstack({ w = cover_w, h = hh, pad = { pad, 0, pad, 0 } }, { cover(ctx, f.book, cover_w, ih) }),
                    flex(0),
                })
            end
            if cfg.cover == "stack" then
                local cover_h = math.min(px(96), math.floor(ih * 0.48 + 0.5))
                local cover_w = math.floor(cover_h * 2 / 3 + 0.5)
                local tw = iw - cover_w - px(12)
                return vstack({ w = w, h = hh, pad = pad }, {
                    head(iw, cfg.label, icon("hourglass", px(16), BoardColour.icon(ctx, 2.25))),
                    space(nil, px(8)),
                    hstack({ gap = px(12), valign = "bottom" }, {
                        cover(ctx, f.book, cover_w, cover_h),
                        vstack({ w = tw }, { text(f.day, { s = 24, b = true, w = tw }), text(f.date, { s = 13, col = INK.g4, w = tw }) }),
                    }),
                    flex(px(6)),
                    cfg.strip and strip(iw) or false,
                    bottom and space(nil, px(6)) or false,
                    bottom or false,
                })
            end
            return vstack({ w = w, h = hh, pad = pad }, {
                head(iw, cfg.label, icon("hourglass", px(16), BoardColour.icon(ctx, 2.25))),
                flex(0),
                dayEl(cfg.day, iw),
                cfg.strip and space(nil, px(8)) or false, cfg.strip and strip(iw) or false,
                bottom and space(nil, px(4)) or false,
                bottom or false,
            })
        end
    end
    local L1, L2 = _("Finish forecast"), _("Finish")
    local cfgs = {
        { cover = "side", strip = tall, day = "long", bottom = 2, label = L1 },
        { cover = "side", strip = tall, day = "long", bottom = 1, label = L1 },
        { cover = "stack", strip = tall, day = "long", bottom = 2, label = L1 },
        { cover = "stack", strip = tall, day = "long", bottom = 1, label = L1 },
        { cover = "none", strip = tall, day = "long", bottom = 2, label = L1 },
        { cover = "none", strip = tall, day = "long", bottom = 1, label = L1 },
        { cover = "side", strip = false, day = "mid", bottom = 1, label = L2 },
        { cover = "none", strip = tall, day = "mid", bottom = 0, label = L2 },
        { cover = "none", strip = false, day = "short", bottom = 0, label = L2 },
        { cover = "none", strip = false, day = "short", bottom = -1, label = L2 },
    }
    local variants = {}
    for _i, cfg in ipairs(cfgs) do
        if cfg.cover ~= "stack" or tall then table.insert(variants, build(cfg)) end
    end
    return pick(variants)
end

-- A word looked up while reading, with the sentence it came from.
W.word = function(ctx, w, hh)
    local wd = ctx.d.word
    local pad = px(12)
    local iw = w - 2 * pad
    local word_icon = icon("whole-word", px(17), BoardColour.icon(ctx, 2.25))
    if not wd then
        local variants = {}
        for _i, long in ipairs({ true, false }) do
            table.insert(variants, function()
                return vstack({ w = w, h = hh, pad = pad }, {
                    head(iw, _("Word of the day"), word_icon),
                    space(nil, px(6)),
                    text(long and _("Look up a word while reading and one comes back here each day.") or _("Look up a word while reading."), { s = 13, col = INK.g4, lines = 3, w = iw }),
                })
            end)
        end
        return pick(variants)
    end
    local context = "\u{2026}" .. (wd.before or "") .. wd.word .. (wd.after or "") .. "\u{2026}"
    local tall = hh >= px(170)
    local function build(cfg)
        return function()
            local items = {
                head(iw, _("Word of the day"), word_icon),
                space(nil, px(cfg.big and 10 or 4)),
                text(wd.word, { s = cfg.ws, b = true, serif = true, w = iw, data = true, col = BoardColour.ink(ctx, INK.black) }),
            }
            if cfg.ctx_lines > 0 then
                table.insert(items, space(nil, px(4)))
                table.insert(items, text(context, { s = 14, i = true, serif = true, lines = cfg.ctx_lines, w = iw, col = INK.g2, data = true }))
            end
            table.insert(items, flex(px(cfg.source and 6 or 0)))
            if cfg.source and wd.book then
                table.insert(items, text(wd.book, { s = 11, col = INK.g4, w = iw, data = true }))
            end
            return vstack({ w = w, h = hh, pad = pad }, items)
        end
    end
    local cfgs = tall and {
        { big = true, ws = 28, ctx_lines = 5, source = true },
        { big = true, ws = 28, ctx_lines = 4, source = true },
        { big = false, ws = 24, ctx_lines = 3, source = true },
        { big = false, ws = 24, ctx_lines = 2, source = false },
        { big = false, ws = 22, ctx_lines = 0, source = false },
    } or {
        { ws = 22, ctx_lines = 2, source = false },
        { ws = 22, ctx_lines = 1, source = false },
        { ws = 20, ctx_lines = 1, source = false },
        { ws = 20, ctx_lines = 0, source = false },
    }
    local variants = {}
    for _i, cfg in ipairs(cfgs) do table.insert(variants, build(cfg)) end
    return pick(variants)
end

-- What you were reading this time last year.
W.yearago = function(ctx, w, hh)
    local y = ctx.d.year_ago
    local pad = px(12)
    local iw, ih = w - 2 * pad, hh - 2 * pad
    local cal = icon("calendar-clock", px(17), BoardColour.icon(ctx, 2.25))
    if not y then
        local variants = {}
        for _i, long in ipairs({ true, false }) do
            table.insert(variants, function()
                return vstack({ w = w, h = hh, pad = pad }, {
                    head(iw, _("A year ago"), cal),
                    space(nil, px(6)),
                    text(long and _("Next year, this shows what you were reading today.") or _("Check back next year."), { s = 13, col = INK.g4, lines = 3, w = iw }),
                })
            end)
        end
        return pick(variants)
    end
    local tall = hh >= px(170)
    local function short(detail)
        return function()
            local cover_w = math.floor(ih * 2 / 3 + 0.5)
            local tw = iw - cover_w - px(12)
            local lines = {
                [2] = y.stopped_at and (T(_("Stopped at %1%"), y.stopped_at) .. " · " .. BoardData.formatShortDuration(y.minutes)) or BoardData.formatShortDuration(y.minutes),
                [1] = y.stopped_at and T(_("Stopped at %1%"), y.stopped_at) or BoardData.formatShortDuration(y.minutes),
                [0] = y.stopped_at and T(_("%1% read"), y.stopped_at) or "",
            }
            return hstack({ w = w, h = hh }, {
                space(pad, 1),
                cover(ctx, y.book, cover_w, ih),
                space(px(12), 1),
                vstack({ w = tw, h = ih }, {
                    head(tw, _("A year ago"), nil),
                    flex(0),
                    text(y.book.title, { s = 15, b = true, w = tw, data = true }),
                    text(lines[detail], { s = 12, col = INK.g4, w = tw }),
                }),
                flex(0),
            })
        end
    end
    if not tall then return pick({ short(2), short(1), short(0) }) end
    local function big(cfg)
        return function()
            local body_h = ih - lh1(13) - px(10)
            local cover_h = math.min(body_h, px(cfg.cover_max))
            local cover_w = math.floor(cover_h * 2 / 3 + 0.5)
            local tw = iw - cover_w - px(14)
            local btn_h = px(34)
            local btn_inner = hstack({ h = btn_h, gap = px(6) }, { space(px(14) - px(6), 1), icon("book-open", px(15), { sw = 2.25 }), text(_("Pick it up"), { s = 13, b = true }), space(px(14) - px(6), 1) })
            local btn = BoardUI.box({ w = btn_inner:getSize().w, h = btn_h, radius = math.floor(btn_h / 2), border = math.max(1, px(1.5)) }, btn_inner)
            local story = cfg.story and T(_.ngettext("%1 over %2 day, then you stopped at %3%.", "%1 over %2 days, then you stopped at %3%.", y.days), BoardData.formatDuration(y.minutes), y.days, y.stopped_at or 0)
                or T(_("Stopped at %1%."), y.stopped_at or 0)
            return vstack({ w = w, h = hh, pad = pad }, {
                head(iw, _("A year ago"), cfg.when and y.when and text(y.when, { s = 12, col = INK.g4 }) or nil),
                space(nil, px(10)),
                hstack({ w = iw, h = body_h, gap = px(14), valign = "top" }, {
                    cover(ctx, y.book, cover_w, cover_h),
                    vstack({ w = tw, h = body_h }, {
                        text(y.book.title, { s = 17, b = true, lines = 2, w = tw, data = true }),
                        text(firstAuthor(y.book) or "", { s = 13, col = INK.g4, w = tw, data = true }),
                        space(nil, px(8)),
                        text(story, { s = 13, lines = 3, w = tw }),
                        flex(px(8)),
                        cfg.button and btn or false,
                    }),
                }),
            })
        end
    end
    return pick({
        big({ cover_max = 150, when = true, story = true, button = true }),
        big({ cover_max = 130, when = true, story = true, button = true }),
        big({ cover_max = 130, when = false, story = true, button = true }),
        big({ cover_max = 120, when = false, story = false, button = true }),
        big({ cover_max = 120, when = false, story = false, button = false }),
        short(1),
    })
end

-- ------------------------------------------------------------------ chrome
-- Tile styles: Outline (thin gray, the default), Soft (gray fills) and Ink
-- (black outlines). Black fill stays reserved for Continue reading.
function BoardWidgets.chrome(tiles, chrome)
    local r = px(12)
    if chrome == "ink" then return { bg = INK.black, radius = r, border = 0, fg = "white" } end
    if chrome == "fill" then return { bg = tiles == "soft" and INK.gd or INK.ge, radius = r, border = 0 } end
    if tiles == "soft" then return { bg = INK.ge, radius = r, border = 0 } end
    if tiles == "ink" then return { bg = INK.white, radius = r, border = math.max(1, px(1.5)), border_col = INK.black } end
    return { bg = INK.white, radius = r, border = math.max(1, px(1)), border_col = INK.g8 }
end

-- The tile: chrome around a widget's content, built at exactly w x h. The
-- content gets the whole tile and the outline is drawn over its padding, so
-- the outline never costs the content any room.
function BoardWidgets.tile(ctx, item, w, h)
    local fn = W[item.type]
    ctx.tile_key = BoardColour.keyFor(item.type, item.props)
    local ch = BoardColour.chrome(ctx, item.chrome, ctx.tile_key, BoardWidgets.chrome(ctx.tiles, item.chrome), math.max(1, px(1)), math.max(1, px(1.5)))
    local content
    if fn then
        BoardUI.debug_widget = item.type .. " " .. w .. "x" .. h
        local props = item.props or {}
        local sig = BoardWidgets.SIG[item.type]
        local sig_ok, extra = true, ""
        if sig and ctx.d then sig_ok, extra = pcall(sig, ctx) end
        BoardUI.pickScope(item.type .. ":" .. tostring(props.source or props.link or props.animal or "") .. ":" .. w .. "x" .. h .. ":" .. tostring(ch.bg)
            .. ":" .. (sig_ok and tostring(extra) or ""), ctx.d and ctx.d.fingerprint)
        local surface = BoardUI.surface
        BoardUI.surface = ch.bg
        local ok, result = pcall(fn, ctx, w, h, props, item)
        BoardUI.surface = surface
        BoardUI.pickScope(nil, ctx.d and ctx.d.fingerprint)
        content = ok and result or text(_("Could not draw this widget."), { s = 12, col = INK.g4, w = w - 2 * px(12) })
        if not ok then require("logger").warn("BookOrbit: widget", item.type, "failed:", result) end
    end
    local layers = {
        { widget = BoardUI.box({ w = w, h = h, radius = ch.radius, bg = ch.bg }) },
        { widget = content },
    }
    if ch.border > 0 then
        table.insert(layers, { widget = BoardUI.box({ w = w, h = h, radius = ch.radius, border = ch.border, border_col = ch.border_col }) })
    end
    return BoardUI.overlay(w, h, layers)
end

-- ------------------------------------------------------------------- decor
-- The decor widgets (bookorbit_board_decor) load the first time a board
-- draws or offers one.
local DECOR_TYPES = { buddy = true, analog = true, moon = true, odometer = true, glyph = true, rings = true, chapters = true, badge = true, dust = true }
local function decor()
    local Decor = require("bookorbit_board_decor")
    if not rawget(W, "buddy") then Decor.install(W, { head = head, formatCount = formatCount }) end
    return Decor
end
setmetatable(W, { __index = function(t, k)
    if DECOR_TYPES[k] then
        decor()
        return rawget(t, k)
    end
end })
BoardWidgets.SIG = setmetatable({}, { __index = function(_t, k)
    if DECOR_TYPES[k] then return decor().SIG[k] end
end })

return BoardWidgets