import type { BackendInfo, MethodDefinition, PlateResult } from "@plate-dyn/core";

export type StagedStatus =
  | { status: "idle" }
  | { status: "running"; stage: "modes" | "strike" | "script"; startedAt: number; output: string[] }
  | {
      status: "done";
      output: string[];
      wallMs: number;
      /** Wall time of the modes stage in this run, or null when the modes were reused */
      modesMs: number | null;
      strikeMs: number;
      backend: BackendInfo;
    }
  | {
      status: "error";
      error: string;
      output: string[];
      wallMs: number;
      backend: BackendInfo;
      cancelled?: boolean;
    };

export interface RunStatusProps {
  state: StagedStatus;
  result?: PlateResult | null;
  method?: MethodDefinition;
  backend?: BackendInfo | null;
  /** Predicted wall times for the next run [ms], shown while idle */
  estimate?: { modesMs: number | null; strikeMs: number };
  onCancel?: () => void;
}

/** Makes the execution visible: what ran, where, how big it was and how long it took. */
export function RunStatus({ state, result, method, backend, estimate, onCancel }: RunStatusProps) {
  const be = state.status === "done" || state.status === "error" ? state.backend : backend;
  return (
    <div className="pl-status">
      <div className="pl-row">
        {state.status === "idle" && <span className="pl-badge pl-badge-info">ready</span>}
        {state.status === "running" && (
          <>
            <span className="pl-badge pl-badge-info">
              {state.stage === "modes"
                ? "solving the modes"
                : state.stage === "strike"
                  ? "striking"
                  : "running the script"}
            </span>
            {onCancel && (
              <button className="pl-btn pl-btn-danger" onClick={onCancel}>
                Cancel
              </button>
            )}
          </>
        )}
        {state.status === "done" && <span className="pl-badge pl-badge-ok">finished</span>}
        {state.status === "error" && (
          <span className="pl-badge pl-badge-error">{state.cancelled ? "cancelled" : "error"}</span>
        )}
        {method && <span className="pl-muted">{method.name}</span>}
      </div>
      {state.status === "running" && (
        <div className="pl-progress">
          <div />
        </div>
      )}
      {state.status === "error" && <div className="pl-error">{state.error}</div>}
      <table>
        <tbody>
          <tr>
            <td>Backend</td>
            <td>
              {be
                ? `${be.engine} ${be.version}, ${be.optimization === "1" ? "JS JIT (opt 1)" : "interpreter (opt 0)"}, ${be.host === "web-worker" ? "Web Worker in this browser" : "Node.js"}, double precision`
                : "numbl (not yet started)"}
            </td>
          </tr>
          <tr>
            <td>Wall time</td>
            <td>
              {state.status === "done" ? (
                <>
                  {fmtMs(state.wallMs)} in total:{" "}
                  {state.modesMs === null
                    ? "the modes were kept from an earlier run"
                    : `${fmtMs(state.modesMs)} for the modes`}
                  , {fmtMs(state.strikeMs)} for the strike and the synthesis
                </>
              ) : state.status === "running" ? (
                "…"
              ) : estimate ? (
                `about ${estimate.modesMs === null ? "" : `${fmtMs(estimate.modesMs)} for the modes and `}${fmtMs(estimate.strikeMs)} for the strike expected`
              ) : (
                "–"
              )}
            </td>
          </tr>
          {result && (
            <tr>
              <td>Problem size</td>
              <td>
                {result.info.size_note}; {result.info.nmodes} modes kept ({result.info.n_audible}{" "}
                audible below {(result.info.f_max / 1000).toFixed(1)} kHz
                {result.info.n_rigid > 0 ? `, ${result.info.n_rigid} rigid-body` : ""}),{" "}
                {result.info.nsamples.toLocaleString()} samples at {result.info.fs} Hz,{" "}
                {result.frames.t.length} frames
              </td>
            </tr>
          )}
          {result && (
            <tr>
              <td>Inside the solver</td>
              <td>
                {fmtMs(result.info.modes_wall_s * 1000)} for the modes (by tic/toc, when they were
                computed), {fmtMs(result.info.strike_wall_s * 1000)} for the strike
                {result.info.extra.eig_iterations !== undefined
                  ? `; eigensolver ${result.info.extra.eig_iterations} iterations`
                  : ""}
              </td>
            </tr>
          )}
        </tbody>
      </table>
      {result && result.info.notes.length > 0 && (
        <div>
          {result.info.notes.map((n, i) => (
            <div className="pl-note" key={i}>
              {n}
            </div>
          ))}
        </div>
      )}
      {(state.status === "running" || state.status === "done" || state.status === "error") &&
        state.output.length > 0 && (
          <details>
            <summary className="pl-small pl-muted">
              Script output ({state.output.length} lines)
            </summary>
            <div className="pl-log">{state.output.join("")}</div>
          </details>
        )}
    </div>
  );
}

export function fmtMs(ms: number): string {
  if (ms < 1000) return `${ms.toFixed(0)} ms`;
  return `${(ms / 1000).toFixed(2)} s`;
}

export function fmtTime(s: number): string {
  if (s >= 1) return `${s.toPrecision(3)} s`;
  if (s >= 1e-3) return `${(s * 1e3).toPrecision(3)} ms`;
  return `${(s * 1e6).toPrecision(3)} µs`;
}