TREK/shared/src/book/auto/auto-book.ts

import { bookElementId } from '../book-ids';
import { blankBook, blankSpread } from '../book-pages';
import { MAX_BOOK_TITLE, type BookDocument, type BookPageSetup, type BookSpread } from '../book.schema';
import type { JourneyStats } from '../journey-stats.schema';
import {
  STATIONS_PER_PAGE,
  backSpread,
  countriesSpread,
  coverSpread,
  stationsSpread,
  summarySpread,
} from './auto-book-spreads';
import { countryNames, isPano, type NewId } from './auto-elements';
import {
  bandSpread,
  gallerySpread,
  immersiveSpread,
  panelSpread,
  panoSpread,
  placeSpread,
  storySpread,
  type EntryContext,
} from './auto-spreads';
import { applyAutoTemplate, autoTemplateFit } from './auto-template-apply';
import { AUTO_TEMPLATES } from './auto-templates.data';
import type { AutoEntry, AutoInput, AutoPhoto } from './auto-types';

/**
 * The auto mode: turn a journey into a book.
 *
 * The one rule that shapes everything else is that this produces an ordinary
 * document. There is no "auto layout" state that locks, no template engine
 * that re-runs behind the user's back: it lays the pages out once, and from
 * that moment every element is as editable as one dragged in by hand.
 *
 * Templates are chosen by what the material actually is: how many photos the
 * entry has, whether they are portrait or landscape, how much story there is
 * to set. Moved here from the Studio (client/src/components/Studio/autoLayout.ts)
 * so the Studio and the server's design tool lay a book out the same way;
 * `auto-layout.parity.spec.ts` holds the move to the old code's output.
 */

const idsOf = (input: AutoInput): NewId => input.newId ?? bookElementId;

/**
 * Whether an entry has anything to fill a spread with. A journey built from a
 * trip starts as one skeleton entry per stop: a date, a place name, nothing
 * else. Those share a list rather than taking a spread each.
 */
export function autoEntryHasSubstance(entry: AutoEntry): boolean {
  return entry.photos.length > 0 || !!(entry.story || '').trim();
}

/**
 * A hand-drawn template for this entry, if one of them fits. Tried before the
 * layouts written as code: a page somebody designed beats a page a function
 * reasoned its way to. Rotated by position so a run of similar entries does
 * not come out as a run of identical pages.
 */
function templateSpread(entry: AutoEntry, input: AutoInput, index: number, newId: NewId): BookSpread | null {
  const templates = input.templates ?? AUTO_TEMPLATES;
  const scored = templates
    .map((t) => ({ t, fit: autoTemplateFit(t, entry) }))
    .filter((x) => x.fit >= 0)
    .sort((a, b) => b.fit - a.fit);
  const best = scored[0];
  if (!best) return null;
  // Everything within a few points of the best is equally suitable, so the position picks between them.
  const equals = scored.filter((x) => x.fit >= best.fit - 5);
  const pick = equals[index % equals.length] ?? best;
  const ctx = { page: input.page, locale: input.locale, stats: input.stats, dayLabel: input.dayLabel, newId };
  return applyAutoTemplate(pick.t, entry, ctx);
}

/**
 * One entry, one spread: a drawn template when one fits, else one of the
 * layouts written as code, by contents first (a panorama wants the fold, a
 * stop with nothing said about it wants the place page) and then by position.
 * The full-bleed page is kept to every sixth and never the first.
 */
function entrySpread(entry: AutoEntry, input: AutoInput, index: number, newId: NewId): BookSpread {
  const hand = index % 2 === 0 ? 'left' : 'right';
  const photos = entry.photos.slice(0, 5);
  const withPhotos = { ...entry, photos };
  const c: EntryContext = { entry: withPhotos, input, index, hand, newId };
  const story = (entry.story || '').trim();

  const fromTemplate = templateSpread(withPhotos, input, index, newId);
  if (fromTemplate) return fromTemplate;
  if (photos.length === 0 && !story) return placeSpread(c);
  const first = photos[0];
  if (first && isPano(first)) return panoSpread(c);
  switch (index % 6) {
    case 0:
      return photos.length > 1 ? gallerySpread(c) : storySpread(c);
    case 1:
      return panelSpread(c);
    case 2:
      return photos.length > 2 ? bandSpread(c) : storySpread(c);
    case 3:
      return photos.length ? immersiveSpread(c) : panelSpread(c);
    case 4:
      return photos.length > 1 ? bandSpread(c) : panelSpread(c);
    default:
      return photos.length > 1 ? gallerySpread(c) : storySpread(c);
  }
}

/**
 * The page setup for a book that opens on a single page: the first page
 * inside the covers is page 1 (#2317). Nothing else of the setup is touched.
 */
function withFirstPage(page: BookPageSetup): BookPageSetup {
  return { ...page, pageNumbers: { ...page.pageNumbers, startAt: 1 } };
}

/** The spreads the entries make: one each for entries with substance, a shared list for runs of bare ones. */
function entrySpreads(input: AutoInput, newId: NewId): BookSpread[] {
  const out: BookSpread[] = [];
  let laid = 0;
  let run: AutoEntry[] = [];
  const flushRun = () => {
    for (let i = 0; i < run.length; i += STATIONS_PER_PAGE * 2) {
      out.push(stationsSpread(run.slice(i, i + STATIONS_PER_PAGE * 2), input, newId));
    }
    run = [];
  };
  for (const entry of input.entries) {
    if (autoEntryHasSubstance(entry)) {
      flushRun();
      out.push(entrySpread(entry, input, laid++, newId));
    } else {
      run.push(entry);
    }
  }
  flushRun();
  return out;
}

/**
 * The whole book: the cover, the first page, the journey at a glance and its
 * countries (both left out when the journey has nothing to say with them),
 * the entries in the order they happened, the last page and the back cover.
 */
export function buildBook(input: AutoInput): BookDocument {
  const newId = idsOf(input);
  const spreads: BookSpread[] = [coverSpread(input, newId), blankSpread('first', newId)];
  const summary = summarySpread(input, newId);
  if (summary) spreads.push(summary);
  const countries = countriesSpread(input, countryNames(input), newId);
  if (countries) spreads.push(countries);
  spreads.push(...entrySpreads(input, newId));
  spreads.push(blankSpread('last', newId), backSpread(input, newId));
  return {
    version: 1,
    title: input.title.slice(0, MAX_BOOK_TITLE),
    page: withFirstPage(input.page),
    spreads,
  };
}

/**
 * A book nobody has laid out yet: what a journey with no book opens on. The
 * layout is offered, not applied; the same blank book `create_book` writes.
 */
export function emptyBook(input: AutoInput): BookDocument {
  return blankBook({ title: input.title, page: input.page, newId: idsOf(input) });
}

/**
 * Lay one spread out again, from the entry it came from, keeping its id so the
 * pages rail does not jump. Null for a spread that has no entry behind it (the
 * covers, the summary, anything added by hand): there is nothing to rebuild it
 * from, and replacing it with a blank page would be worse than refusing.
 */
export function relayoutSpread(spread: BookSpread, input: AutoInput): BookSpread | null {
  if (spread.role !== 'inner' || spread.entryId == null) return null;
  const entry = input.entries.find((e) => e.id === spread.entryId);
  if (!entry) return null;
  const index = input.entries.indexOf(entry);
  return { ...entrySpread(entry, input, index < 0 ? 0 : index, idsOf(input)), id: spread.id };
}

/**
 * Hand the journey's loose gallery photos to the entries. Photos that already
 * sit on an entry stay there; the rest are shared out in order, so a book
 * built from a journey whose pictures all live in the gallery still gets
 * pictures on its pages.
 */
export function distributeGallery(entries: AutoEntry[], gallery: readonly AutoPhoto[]): AutoEntry[] {
  const taken = new Set(entries.flatMap((e) => e.photos.map((p) => p.photoId)));
  const loose = gallery.filter((p) => !taken.has(p.photoId));
  if (!loose.length || !entries.length) return entries;
  const per = Math.max(1, Math.floor(loose.length / entries.length));
  let i = 0;
  return entries.map((e, idx) => {
    if (e.photos.length >= 4) return e;
    const want = Math.min(4 - e.photos.length, idx === entries.length - 1 ? loose.length - i : per);
    const slice = loose.slice(i, i + Math.max(0, want));
    i += slice.length;
    return { ...e, photos: [...e.photos, ...slice] };
  });
}

/**
 * Give every entry what the journey's figures know about its stop: the
 * coordinates and country its place resolved to, and which day of the
 * journey it is. Matched by date first and by name second, because a day
 * usually has one stop and two stops on one day are told apart by name.
 */
export function autoEntriesWithStops(entries: readonly AutoEntry[], stats: JourneyStats | null): AutoEntry[] {
  const points = stats?.points ?? [];
  const dayCount = stats?.days ?? null;
  // Calendar days counted in UTC: a local midnight would lose a day across a change to summer time.
  const first = stats?.start ? Date.parse(`${stats.start}T00:00:00Z`) : Number.NaN;
  return entries.map((entry) => {
    const byDate = points.find((p) => p.date && entry.date && p.date === entry.date);
    const point = byDate ?? points.find((p) => p.label && entry.location && p.label === entry.location);
    const at = entry.date ? Date.parse(`${entry.date}T00:00:00Z`) : Number.NaN;
    const known = Number.isFinite(at) && Number.isFinite(first);
    const dayNumber = known ? Math.floor((at - first) / 86_400_000) + 1 : null;
    return {
      ...entry,
      lat: point?.lat ?? null,
      lng: point?.lng ?? null,
      country: point?.country ?? null,
      dayNumber: dayNumber && dayNumber > 0 ? dayNumber : null,
      dayCount,
    };
  });
}