// Pure conversion helpers behind the editor's DurationField control.
//
// Every cadence in the app is stored as a bare integer in one fixed unit —
// minutes for the sync/sweep/backoff intervals, seconds for the heartbeat. That
// keeps settings.json and every existing validator simple, but it means an
// operator reads `10080` and has to do the arithmetic to learn it means weekly.
// DurationField shows the same number as an amount + unit pair; these helpers do
// the conversion both ways, and are kept here (rather than beside the component)
// because `lib/*.test.ts` is what the common package's unit-test glob picks up.
//
// The invariant that matters: splitDuration only ever picks a unit that divides
// the stored value EXACTLY, so a hand-edited `137` round-trips as "137 minutes"
// instead of being silently rounded to "2 hours".

export type DurationUnit = "seconds" | "minutes" | "hours" | "days" | "weeks";

// Posted by DurationField's "Leave unchanged" mode, and understood by the
// actions that read it. A distinct token rather than "", because "" already
// means "clear this key and inherit the global default" — a bulk edit that
// skips a field must be distinguishable from one that resets it. Lives here
// rather than beside the component so a server action can import it without
// crossing the "use client" boundary.
export const DURATION_KEEP = "keep";

// Seconds per unit. Ordered smallest-first; the order is load-bearing for
// splitDuration, which walks it backwards to find the largest even divisor.
const UNIT_SECONDS: Record<DurationUnit, number> = {
  seconds: 1,
  minutes: 60,
  hours: 3600,
  days: 86400,
  weeks: 604800,
};

const UNIT_ORDER: DurationUnit[] = [
  "seconds",
  "minutes",
  "hours",
  "days",
  "weeks",
];

export function isDurationUnit(value: unknown): value is DurationUnit {
  return typeof value === "string" && value in UNIT_SECONDS;
}

// Label for a unit, pluralised for `amount`. Used by both the unit <select> and
// the echo line, so they can never disagree about wording.
export function unitLabel(unit: DurationUnit, amount = 2): string {
  const singular = unit.slice(0, -1);
  return Math.abs(amount) === 1 ? singular : unit;
}

// Convert `amount` of `unit` into the stored integer, expressed in `baseUnit`.
// Rounded because the caller may hand us a fractional intermediate (e.g. a
// half-typed input); every real conversion here is exact.
export function toBaseUnit(
  amount: number,
  unit: DurationUnit,
  baseUnit: DurationUnit,
): number {
  if (!Number.isFinite(amount)) return 0;
  return Math.round((amount * UNIT_SECONDS[unit]) / UNIT_SECONDS[baseUnit]);
}

// Split a stored value (in `baseUnit`) into the largest unit from `units` that
// divides it evenly: 1440 minutes -> {1, "days"}, 137 minutes -> {137,
// "minutes"}. Falls back to `baseUnit` when nothing divides evenly, even if
// `baseUnit` isn't itself in `units` — that fallback is what preserves an
// arbitrary hand-set value on a field whose presets are all hours and days.
//
// 0 and negatives are sentinels ("off"), not durations: they come back
// unchanged in the base unit.
export function splitDuration(
  value: number,
  units: DurationUnit[],
  baseUnit: DurationUnit = units[0] ?? "minutes",
): { amount: number; unit: DurationUnit } {
  if (!Number.isFinite(value) || value <= 0) {
    return { amount: Number.isFinite(value) ? value : 0, unit: baseUnit };
  }
  const seconds = value * UNIT_SECONDS[baseUnit];
  const candidates = UNIT_ORDER.filter(
    (u) => units.includes(u) && UNIT_SECONDS[u] >= UNIT_SECONDS[baseUnit],
  );
  for (let i = candidates.length - 1; i >= 0; i -= 1) {
    const unit = candidates[i];
    if (seconds % UNIT_SECONDS[unit] === 0) {
      return { amount: seconds / UNIT_SECONDS[unit], unit };
    }
  }
  return { amount: value, unit: baseUnit };
}

// "1,440 minutes" — the raw stored value, always shown so nothing is hidden
// from someone who also reads settings.json.
export function formatBaseValue(value: number, baseUnit: DurationUnit): string {
  return `${value.toLocaleString("en-US")} ${unitLabel(baseUnit, value)}`;
}

// How many times something on this cadence happens per day. This is the number
// an operator actually reasons about when judging whether they're about to get
// rate-limited by the source.
export function perDayRate(value: number, baseUnit: DurationUnit): number {
  if (!Number.isFinite(value) || value <= 0) return 0;
  return UNIT_SECONDS.days / (value * UNIT_SECONDS[baseUnit]);
}

// Round a rate to something readable: 0.7, 1, 24. Sub-0.1 rates collapse to a
// "less than" form rather than printing 0.
export function formatRate(rate: number): string {
  if (rate <= 0) return "0";
  if (rate < 0.1) return `<0.1`;
  if (rate < 10) return String(Math.round(rate * 10) / 10);
  return String(Math.round(rate));
}