"use client";
import { useEffect, useRef, useState } from "react";
type R = Record<string, any>;
export default function InlineTest({
  q,
  user,
  documents,
  draft,
  context,
  send,
  load,
  parent,
  issue,
}: R) {
  const initial = draft?.payload || {};
  const [actual, setActual] = useState(initial.actual || ""),
    [verdict, setVerdict] = useState(initial.verdict || ""),
    [evidence, setEvidence] = useState(initial.evidence || ""),
    [files, setFiles] = useState<File[]>([]),
    [busy, setBusy] = useState(false),
    [message, setMessage] = useState(""),
    [error, setError] = useState(""),
    [metrics, setMetrics] = useState<R>(initial.metrics || {}),
    [sessionId, setSessionId] = useState("");
  const operation = useRef(crypto.randomUUID()),
    revision = useRef(draft?.revision || 0),
    queue = useRef<Promise<any>>(Promise.resolve()),
    dirty = useRef(false),
    saved = useRef(false),
    fileInput = useRef<HTMLInputElement>(null),
    sessionPromise = useRef<Promise<any> | null>(null),
    timerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
  const docs = (q.documentIds || [])
    .map((id: string) => documents.find((d: R) => d.id === id))
    .filter(Boolean);
  const docVersions = useRef(
    Object.fromEntries(docs.map((d: R) => [d.id, d.version])),
  );
  const ensureSession = () => {
    if (!sessionPromise.current)
      sessionPromise.current = send({
        action: "quickSession",
        oiName: context.oiName || "Jenny",
        channel: context.channel || "Voice",
      })
        .then((r: R) => {
          setSessionId(r.id);
          return r.id;
        })
        .catch((e: Error) => {
          sessionPromise.current = null;
          throw e;
        });
    return sessionPromise.current!;
  };
  useEffect(() => {
    ensureSession().catch((e: Error) => setError(e.message));
  }, []);
  const data = { actual, verdict, evidence, metrics };
  useEffect(() => {
    if (!dirty.current || saved.current) return;
    const timer = setTimeout(() => {
      queue.current = queue.current
        .catch(() => {})
        .then(async () => {
          try {
            const result = await send({
              action: "draft",
              questionId: q.id,
              payload: data,
              revision: revision.current,
            });
            revision.current = result.revision;
            setMessage("Draft saved. Screenshots are saved with your result.");
          } catch (e: any) {
            setError("Draft not saved: " + e.message);
          }
        });
    }, 1500);
    timerRef.current = timer;
    return () => clearTimeout(timer);
  }, [actual, verdict, evidence, metrics]);
  const edit = (fn: () => void) => {
    dirty.current = true;
    fn();
  };
  function addFiles(incoming: File[]) {
    const combined = [...files, ...incoming];
    if (combined.length > 5) {
      setError("Attach up to five screenshots.");
      return;
    }
    if (
      combined.some(
        (f) =>
          f.size > 5 * 1024 * 1024 ||
          !["image/png", "image/jpeg", "image/webp"].includes(f.type),
      )
    ) {
      setError("Use PNG, JPEG or WebP screenshots, up to 5 MB each.");
      return;
    }
    setFiles(combined);
    setError("");
  }
  async function save(e: any) {
    e.preventDefault();
    if (timerRef.current) clearTimeout(timerRef.current);
    setBusy(true);
    setError("");
    try {
      if (!verdict) throw Error("Choose Pass, Failed or Blocked.");
      if (!actual.trim())
        throw Error("Tell us what happened, or paste the OI reply.");
      const sid = await ensureSession();
      await queue.current;
      await send(
        {
          action: "run",
          operationId: operation.current,
          questionId: q.id,
          questionVersion: q.version,
          sessionId: sid,
          verdict,
          actual,
          evidence,
          reason: ["Blocked", "N/A"].includes(verdict) ? actual : "",
          setupConfirmed: verdict !== "Blocked",
          outcomeVerified: verdict === "Pass",
          documentVersions: docVersions.current,
          ...metrics,
          previousRunId: parent?.id,
          issueId: issue?.id,
          issueRevision: issue?.revision,
        },
        files,
      );
      saved.current = true;
      setMessage(
        "Result and evidence saved. You can move to the next question.",
      );
      dirty.current = false;
      await load();
    } catch (e: any) {
      setError(e.message);
    } finally {
      setBusy(false);
    }
  }
  function again() {
    saved.current = false;
    operation.current = crypto.randomUUID();
    setFiles([]);
    setActual("");
    setVerdict("");
    setEvidence("");
    setMetrics({});
    revision.current = 0;
    setMessage("Ready for another attempt.");
  }
  return (
    <form
      className="inline-test"
      onSubmit={save}
      onPaste={(e) => {
        const incoming = Array.from(e.clipboardData.items)
          .filter((i) => i.kind === "file" && i.type.startsWith("image/"))
          .map((i) => i.getAsFile())
          .filter(Boolean) as File[];
        if (incoming.length) {
          e.preventDefault();
          addFiles(incoming);
        }
      }}
    >
      <h3>1. Upload your screenshot</h3>
      <div
        className="evidence-drop"
        onDragOver={(e) => e.preventDefault()}
        onDrop={(e) => {
          e.preventDefault();
          addFiles(Array.from(e.dataTransfer.files));
        }}
      >
        <button
          type="button"
          className="primary"
          disabled={busy || saved.current}
          onClick={() => fileInput.current?.click()}
        >
          Choose screenshots
        </button>
        <p>
          Or drag screenshots here, or paste an image copied to your clipboard.
        </p>
        <small>Optional · up to 5 images · 5 MB each</small>
        <input
          ref={fileInput}
          type="file"
          accept="image/png,image/jpeg,image/webp"
          multiple
          hidden
          onChange={(e) => {
            addFiles(Array.from(e.target.files || []));
            e.target.value = "";
          }}
        />
      </div>
      <div className="evidence-files">
        {files.map((f, i) => (
          <div key={i}>
            <span>{f.name}</span>
            <button
              type="button"
              disabled={busy || saved.current}
              onClick={() => setFiles(files.filter((_, n) => n !== i))}
            >
              Remove
            </button>
          </div>
        ))}
      </div>
      <label className="result-notes">
        2. What happened?
        <textarea
          value={actual}
          disabled={busy || saved.current}
          required
          placeholder="Paste the OI’s reply here, or briefly explain what went right or wrong."
          onChange={(e) => edit(() => setActual(e.target.value))}
        />
      </label>
      <fieldset className="verdict-picker">
        <legend>3. Choose the result</legend>
        <div>
          {[
            ["Pass", "Pass"],
            ["Fail", "Failed"],
            ["Blocked", "Blocked"],
            ["N/A", "Not applicable"],
          ].map(([v, label]) => (
            <label key={v} className={"verdict-option " + v.replace("/", "")}>
              <input
                type="radio"
                name={"verdict-" + q.id}
                value={v}
                checked={verdict === v}
                disabled={busy || saved.current}
                onChange={() => edit(() => setVerdict(v))}
                required
              />
              {label}
            </label>
          ))}
        </div>
      </fieldset>
      <p className="muted">
        Pass means you checked the result really happened. Failed means it was
        wrong. Blocked means you could not complete the test.
      </p>
      <details>
        <summary>Optional: link, search cost and time</summary>
        <label>
          Evidence link or recording reference
          <input
            value={evidence}
            disabled={busy || saved.current}
            onChange={(e) => edit(() => setEvidence(e.target.value))}
          />
        </label>
        {[
          ["sourcesChecked", "Sources checked"],
          ["sourceCount", "Number of sources"],
          ["duration", "Total response time (seconds)"],
          ["costAmount", "Cost shown"],
          ["inputTokens", "Input tokens"],
          ["outputTokens", "Output tokens"],
        ].map(([name, label]) => (
          <label key={name}>
            {label}
            <input
              value={metrics[name] ?? ""}
              type={["sourcesChecked"].includes(name) ? "text" : "number"}
              min="0"
              step="any"
              disabled={busy || saved.current}
              onChange={(e) =>
                edit(() => setMetrics({ ...metrics, [name]: e.target.value }))
              }
            />
          </label>
        ))}
        <label>
          Currency
          <select
            value={metrics.costCurrency || "USD"}
            onChange={(e) =>
              edit(() =>
                setMetrics({ ...metrics, costCurrency: e.target.value }),
              )
            }
          >
            {["USD", "GBP", "EUR", "GHS", "NGN", "INR"].map((c) => (
              <option key={c}>{c}</option>
            ))}
          </select>
        </label>
        <label>
          What the cost covers
          <select
            value={metrics.costScope || "Not specified"}
            onChange={(e) =>
              edit(() => setMetrics({ ...metrics, costScope: e.target.value }))
            }
          >
            {["Not specified", "Model only", "Full voice call", "Other"].map(
              (c) => (
                <option key={c}>{c}</option>
              ),
            )}
          </select>
        </label>
        <p className="muted">
          Leave unavailable figures blank. This does not automatically read or
          score your screenshot.
        </p>
      </details>
      {error && (
        <p className="alert" role="alert">
          {error}
        </p>
      )}
      {message && (
        <p className="save-message" role="status">
          {message}
        </p>
      )}
      <div className="actions spaced">
        {saved.current ? (
          <button type="button" onClick={again}>
            Record another attempt
          </button>
        ) : (
          <button className="primary save-result" disabled={busy}>
            {busy ? "Saving…" : "Save result & evidence"}
          </button>
        )}
      </div>
      <small>
        Your name, question and time are recorded automatically. No session
        setup is needed.
      </small>
    </form>
  );
}
