Values as text

/**
 * A scalar value as text, by the kind its schema gives it: how a grid shows a
 * cell, what it puts on the clipboard, and how it reads what is typed into one or
 * pasted. The reading is as forgiving as a field's — `１，２００円` is a number in
 * a column of yen — so cells copied from anywhere land as values of the right
 * kind.
 */
import { dateType, isDate } from "./date-type.ts";
import { numberType } from "./number-type.ts";
import { resolve } from "./schema.ts";
import type { Schema } from "./schema.ts";
import { angle, length } from "./units.ts";
import type { ParseResult } from "./use-field.ts";

export interface TextCodec {
  /** The text for a value; the empty string for none. */
  readonly format: (value: unknown) => string;
  /** The value in a text as it is typed, or why there is none. An empty text is no value. */
  readonly parse: (text: string) => ParseResult<unknown>;
  /**
   * The value in a text as data holds it — a cell pasted from elsewhere. Read
   * as written and no further: arithmetic is not worked out, and a value
   * outside the field's range is refused rather than moved into it, since
   * nobody is there to see it change.
   */
  readonly read: (text: string) => ParseResult<unknown>;
}

const DIMENSIONS = { length, angle };
const YES = new Set(["true", "yes", "y", "1", "on", "✓", "はい"]);
const NO = new Set(["false", "no", "n", "0", "off", "いいえ"]);

/** A codec whose pasted text is read as its typed text is. */
function same(codec: Omit<TextCodec, "read">): TextCodec {
  return { ...codec, read: codec.parse };
}

export function textCodec(given: Schema, locale = "en-US"): TextCodec {
  // A schema given by reference is read and shown as what it refers to.
  const schema = resolve(given);
  switch (schema.kind) {
    case "number": {
      const type = numberType({
        locale,
        minimum: schema.minimum,
        maximum: schema.maximum,
        step: schema.step,
        precision: schema.precision,
        kind: schema.format,
        currency: schema.currency,
        units: schema.dimension === undefined ? undefined : DIMENSIONS[schema.dimension],
        unit: schema.unit,
      });
      return {
        format: (value) => (typeof value === "number" && Number.isFinite(value) ? type.format(value) : ""),
        parse(text) {
          const result = type.parse(text);
          return result.ok ? { ok: true, value: type.constrain(result.value) } : result;
        },
        read(text) {
          const result = type.parse(text, { arithmetic: false });
          if (!result.ok) return result;
          if (type.minimum !== undefined && result.value < type.minimum)
            return { ok: false, reason: "minimum" };
          if (type.maximum !== undefined && result.value > type.maximum)
            return { ok: false, reason: "maximum" };
          return { ok: true, value: type.constrain(result.value) };
        },
      };
    }
    case "date": {
      const type = dateType({ locale, minimum: schema.minimum, maximum: schema.maximum });
      return same({
        // Only a date is shown as one: anything else a record holds here would not format.
        format: (value) => (typeof value === "string" && isDate(value) ? type.format(value) : ""),
        // A date outside the field's range is refused by the type itself.
        parse: type.parse,
      });
    }
    case "boolean":
      return same({
        format: (value) => (typeof value === "boolean" ? (value ? "TRUE" : "FALSE") : ""),
        parse(text) {
          const word = text.trim().toLowerCase();
          if (word === "") return { ok: false, reason: "empty" };
          if (YES.has(word)) return { ok: true, value: true };
          if (NO.has(word)) return { ok: true, value: false };
          return { ok: false, reason: "invalid" };
        },
      });
    case "choice":
      return same({
        format: (value) => schema.options.find((option) => option.value === value)?.label ?? "",
        parse(text) {
          const word = text.trim().toLowerCase();
          if (word === "") return { ok: false, reason: "empty" };
          // By its value exactly, as data holds it; else by its label or value, as a person writes it.
          const option =
            schema.options.find((candidate) => candidate.value === text.trim()) ??
            schema.options.find(
              (candidate) => candidate.label.toLowerCase() === word || candidate.value.toLowerCase() === word,
            );
          return option === undefined ? { ok: false, reason: "invalid" } : { ok: true, value: option.value };
        },
      });
    case "text":
      return same({
        format: (value) => (typeof value === "string" ? value : ""),
        parse: (text) => (text === "" ? { ok: false, reason: "empty" } : { ok: true, value: text }),
      });
    default:
      return same({ format: () => "", parse: () => ({ ok: false, reason: "invalid" }) });
  }
}