"use client";

import React, { useEffect } from "react";
import { useState, useRef, useMemo } from "react";
import DiagnosticsView from "@/components/diagnostics-view";
import ReasoningWorkspace, { LoadingOverlay, ContinueLaterBanner } from "@/components/reasoning-workspace";
import { mockFetch, AVAILABLE_SCENARIOS } from "@/lib/mocks/confidence-engine/mock-client";

/* Compile-time env resolution — NEXT_PUBLIC_ vars are injected by Next.js at build */
const MOCK_ENABLED = process.env.NEXT_PUBLIC_CONFIDENCE_ENGINE_MOCKS === "true";

/* ── inject runtime globals for the mock client to read ──── */
function useMockGlobals() {
  useEffect(() => {
    if (MOCK_ENABLED) {
      var w = window;
      w.__MOCK_ENABLED = true;
      w.__MOCK_DELAY = process.env.NEXT_PUBLIC_CONFIDENCE_MOCK_DELAY || "normal";
      w.__MOCK_SCENARIO = process.env.NEXT_PUBLIC_CONFIDENCE_ENGINE_MOCK_SCENARIO || "";
    }
  }, []);
}

const MAX_LENGTH = 10000;

export async function submitScenarioForStartCase(fetchImpl, scenario) {
  return fetchImpl("/api/cases/start", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ scenario }),
  });
}

export async function submitAnswerForUpdateCase(
  fetchImpl,
  { situationGraph, previousQuestion, answer },
) {
  if (!answer?.trim()) {
    return {
      ok: false,
      skipped: true,
      data: {
        success: false,
        stage: "request_validation",
        error: "Please enter an answer before updating.",
      },
    };
  }

  const response = await fetchImpl("/api/cases/update", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ situationGraph, previousQuestion, answer }),
  });

  return {
    ok: response.ok,
    skipped: false,
    data: await response.json(),
  };
}

function normaliseStartResult(data) {
  return {
    ...data,
    selectedQuestion:
      typeof data?.selectedQuestion === "string"
        ? data.selectedQuestion
        : data?.selectedQuestion?.question ?? null,
    newlySurfacedNodeIds: data?.newlySurfacedNodeIds ?? [],
  };
}

function normaliseUpdateSelectedQuestion(selectedQuestion) {
  if (!selectedQuestion) return null;
  if (typeof selectedQuestion === "string") return selectedQuestion;
  return selectedQuestion.question ?? null;
}

export function ScenarioResultPanels({ status, result }) {
  if (!result) return null;

  const hasGraph = Boolean(result.situationGraph);
  const hasQuestion = Boolean(result.selectedQuestion?.question);
  const hasDiagnostics = Boolean(result.diagnostics);

  return (
    <>
      {status === "error" && (
        <div className="space-y-3">
          {result.error && (
            <div className="rounded-lg border border-red-300 bg-red-50 px-4 py-3 text-sm text-red-700 whitespace-pre-wrap">
              Error: {result.error}
            </div>
          )}
          {!hasGraph && !hasQuestion && (
            <div className="rounded-lg border border-yellow-300 bg-yellow-50 px-4 py-2 text-sm text-yellow-800">
              Validation failed — no structured graph output was produced.
            </div>
          )}
        </div>
      )}

      {hasDiagnostics && <DiagnosticsView result={result} />}
    </>
  );
}

// ── Message pools ───────────────────────────────────────────
const INITIAL_MESSAGES = [
  { min: 0, text: "Reading your situation" },
  { min: 10, text: "Building a structured understanding" },
  { min: 25, text: "Identifying what is known and still unclear" },
  { min: 45, text: "Selecting the next useful question" },
];

const UPDATE_MESSAGES = [
  { min: 0, text: "Considering your answer" },
  { min: 10, text: "Updating the situation" },
  { min: 25, text: "Checking what changed" },
  { min: 45, text: "Choosing the next question" },
];

function useLoadingStatus(messages, isLoading) {
  const [elapsed, setElapsed] = useState(0);
  const startRef = useRef(null);

  useEffect(() => {
    if (isLoading) {
      startRef.current = Date.now();
      const iv = setInterval(() => {
        setElapsed(Math.floor((Date.now() - startRef.current) / 1000));
      }, 1000);
      return () => clearInterval(iv);
    } else {
      setElapsed(0);
      startRef.current = null;
    }
  }, [isLoading]);

  const currentMessage = useMemo(() => {
    if (!messages || messages.length === 0) return "";
    let msg = messages[0].text;
    for (const m of messages) {
      if (elapsed >= m.min) msg = m.text;
    }
    return msg;
  }, [messages, elapsed]);

  return { elapsed, currentMessage };
}

export function UpdateErrorPanel({ updateError }) {
  if (!updateError) return null;

  const errors = [
    ...(updateError.errors || []),
    ...(updateError.validationErrors || []),
    ...(updateError.graphValidationErrors || []),
    ...(updateError.proposalErrors || []),
    ...(updateError.providerErrors || []),
  ];

  return (
    <div className="space-y-3">
      <div className="rounded-lg border border-red-300 bg-red-50 px-4 py-3 text-sm text-red-700 whitespace-pre-wrap">
        Update error: {updateError.error}
      </div>
      {errors.length > 0 && (
        <details className="rounded-lg border border-red-200 bg-red-50 px-4 py-3">
          <summary className="cursor-pointer text-sm font-medium text-red-700 underline">
            Update details ({errors.length})
          </summary>
          <ul className="mt-2 space-y-1 text-sm text-red-700">
            {errors.map((item, index) => (
              <li key={index}>
                {typeof item === "string" ? item : item?.message || JSON.stringify(item)}
              </li>
            ))}
          </ul>
        </details>
      )}
    </div>
  );
}

export { INITIAL_MESSAGES, UPDATE_MESSAGES, useLoadingStatus };

// ── Session key ────────────────────────────────────────────────
const SESSION_KEY = "confidence-engine-session";

function getSession() {
  if (typeof sessionStorage === "undefined") return null;
  try {
    const raw = sessionStorage.getItem(SESSION_KEY);
    return raw ? JSON.parse(raw) : null;
  } catch (_) { return null; }
}

function saveSession(state) {
  if (typeof sessionStorage === "undefined") return;
  try { sessionStorage.setItem(SESSION_KEY, JSON.stringify(state)); } catch (_) {}
}

function clearSession() {
  if (typeof sessionStorage === "undefined") return;
  try { sessionStorage.removeItem(SESSION_KEY); } catch (_) {}
}

export default function ScenarioForm() {
  const [scenario, setScenario] = useState("");
  const [status, setStatus] = useState("idle"); // idle | loading | error | success
  const [result, setResult] = useState(null);
  const [answer, setAnswer] = useState("");
  const [updateStatus, setUpdateStatus] = useState("idle"); // idle | loading | error | success
  const [updateError, setUpdateError] = useState(null);
  const [updateResult, setUpdateResult] = useState(null);
  const [lastSubmittedAnswer, setLastSubmittedAnswer] = useState("");
  const [currentUnderstanding, setCurrentUnderstanding] = useState(null);
  const [mockScenario, setMockScenario] = useState("");
  const textareaRef = useRef(null);

  /* Restore persisted session on mount (Phase 3) ─────────── */
  useEffect(() => {
    if (typeof window === "undefined") return;
    const saved = getSession();
    if (!saved) return;
    setScenario(saved.scenario || "");
    setResult(saved.situationGraph ? { ...saved, situationGraph: saved.situationGraph } : null);
    setCurrentUnderstanding(saved.summary || null);
    setStatus("success");
  }, []);

  /* Inject mock globals so the interceptor can read them at runtime */
  useMockGlobals();

  function handleScenarioSelect(key) {
    setMockScenario(key);
    if (typeof window !== "undefined") {
      window.__MOCK_SCENARIO = key;
    }
    // Auto-fill central statement for quick start
    var found = AVAILABLE_SCENARIOS.find(function(s) { return s.key === key; });
    if (found && found.centralStatement) {
      setScenario(found.centralStatement);
    }
  }

  function handleScenarioFill(key) {
    handleScenarioSelect(key);
    setStatus("loading");
    setResult(null);
    setAnswer("");
    setUpdateStatus("idle");
    setUpdateResult(null);
    setLastSubmittedAnswer("");
    setCurrentUnderstanding(null);
    setUpdateError(null);
    // Simulate a click on the analyse button after auto-filling
    setTimeout(function() {
      var btn = document.querySelector('button[type="submit"]');
      if (btn && !btn.disabled) btn.click();
    }, 50);
  }

  const { elapsed: startElapsed, currentMessage: startMsg } = useLoadingStatus(
    INITIAL_MESSAGES,
    status === "loading"
  );

  const { elapsed: updateElapsed, currentMessage: updateMsg } = useLoadingStatus(
    UPDATE_MESSAGES,
    updateStatus === "loading"
  );

  const handleSubmit = async (e) => {
    e.preventDefault();
    setStatus("loading");
    setResult(null);
    setAnswer("");
    setUpdateStatus("idle");
    setUpdateResult(null);
    setLastSubmittedAnswer("");
    setUpdateError(null);
    setCurrentUnderstanding(null);

    try {
      const res = await submitScenarioForStartCase(MOCK_ENABLED ? mockFetch : fetch, scenario);

      const data = await res.json();

      if (res.ok && data.success) {
        setStatus("success");
        setCurrentUnderstanding(data.summary ?? null);
        const normalised = normaliseStartResult(data);
        setResult(normalised);
        saveSession({ scenario, situationGraph: normalised.situationGraph, selectedQuestion: normalised.selectedQuestion, summary: data.summary ?? null, updatedAt: new Date().toISOString() });
      } else {
        setStatus("error");
        setCurrentUnderstanding(data.summary ?? null);
        setResult(normaliseStartResult(data));
      }
    } catch (err) {
      setStatus("error");
      setResult({ error: err.message || "Network request failed" });
    }
  };

  const handleUpdate = async (e) => {
    e.preventDefault();

    // Guard empty answer before showing loading state
    if (!answer?.trim()) {
      setUpdateStatus("error");
      setUpdateError({ error: "Please enter an answer before updating." });
      return;
    }

    setUpdateStatus("loading");
    setUpdateError(null);
    setLastSubmittedAnswer(answer.trim());

    const submission = await submitAnswerForUpdateCase(MOCK_ENABLED ? mockFetch : fetch, {
      situationGraph: result?.situationGraph,
      previousQuestion: result?.selectedQuestion,
      answer,
    });

    if (submission.skipped) {
      setUpdateStatus("error");
      setUpdateError(submission.data);
      return;
    }

    try {
      const outcome = submission.data;

      if (submission.ok && outcome.success) {
        setUpdateStatus("success");
        setCurrentUnderstanding(
          outcome.summary ? outcome.summary : currentUnderstanding,
        );
        setUpdateResult({
          ...outcome,
          previousSituationGraph: result?.situationGraph ?? null,
        });
        setResult((current) => ({
          ...current,
          situationGraph: outcome.updatedSituationGraph,
          selectedQuestion: normaliseUpdateSelectedQuestion(
            outcome.selectedQuestion,
          ),
          newlySurfacedNodeIds: (outcome.proposal?.addedNodes || [])
            .filter((node) => node.kind === "unknown")
            .map((node) => node.id),
          diagnostics: outcome.diagnostics,
        }));
        setAnswer("");
        // Persist after successful update turn
        saveSession({ scenario, situationGraph: outcome.updatedSituationGraph, selectedQuestion: normaliseUpdateSelectedQuestion(outcome.selectedQuestion), summary: outcome.summary ?? currentUnderstanding, updatedAt: new Date().toISOString() });
      } else {
        setUpdateStatus("error");
        setUpdateError(outcome);
      }
    } catch (err) {
      setUpdateStatus("error");
      setUpdateError({ error: err.message || "Network request failed" });
    }
  };

  return (
    <div className="space-y-6">
      {status === "idle" && (
        <form onSubmit={handleSubmit} className="space-y-4">
          <textarea
            ref={textareaRef}
            value={scenario}
            onChange={(e) => setScenario(e.target.value)}
            placeholder="Describe the scenario you want analysed..."
            rows={10}
            className="w-full rounded-lg border border-gray-300 px-4 py-3 text-sm focus:border-gray-500 focus:outline-none focus:ring-2 focus:ring-gray-400"
          />
          <div className="flex items-center justify-between">
            <span className="text-xs text-gray-400">
              {scenario.length}/{MAX_LENGTH}
            </span>
            <button
              type="submit"
              disabled={!scenario.trim()}
              className="rounded-lg bg-gray-900 px-6 py-2.5 text-sm font-medium text-white transition hover:bg-gray-700 disabled:cursor-not-allowed disabled:opacity-40"
            >
              Analyse
            </button>
          </div>
        </form>
      )}

      {status === "idle" && MOCK_ENABLED && (
        <details className="rounded-lg border border-gray-200 bg-gray-50">
          <summary className="cursor-pointer px-4 py-2 text-sm font-medium text-gray-600">Developer details</summary>
          <div className="space-y-3 px-4 pb-4">
            <div>
              <label htmlFor="mock-scenario" className="block text-xs font-medium text-gray-500 mb-1">Mock scenario</label>
              <select
                id="mock-scenario"
                value={mockScenario}
                onChange={(e) => handleScenarioSelect(e.target.value)}
                className="w-full rounded-md border border-gray-300 px-3 py-2 text-sm focus:border-gray-500 focus:outline-none focus:ring-2 focus:ring-gray-400"
              >
                <option value="">— default (env var) —</option>
                {AVAILABLE_SCENARIOS.map(function(s) {
                  return <option key={s.key} value={s.key}>{s.label}</option>;
                })}
              </select>
            </div>
            <div className="flex flex-wrap gap-2">
              {AVAILABLE_SCENARIOS.map(function(s) {
                return (
                  <button
                    key={s.key}
                    type="button"
                    onClick={() => handleScenarioFill(s.key)}
                    disabled={!scenario.trim() && scenario !== s.centralStatement}
                    className="rounded-md border border-gray-200 bg-white px-3 py-1.5 text-xs text-gray-600 hover:bg-gray-100 disabled:opacity-30"
                  >
                    {s.label} ({s.turnCount} turns)
                  </button>
                );
              })}
            </div>
          </div>
        </details>
      )}

      {/* ── Initial analysis loading card ─────────────── */}
      {status === "loading" && (
        <LoadingOverlay
          isLoading={true}
          elapsed={startElapsed}
          currentMessage={startMsg}
          variant="initial"
        />
      )}

      {/* ── Main result workspace ─────────────────────── */}
      {(status === "success" || status === "error") && (
        <ReasoningWorkspace
          scenario={scenario}
          status={status}
          updateStatus={updateStatus}
          currentUnderstanding={currentUnderstanding}
          result={{
            ...(result || {}),
            situationGraph: updateResult?.updatedSituationGraph ?? result?.situationGraph,
            selectedQuestion: updateResult?.selectedQuestion ?? result?.selectedQuestion,
            newlySurfacedNodeIds: result?.newlySurfacedNodeIds || [],
            diagnostics: result?.diagnostics || null,
            updateError,
          }}
          answer={answer}
          setAnswer={setAnswer}
          onAnswerSubmit={handleUpdate}
          lastSubmittedAnswer={lastSubmittedAnswer}
          onRestart={() => {
            clearSession();
            setStatus("idle");
            setResult(null);
            setAnswer("");
            setUpdateStatus("idle");
            setUpdateResult(null);
            setLastSubmittedAnswer("");
            setCurrentUnderstanding(null);
            setUpdateError(null);
          }}
        />
      )}

      {/* ── Continue later banner when session was restored ── */}
      {status === "success" && result?.updatedAt && (
        <ContinueLaterBanner onRestart={() => { clearSession(); setStatus("idle"); setResult(null); setAnswer(""); setUpdateStatus("idle"); setCurrentUnderstanding(null); }} />
      )}

      {/* Reset button after successful analysis */}
      {status === "success" && (
        <div className="text-center">
          <button
            onClick={() => {
              clearSession();
              setScenario("");
              setStatus("idle");
              setResult(null);
              setAnswer("");
              setUpdateStatus("idle");
              setUpdateResult(null);
              setLastSubmittedAnswer("");
              setCurrentUnderstanding(null);
              setUpdateError(null);
            }}
            className="rounded-lg border border-gray-300 px-4 py-2 text-sm font-medium text-gray-600 transition hover:bg-gray-50"
          >
            Start new investigation
          </button>
        </div>
      )}

      {/* Empty state */}
      {status === "idle" && (
        <div className="rounded-lg border border-dashed border-gray-300 bg-gray-50 px-6 py-8 text-center">
          <p className="text-sm text-gray-400">
            Enter a scenario above and click Analyse to begin.
          </p>
        </div>
      )}
    </div>
  );
}