Filling

/**
 * Filling cells from the cells beside them: a block dragged out by its corner,
 * or told to fill down or to the side.
 *
 * - A fill runs along one axis: down or up the rows, or along the columns —
 *   whichever the place dragged to lies furthest beyond the block in.
 * - What fills is the block's own cells, repeated in their order, so that a
 *   block filled by itself tiles: backwards as well as forwards.
 * - Numbers and dates continue instead, when there is one way to continue them
 *   and no other: at least two of them, a constant step apart. Anything else —
 *   one value, a gap, steps that differ, dates that are as many days apart as
 *   they are months — is repeated. A fill never guesses.
 */
import { dateOfDay, dayNumber } from "./calendar.ts";
import type { Bounds, Cell } from "./grid-selection.ts";

export interface FillTarget {
  /** The cells to fill: beside the block, and none of its own. */
  readonly bounds: Bounds;
  /** Whether the fill runs through the rows, or through the columns. */
  readonly axis: "rows" | "columns";
  /** Onward from the block's end, or back from its start. */
  readonly forward: boolean;
}

/** The cells a block fills when its corner is dragged to `to`, or `null` while that is within the block. */
export function fillTarget(source: Bounds, to: Cell): FillTarget | null {
  const down = to.row - source.bottom;
  const up = source.top - to.row;
  const right = to.column - source.right;
  const left = source.left - to.column;
  const rows = Math.max(down, up);
  const columns = Math.max(right, left);
  if (rows <= 0 && columns <= 0) return null;
  // As far one way as the other, the rows have it: down is where a fill most often goes.
  if (rows >= columns) {
    return down > 0
      ? { axis: "rows", forward: true, bounds: { ...source, top: source.bottom + 1, bottom: to.row } }
      : { axis: "rows", forward: false, bounds: { ...source, top: to.row, bottom: source.top - 1 } };
  }
  return right > 0
    ? { axis: "columns", forward: true, bounds: { ...source, left: source.right + 1, right: to.column } }
    : { axis: "columns", forward: false, bounds: { ...source, left: to.column, right: source.left - 1 } };
}

/**
 * What "fill down" and "fill across" fill, and from what: the lines of a block
 * after its first, from the first; or a block of one line, from the line before
 * it. `null` where there is no line to fill from.
 */
export function fillFromFirst(
  block: Bounds,
  axis: FillTarget["axis"],
): { readonly source: Bounds; readonly target: FillTarget } | null {
  const [first, last] = axis === "rows" ? (["top", "bottom"] as const) : (["left", "right"] as const);
  const start = block[first];
  if (block[last] > start) {
    return {
      source: { ...block, [last]: start },
      target: { axis, forward: true, bounds: { ...block, [first]: start + 1 } },
    };
  }
  if (start === 0) return null;
  return {
    source: { ...block, [first]: start - 1, [last]: start - 1 },
    target: { axis, forward: true, bounds: block },
  };
}

/**
 * What "fill series" fills, and from what: a block's lines that hold values, from
 * its start, continued through the rest of it — down the rows of a block more
 * than one row tall, else along its columns. `filled(line)` says whether a line,
 * counted from the block's start, holds any value. `null` where the block starts
 * with an empty line, or is filled to its end.
 */
export function fillSeries(
  block: Bounds,
  filled: (line: number) => boolean,
): { readonly source: Bounds; readonly target: FillTarget } | null {
  const axis: FillTarget["axis"] = block.bottom > block.top ? "rows" : "columns";
  const [first, last] = axis === "rows" ? (["top", "bottom"] as const) : (["left", "right"] as const);
  const lines = block[last] - block[first] + 1;
  let given = 0;
  while (given < lines && filled(given)) given += 1;
  if (given === 0 || given === lines) return null;
  const end = block[first] + given - 1;
  return {
    source: { ...block, [last]: end },
    target: { axis, forward: true, bounds: { ...block, [first]: end + 1 } },
  };
}

/** How the values of a line of cells may be continued: as numbers, as dates, or not at all. */
export type FillKind = "number" | "date" | "other";

/**
 * What a place beside a line of values takes. `offset` counts from the line: 1
 * is the place after its last value, -1 the place before its first.
 * `undefined` is nothing to put there: a date beyond the years a date can write.
 */
export type Continuation = (offset: number) => unknown;

/** How many digits a number is written with after its point, or `null` where it is not written with one. */
function decimals(value: number): number | null {
  const text = String(value);
  if (text.includes("e")) return null;
  const point = text.indexOf(".");
  return point === -1 ? 0 : text.length - point - 1;
}

/** The step every value is from the one before, or `null` when there is no one step. */
function stepOf(values: readonly number[]): number | null {
  const step = values[1]! - values[0]!;
  for (let index = 2; index < values.length; index += 1) {
    if (values[index]! - values[index - 1]! !== step) return null;
  }
  return step;
}

function numbers(source: readonly unknown[]): Continuation | null {
  let places = 0;
  for (const value of source) {
    const own = typeof value === "number" && Number.isFinite(value) ? decimals(value) : null;
    if (own === null) return null;
    places = Math.max(places, own);
  }
  // Counted in whole units of the last decimal place, so that 0.1, 0.2 goes on to 0.3 exactly.
  const scale = 10 ** places;
  const whole = source.map((value) => Math.round((value as number) * scale));
  const step = stepOf(whole);
  if (step === null || !whole.every(Number.isSafeInteger)) return null;
  return (offset) => {
    const next = (offset > 0 ? whole.at(-1)! : whole[0]!) + step * offset;
    return Number.isSafeInteger(next) ? next / scale : undefined;
  };
}

const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;

function dates(source: readonly unknown[]): Continuation | null {
  if (!source.every((value): value is string => typeof value === "string" && ISO_DATE.test(value))) {
    return null;
  }
  const days = stepOf(source.map(dayNumber));
  // The same day of each month — one that every month has — so many months apart.
  const day = source[0]!.slice(8);
  const monthly = Number(day) <= 28 && source.every((date) => date.slice(8) === day);
  const months = monthly
    ? stepOf(source.map((date) => Number(date.slice(0, 4)) * 12 + Number(date.slice(5, 7)) - 1))
    : null;
  const byDays = days !== null && days !== 0;
  const byMonths = months !== null && months !== 0;
  // Two dates a month apart are also so many days apart: which was meant is not said.
  if (byDays === byMonths) return null;
  const from = (offset: number) => (offset > 0 ? source.at(-1)! : source[0]!);
  if (byDays) return (offset) => dateOfDay(dayNumber(from(offset)) + days * offset) ?? undefined;
  return (offset) => {
    const date = from(offset);
    const month = Number(date.slice(0, 4)) * 12 + Number(date.slice(5, 7)) - 1 + months! * offset;
    const year = Math.floor(month / 12);
    if (year < 1 || year > 9999) return undefined;
    return `${String(year).padStart(4, "0")}-${String((month % 12) + 1).padStart(2, "0")}-${day}`;
  };
}

/**
 * What the places beside a line of values take: the series the values make,
 * when they are of a kind that makes one and make exactly one; otherwise the
 * values again, in their order.
 */
export function continuation(source: readonly unknown[], kind: FillKind = "other"): Continuation {
  const count = source.length;
  if (count === 0) return () => undefined;
  const series =
    count < 2 ? null : kind === "number" ? numbers(source) : kind === "date" ? dates(source) : null;
  if (series !== null) return series;
  // Before the line as after it, the values tile.
  return (offset) => source[(((offset > 0 ? offset - 1 : offset) % count) + count) % count];
}