Numbers

/**
 * The numeric value type: how a number is read from what people type or paste,
 * how it is shown, and how it steps.
 *
 * Reading is forgiving of form and strict about meaning: a text is read as what
 * the person meant, or it is invalid — never a guess. It accepts:
 *
 * - full-width digits from an input method, and every common digit system;
 * - the locale's group and decimal separators, and a separator from another
 *   locale where it cannot be anything else (`1,5` is one and a half);
 * - any minus sign: `-`, `−`, `－`, a dash before a number, `(500)` as accounts
 *   write it;
 * - arithmetic: `12*3`, `(40-8)/2`, `×` and `÷`, `10%` for a tenth — read as a
 *   formula (`algorithms/formula.ts`) that names no field;
 * - mixed numbers and scientific notation: `1 1/2`, `1.5e-7`;
 * - units, converted to the field's: `12pt` in a millimetre field, `5'10"`;
 * - the field's own currency, by symbol, code or name.
 *
 * Showing is the locale's: its digits, separators and unit placement.
 */
import { compileFormula } from "../algorithms/formula.ts";
import { DASH, normalizeNumeric } from "./typed-text.ts";
import { validLocale } from "../lib/valid-locale.ts";
import type { Unit, Units } from "./units.ts";

export interface NumberTypeOptions {
  readonly locale?: string | undefined;
  /** The range, in the value kept: 0.5, not 50, bounds a percentage at 50%. */
  readonly minimum?: number | undefined;
  readonly maximum?: number | undefined;
  /**
   * Whether the range is a cycle — an angle, an hour — so that its maximum is
   * its minimum again: a value past either end, typed or stepped, comes round
   * from the other. Needs both ends.
   */
  readonly wrap?: boolean | undefined;
  /** The amount the arrow keys add, in what is shown: 1 is 1% in a percentage. */
  readonly step?: number | undefined;
  /**
   * The most fraction digits a value shows, and so keeps: of the percentage in a
   * percentage, where 1 keeps 12.5%. A currency's own when not given.
   */
  readonly precision?: number | undefined;
  /** `percent` shows 0.5 as 50%; `currency` needs `currency`. */
  readonly kind?: "decimal" | "percent" | "currency" | undefined;
  readonly currency?: string | undefined;
  /** The units that can be typed, and the one values are in. */
  readonly units?: Units | undefined;
  readonly unit?: string | undefined;
}

export type ParseResult =
  | { readonly ok: true; readonly value: number }
  | { readonly ok: false; readonly reason: "empty" | "invalid" };

export interface ParseOptions {
  /** `false` reads one number as written and no arithmetic, as for pasted data. */
  readonly arithmetic?: boolean | undefined;
}

export interface NumberType {
  readonly parse: (text: string, options?: ParseOptions) => ParseResult;
  readonly format: (value: number) => string;
  /**
   * The value after `count` steps, on the multiples of the step size counted from
   * the minimum; a step is `step`, ten with Shift, a tenth with Alt. `times` is
   * how many such steps at once, as a drag makes them.
   */
  readonly step: (value: number, count: number, times?: number) => number;
  /** Rounded to the precision and held within the range — or, in a cycle, brought round into it. */
  readonly constrain: (value: number) => number;
  readonly minimum: number | undefined;
  readonly maximum: number | undefined;
  /** Whether the range is a cycle: asked for, and with both ends to make one. */
  readonly wrap: boolean;
}

const EMPTY: ParseResult = { ok: false, reason: "empty" };
const INVALID: ParseResult = { ok: false, reason: "invalid" };

// Sticky, so each is tried at a position in the text without slicing it.
const DIGITS = /(?:\d|[.,](?=\d))[\d.,]*/y;
const APOSTROPHE_GROUPED = /[1-9]\d{0,2}(?:'\d{3})+(?!\d)(?:[.,]\d*)?/y;
const EXPONENT = /e[+-]?\d+/iy;
const FRACTION = / +(\d+)\/(\d+)(?![\d.,'/])/y;
const SUFFIX = new RegExp(String.raw` *([^\d\s.,+\-*/()=${DASH}]+)`, "y");
const ANOTHER = / *(?=\d)/y;

const SPACE_GROUPED = /(?<![\d.,'])[1-9]\d{0,2}(?: \d{3})+(?!\d)/g;
const THOUSANDS = /^[1-9]\d{0,2}(?:[.,]\d{3})+$/;
// The Indian system: thousands, then hundreds of them in twos.
const LAKHS = /^[1-9]\d?(?:[.,]\d{2})*[.,]\d{3}$/;
const LITERAL = /^(?:[+-]?n|\(n\))$/;
const NO_FIELDS = (): undefined => undefined;
const NO_VALUES = (): null => null;
const NO_UNITS: ReadonlyMap<string, Unit> = new Map();

interface Separators {
  readonly group: string;
  readonly decimal: string;
  /** Whether groups above the thousands are of two digits. */
  readonly lakhs: boolean;
}

// A locale's separators never change, and every type in it asks for them.
const SEPARATORS = new Map<string, Separators>();

function separators(locale: string): Separators {
  let known = SEPARATORS.get(locale);
  if (known === undefined) SEPARATORS.set(locale, (known = readSeparators(locale)));
  return known;
}

function readSeparators(locale: string): Separators {
  const parts = new Intl.NumberFormat(locale).formatToParts(1234567.8);
  const whole = parts.filter((part) => part.type === "integer");
  return {
    group: normalizeNumeric(parts.find((part) => part.type === "group")?.value ?? ","),
    decimal: parts.find((part) => part.type === "decimal")?.value ?? ".",
    lakhs: whole.length > 2 && whole.at(-2)!.value.length === 2,
  };
}

/**
 * One number as typed, with whatever separators it has, as a plain decimal.
 * With two kinds of separator the last is the point and the others must group
 * thousands. With one kind, the locale's decimal point is one, once; any other
 * groups thousands where it can, and is the point where it occurs once and
 * cannot. Anything else is not a number.
 */
function readDigits(token: string, decimal: "." | ",", lakhs: boolean): string | null {
  const dot = token.lastIndexOf(".");
  const comma = token.lastIndexOf(",");
  if (dot === -1 && comma === -1) return token;
  let point = -1;
  if (dot !== -1 && comma !== -1) {
    point = Math.max(dot, comma);
    const mark = token[point]!;
    if (token.indexOf(mark) !== point || !groups(token.slice(0, point), lakhs && mark === decimal))
      return null;
  } else {
    const mark = dot === -1 ? "," : ".";
    const last = Math.max(dot, comma);
    const once = token.indexOf(mark) === last;
    if (mark === decimal) {
      if (!once) return null;
      point = last;
    } else if (!groups(token, lakhs && decimal === ".")) {
      if (!once) return null;
      point = last;
    }
  }
  if (point === -1) return token.replace(/[.,]/g, "");
  return `${token.slice(0, point).replace(/[.,]/g, "")}.${token.slice(point + 1)}`;
}

function groups(whole: string, lakhs: boolean): boolean {
  return THOUSANDS.test(whole) || (lakhs && LAKHS.test(whole));
}

/** A finite, non-negative number written without an exponent, as a formula reads it. */
function decimalText(value: number): string {
  const text = String(value);
  const at = text.indexOf("e");
  if (at === -1) return text;
  const digits = text.slice(0, at).replace(".", "");
  const shift = Number(text.slice(at + 1));
  // An exponent form has one digit before its point.
  return shift < 0 ? `0.${"0".repeat(-shift - 1)}${digits}` : digits + "0".repeat(shift + 1 - digits.length);
}

/**
 * Rounded to `precision` fraction digits, halves away from zero. It rounds the
 * decimal digits the value is written with rather than scaling it: 1.005 is
 * stored a little below itself, and a large value times a power of ten overflows.
 */
function round(value: number, precision: number): number {
  if (Number.isInteger(value) || !Number.isFinite(value)) return value;
  const text = decimalText(Math.abs(value));
  const cut = text.indexOf(".") + 1 + precision;
  if (cut >= text.length) return value;
  let kept = text.slice(0, precision === 0 ? cut - 1 : cut);
  if (text.charCodeAt(cut) >= 53) {
    // Add one in the last place kept, carrying through the nines.
    let place = kept.length - 1;
    while (place >= 0 && (kept[place] === "9" || kept[place] === ".")) place -= 1;
    const tail = kept.slice(place + 1).replace(/9/g, "0");
    kept = place < 0 ? `1${tail}` : `${kept.slice(0, place)}${Number(kept[place]) + 1}${tail}`;
  }
  const rounded = Number(kept);
  return value < 0 && rounded !== 0 ? -rounded : rounded;
}

function escaped(text: string): string {
  return text.replace(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
}

/** Every way the locale writes the currency: its code, symbols and names. */
function currencyForms(locale: string, currency: string): RegExp {
  const forms = new Set([currency]);
  const add = (format: Intl.NumberFormat, amount: number) => {
    for (const part of format.formatToParts(amount)) {
      if (part.type === "currency") forms.add(normalizeNumeric(part.value));
    }
  };
  for (const currencyDisplay of ["symbol", "narrowSymbol", "name"] as const) {
    const format = new Intl.NumberFormat(locale, {
      style: "currency",
      currency,
      currencyDisplay,
      // "1 US dollar", not "1.00 US dollars".
      minimumFractionDigits: 0,
      maximumFractionDigits: 1,
    });
    // Enough amounts to meet each plural form of a name.
    for (const amount of currencyDisplay === "name" ? [0, 1, 2, 3, 11, 100, 0.5] : [1]) add(format, amount);
  }
  // The symbol that says which dollar, `US$`, as written where it is not the local one.
  add(new Intl.NumberFormat("en-001", { style: "currency", currency }), 1);
  // Longest first, so `US$` goes whole rather than leaving `US`.
  const longestFirst = [...forms].toSorted((a, b) => b.length - a.length);
  return new RegExp(longestFirst.map(escaped).join("|"), "giu");
}

function unitIndex(units: Units): ReadonlyMap<string, Unit> {
  const index = new Map<string, Unit>();
  for (const [key, unit] of Object.entries(units)) {
    // Read as the text is, so `″` names what `"` does.
    for (const name of [key, unit.label, ...(unit.aliases ?? [])]) {
      index.set(normalizeNumeric(name).toLowerCase(), unit);
    }
  }
  return index;
}

/** A percent sign written before its number, at the start or after an operator. */
const PERCENT_FIRST = /(^|[-+*/(\s])%\s*(\d[\d.,]*)/g;

export function numberType({
  locale: localeOption = "en-US",
  minimum: minimumOption,
  maximum: maximumOption,
  wrap: wrapOption = false,
  step: stepOption = 1,
  precision: precisionOption,
  kind: kindOption = "decimal",
  currency,
  units,
  unit,
}: NumberTypeOptions = {}): NumberType {
  // Options are taken as given by data as often as by code: what cannot be meant
  // is put right rather than left to fail where a value is shown.
  const locale = validLocale(localeOption);
  const kind = kindOption === "currency" && currency === undefined ? "decimal" : kindOption;
  const step = Number.isFinite(stepOption) && stepOption > 0 ? stepOption : 1;
  const [minimum, maximum] =
    minimumOption !== undefined && maximumOption !== undefined && minimumOption > maximumOption
      ? [maximumOption, minimumOption]
      : [minimumOption, maximumOption];
  const local = separators(locale);
  // A locale whose separators are neither "." nor "," (Arabic's ٫ and ٬) has them
  // rewritten before reading, so the rules below only meet the two common ones.
  const native = local.decimal !== "." && local.decimal !== ",";
  const decimal: "." | "," = native ? "." : (local.decimal as "." | ",");
  const spaceGroups = local.group === " ";
  const index = units === undefined ? NO_UNITS : unitIndex(units);
  const fieldUnit = units !== undefined && unit !== undefined ? units[unit] : undefined;
  // Where `'` is feet it groups thousands only for a locale that writes them so.
  const apostropheGroups = local.group === "'" || !index.has("'");
  const exponents = !index.has("e");

  // A currency has its own minor unit: none for yen, two digits for dollars.
  const own =
    kind === "currency" && precisionOption === undefined
      ? new Intl.NumberFormat(locale, { style: kind, ...(currency !== undefined && { currency }) })
      : undefined;
  const shown = Number.isFinite(precisionOption)
    ? Math.min(Math.max(Math.trunc(precisionOption!), 0), 20)
    : (own?.resolvedOptions().maximumFractionDigits ?? (kind === "percent" ? 4 : 6));
  // A percentage is kept as a fraction, two digits finer than it is shown.
  const precision = kind === "percent" ? shown + 2 : shown;
  const formatter =
    own ??
    new Intl.NumberFormat(locale, {
      style: kind,
      ...(currency !== undefined && { currency }),
      maximumFractionDigits: shown,
    });
  // Built when first read: a type that only shows values never needs it.
  let money: RegExp | undefined;

  const stepSize = kind === "percent" ? step / 100 : step;
  const anchor = minimum ?? 0;
  const period = minimum !== undefined && maximum !== undefined ? maximum - minimum : 0;
  const wrap = wrapOption && period > 0 && Number.isFinite(period);

  /** Brought round into the cycle, which holds its minimum and not its maximum. */
  function wrapped(value: number): number {
    if (!wrap || !Number.isFinite(value)) return value;
    const within = value - anchor - Math.floor((value - anchor) / period) * period;
    return anchor + within;
  }

  function constrain(value: number): number {
    let result = round(value, precision);
    if (wrap && Number.isFinite(result)) {
      result = round(wrapped(result), precision);
      // Rounding may reach the maximum, which is the minimum again.
      if (result >= maximum! || result < minimum!) result = minimum!;
    } else {
      if (minimum !== undefined) result = Math.max(minimum, result);
      if (maximum !== undefined) result = Math.min(maximum, result);
    }
    return Object.is(result, -0) ? 0 : result;
  }

  function parse(text: string, options?: ParseOptions): ParseResult {
    let source = normalizeNumeric(text);
    if (kind === "currency" && currency !== undefined) {
      money ??= currencyForms(locale, currency);
      // A space, so that the numbers either side of a sign stay two.
      source = source.replace(money, " ");
    }
    if (native) source = source.replaceAll(local.group, ",").replaceAll(local.decimal, ".");
    source = source.replace(/×/g, "*").replace(/÷/g, "/").trim();
    if (source === "") return EMPTY;
    if (source.startsWith("=")) source = source.slice(1);
    // Some locales write the percent sign first: %50.
    source = source.replace(PERCENT_FIRST, "$1$2%");
    if (spaceGroups) source = source.replace(SPACE_GROUPED, (grouped) => grouped.replaceAll(" ", ""));

    let expression = "";
    // The text's outline: `n` for each quantity, and each operator as itself.
    let shape = "";
    let operand = false;
    let percent = false;
    let quantity = 0;
    let at = 0;
    while (at < source.length) {
      const char = source[at]!;
      if (char === " ") {
        at += 1;
      } else if (char === DASH) {
        // A dash between two numbers is a range, which is not a number.
        if (operand) return INVALID;
        expression += "-";
        shape += "-";
        at += 1;
      } else if ("+-*/()".includes(char)) {
        expression += char;
        shape += char;
        operand = char === ")";
        at += 1;
      } else {
        // Two numbers with nothing between them are not one.
        if (operand) return INVALID;
        // A quantity: a number, or measures from the larger unit down, in the field's unit.
        let total = 0;
        let larger = Infinity;
        for (;;) {
          APOSTROPHE_GROUPED.lastIndex = at;
          DIGITS.lastIndex = at;
          const grouped = apostropheGroups ? APOSTROPHE_GROUPED.exec(source) : null;
          const token = grouped ?? DIGITS.exec(source);
          if (token === null) return INVALID;
          at += token[0].length;
          const plain = readDigits(
            grouped === null ? token[0] : token[0].replaceAll("'", ""),
            decimal,
            local.lakhs,
          );
          if (plain === null) return INVALID;

          let amount = Number(plain);
          EXPONENT.lastIndex = at;
          FRACTION.lastIndex = at;
          const exponent = exponents ? EXPONENT.exec(source) : null;
          const fraction = exponent === null && !plain.includes(".") ? FRACTION.exec(source) : null;
          if (exponent !== null) {
            amount = Number(plain + exponent[0]);
            at += exponent[0].length;
          } else if (fraction !== null) {
            const over = Number(fraction[1]);
            const under = Number(fraction[2]);
            // Only a proper fraction makes a mixed number; `1 3/2` is two numbers.
            if (over > 0 && over < under) {
              amount += over / under;
              at += fraction[0].length;
            }
          }

          SUFFIX.lastIndex = at;
          const suffix = SUFFIX.exec(source);
          if (suffix === null || suffix[1] === "%") {
            if (larger !== Infinity) return INVALID;
            total = amount;
            if (suffix !== null) {
              total /= 100;
              percent = true;
              at += suffix[0].length;
            }
            break;
          }
          at += suffix[0].length;
          const typed = index.get(suffix[1]!.toLowerCase());
          if (typed === undefined || fieldUnit === undefined || typed.factor >= larger) return INVALID;
          total += amount * typed.factor;
          larger = typed.factor;
          ANOTHER.lastIndex = at;
          const another = ANOTHER.exec(source);
          if (another === null) {
            total /= fieldUnit.factor;
            break;
          }
          at += another[0].length;
        }
        if (!Number.isFinite(total)) return INVALID;
        expression += decimalText(total);
        quantity = total;
        shape += "n";
        operand = true;
      }
    }
    const literal = LITERAL.test(shape);
    if (options?.arithmetic === false && !literal) return INVALID;

    let value: number;
    if (literal) {
      // One number is its own value — negative after a minus, or wholly in
      // parentheses as accounts write it — and a paste of many compiles nothing.
      value = shape === "-n" || shape === "(n)" ? 0 - quantity : quantity;
    } else {
      // Arithmetic is a formula that names no field: one language, read one way.
      const compiled = compileFormula(expression, NO_FIELDS);
      const result = compiled.ok ? compiled.evaluate(NO_VALUES) : null;
      if (typeof result !== "number") return INVALID;
      value = result;
    }
    // Without a percent sign anywhere, what a percentage field is given is in percent.
    if (kind === "percent" && !percent) value /= 100;
    // Read round the cycle, not held at its end: 370° is 10°, and nothing was limited.
    return { ok: true, value: wrapped(value) };
  }

  function format(value: number): string {
    // Zero is shown as zero, whichever side it was approached from.
    const number = formatter.format(value === 0 ? 0 : value);
    if (fieldUnit === undefined) return number;
    return fieldUnit.attached ? `${number}${fieldUnit.label}` : `${number} ${fieldUnit.label}`;
  }

  function stepped(value: number, count: number, times = 1): number {
    if (count === 0 || !(times >= 1)) return constrain(value);
    // Less than one step is a finer grid; one the precision cannot keep is a whole step.
    const part = Math.min(1, Math.abs(count));
    const fine = stepSize * part;
    const keeps = Math.abs(round(fine, precision) - fine) <= fine * 1e-9;
    const size = keeps ? fine : stepSize;
    const steps = (keeps ? count / part : Math.sign(count)) * Math.trunc(times);
    const position = (value - anchor) / size;
    const nearest = Math.round(position);
    // Between two multiples, the first step goes to the next one that way.
    const from =
      Math.abs(position - nearest) <= 1e-9 * Math.max(1, Math.abs(position))
        ? nearest
        : steps > 0
          ? Math.floor(position)
          : Math.ceil(position);
    return constrain(anchor + (from + steps) * size);
  }

  return { parse, format, step: stepped, constrain, minimum, maximum, wrap };
}