import type { DiagnosticReport } from "fhir/r4";
import { dayAndTime } from "../pages/DashboardPage/BenchPage/benchTime.ts";

/** Where the controls stood for one test. Unknown means the record could not be read, never that it passed. */
export interface QualityControlPosition {
  outcome: "pass" | "fail" | "none" | "unknown" | "outside";
  openFailure?: boolean;
  ranAt?: string;
  /** The laboratory that performed the test when it was not this bench. */
  performer?: string;
  /** The last run was before the practice's current day, so it says nothing about today's work. */
  stale?: boolean;
  lot?: string;
  level?: string;
}

export const QUALITY_CONTROL_POSITION_EXTENSION_URL =
  "https://akashichealthrecords.com/fhir/StructureDefinition/quality-control-position";

const OUTCOMES = new Set(["pass", "fail", "none", "outside"]);

/** The position the server stamped on a released report; absent on a report released before it stamped one. */
export const readQualityControlPosition = (report: DiagnosticReport | undefined): QualityControlPosition | undefined => {
  const found = (report?.extension ?? []).find((extension) => extension.url === QUALITY_CONTROL_POSITION_EXTENSION_URL);
  if (!found) return undefined;
  const part = (url: string) => (found.extension ?? []).find((extension) => extension.url === url);
  const outcome = part("outcome")?.valueCode;
  return {
    outcome: outcome && OUTCOMES.has(outcome) ? outcome as QualityControlPosition["outcome"] : "unknown",
    ...(part("openFailure")?.valueBoolean !== undefined ? { openFailure: part("openFailure")?.valueBoolean } : {}),
    ...(part("ranAt")?.valueDateTime ? { ranAt: part("ranAt")?.valueDateTime } : {}),
    ...(part("performer")?.valueString ? { performer: part("performer")?.valueString } : {}),
    ...(part("stale")?.valueBoolean ? { stale: true } : {}),
    ...(part("lot")?.valueString ? { lot: part("lot")?.valueString } : {}),
    ...(part("level")?.valueString ? { level: part("level")?.valueString } : {}),
  };
};

export type QualityControlState =
  | "current" | "outside" | "unknown" | "unknown-open-failure" | "none" | "stale" | "failed" | "failed-corrected" | "open-failure";

/** Only a run today that passed, with no failure left unanswered, is current. */
export const qualityControlState = (qc: QualityControlPosition | undefined): QualityControlState => {
  if (qc?.outcome === "outside") return "outside";
  if (!qc || qc.outcome === "unknown") return qc?.openFailure ? "unknown-open-failure" : "unknown";
  if (qc.outcome === "none") return "none";
  if (qc.outcome === "fail") return qc.openFailure === false ? "failed-corrected" : "failed";
  if (qc.openFailure) return "open-failure";
  return qc.stale ? "stale" : "current";
};

/** Quality control is attention, never a gate: shown beside the result, and unreadable is not passed. */
export const qualityControlNotice = (qc: QualityControlPosition | undefined, test?: string): string | undefined => {
  const named = test ?? "this test";
  const lastRun = "The last control run for " + named;
  switch (qualityControlState(qc)) {
    case "current":
    case "outside":
      return undefined;
    case "unknown":
      return "Quality control for " + named + " could not be read. Unavailable quality control is not a pass.";
    case "unknown-open-failure":
      return "Quality control for " + named + " could not be read in full, and what was read includes a failed control with no corrective action recorded.";
    case "none":
      return "No control run could be matched to " + named + ".";
    case "failed":
      return lastRun + " failed, and no corrective action is recorded.";
    case "failed-corrected":
      return lastRun + " failed. A corrective action is recorded, but no passing run has followed.";
    case "open-failure":
      return lastRun + " passed, but an earlier failure has no corrective action recorded.";
    case "stale":
      return lastRun + " passed before today. No control has been run today.";
  }
};

/** The run the position came from, as recorded; nothing when no run was matched or read. */
export const controlRunLine = (qc: QualityControlPosition | undefined): string | undefined => {
  if (!qc?.ranAt || qc.outcome === "outside") return undefined;
  const verdict = qc.outcome === "pass" ? "passed" : qc.outcome === "fail" ? "failed" : "run";
  const when = dayAndTime(qc.ranAt) ?? "at a time that could not be read";
  return ["Last run " + verdict + " " + when, qc.lot ? "Lot " + qc.lot : undefined, qc.level ? "Level " + qc.level : undefined]
    .filter(Boolean)
    .join(" \u00b7 ");
};

/** The position stamped when the result went out, said as that and never as today's. Null is a report released before stamping. */
export const qualityControlAtRelease = (qc: QualityControlPosition | null | undefined, test?: string): string => {
  if (!qc) return "Quality control at release was not recorded.";
  if (qc.outcome === "outside") return "At release: performed by " + (qc.performer ?? "another laboratory") + ", outside this practice's quality control.";
  return "At release: " + (qualityControlNotice(qc, test) ?? "quality control for " + (test ?? "this test") + " was current.");
};