import { useEffect, useState } from "react";
import {
  api, isAdministrator, isManager,
  type Entity, type EntityType, type CapitalImportPreview, type BatchCapitalImportResult,
  type BtcPricesStatus,
} from "../api";
import { useAuth } from "../context/AuthContext";
import { formatDate, formatMoneyExact } from "../format";

type EntityMode = "existing" | "from_file";

type Decision = {
  action: "match" | "create" | "skip";
  source_name: string;
  external_id: string | null;
  matched_username: string | null;
  user_id: number | null;
  value_dollars: number;
  commitment_dollars: number;
  contributions_dollars: number;
  distributions_dollars: number;
  // create fields
  name: string;
  username: string;
  email: string;
};

export default function Import() {
  const { user } = useAuth();
  const [entities, setEntities] = useState<Entity[]>([]);
  const [entityMode, setEntityMode] = useState<EntityMode>("existing");
  const [entityId, setEntityId] = useState("");
  const [createType, setCreateType] = useState<EntityType>("fund");
  const [vintageYear, setVintageYear] = useState("");
  const [password, setPassword] = useState("");
  const [file, setFile] = useState<File | null>(null);
  const [replaceExisting, setReplaceExisting] = useState(false);

  const [holdings, setHoldings] = useState<{ count: number; nav: number; sourceName: string | null } | null>(null);
  const [memberPv, setMemberPv] = useState<CapitalImportPreview | null>(null);
  const [decisions, setDecisions] = useState<Decision[]>([]);
  const [asOf, setAsOf] = useState("");

  const [result, setResult] = useState<any>(null);
  const [error, setError] = useState("");
  const [busy, setBusy] = useState(false);
  const [step, setStep] = useState("");
  const [confirmReplace, setConfirmReplace] = useState(false);

  const canImport = user && isManager(user.role);
  // An Administrator imports into their own funds only — no fund creation, and the
  // portal-wide BTC price table stays internal.
  const administrator = !!user && isAdministrator(user.role);
  const inputCls = "w-full px-3 py-2 border border-gray-300 rounded text-sm";

  useEffect(() => {
    api.listEntities().then(setEntities);
  }, []);

  function reset() {
    setHoldings(null);
    setMemberPv(null);
    setDecisions([]);
    setResult(null);
    setReplaceExisting(false);
  }

  async function readEnav() {
    if (!file) return;
    if (entityMode === "existing" && !entityId) {
      setError("Select the fund, or choose 'Create from file'.");
      return;
    }
    setError("");
    setBusy(true);
    setResult(null);
    try {
      const eid = entityMode === "existing" ? Number(entityId) : undefined;
      // Holdings (dry run) + members preview from the same file.
      const [sched, members] = await Promise.all([
        api.scheduleImport(file, {
          commit: false,
          entityId: eid,
          password: password || undefined,
          createType,
          vintageYear,
        }),
        api.capitalImportPreview(file, eid as number, undefined, password || undefined),
      ]);

      const nav = (sched.positions || []).reduce((s: number, p: any) => s + (p.value_cents || 0), 0);
      setHoldings({
        count: sched.positions?.length ?? 0,
        nav,
        sourceName: sched.source_entity_name ?? null,
      });
      setAsOf(members.as_of_date ?? sched.seed_round?.quarter_end ?? "");
      setMemberPv(members);
      setDecisions(
        members.investors.map((i) => ({
          action: i.matched_user_id ? "match" : "create",
          source_name: i.source_name,
          external_id: i.external_id,
          matched_username: i.matched_username,
          user_id: i.matched_user_id,
          value_dollars: i.value_dollars,
          commitment_dollars: i.commitment_dollars,
          contributions_dollars: i.contributions_dollars,
          distributions_dollars: i.distributions_dollars,
          name: i.source_name,
          username: i.suggested_username ?? "",
          email: "",
        })),
      );
    } catch (e: any) {
      setError(e.message || "Could not read the workbook");
      reset();
    } finally {
      setBusy(false);
    }
  }

  const update = (idx: number, patch: Partial<Decision>) =>
    setDecisions((d) => d.map((row, i) => (i === idx ? { ...row, ...patch } : row)));

  // The "Confirm import" button routes through here so a destructive holdings-replace gets a
  // final confirmation before anything is cleared.
  function handleConfirmClick() {
    if (entityMode === "existing" && replaceExisting) {
      setConfirmReplace(true);
      return;
    }
    confirmImport();
  }

  async function confirmImport() {
    if (!file || !asOf) return;
    setConfirmReplace(false);
    setError("");
    setBusy(true);
    try {
      const memberPayload = {
        as_of_date: asOf,
        investors: decisions.map((d) => ({
          action: d.action,
          value_dollars: d.value_dollars,
          commitment_dollars: d.commitment_dollars,
          contributions_dollars: d.contributions_dollars,
          distributions_dollars: d.distributions_dollars,
          user_id: d.action === "match" ? d.user_id : undefined,
          name: d.action === "create" ? d.name : undefined,
          username: d.action === "create" ? d.username : undefined,
          email: d.action === "create" ? d.email || undefined : undefined,
          external_id: d.external_id || undefined,
        })),
      };

      let resolvedEntityId: number;
      let holdingsNote = "";

      if (entityMode === "existing") {
        resolvedEntityId = Number(entityId);
        // Members first (idempotent), then holdings.
        setStep("Saving members…");
        await api.capitalImportCommit({ entity_id: resolvedEntityId, ...memberPayload });
        setStep(replaceExisting ? "Replacing holdings…" : "Loading holdings…");
        try {
          await api.scheduleImport(file, {
            commit: true,
            entityId: resolvedEntityId,
            password: password || undefined,
            asOf,
            replaceExisting,
          });
        } catch (e: any) {
          if (String(e.message).toLowerCase().includes("already exists")) {
            holdingsNote = "A signed valuation round exists for this quarter — holdings left unchanged.";
          } else {
            throw e;
          }
        }
      } else {
        // Create-from-file: holdings commit creates the fund, then members.
        setStep("Creating fund and loading holdings…");
        const sres = await api.scheduleImport(file, {
          commit: true,
          password: password || undefined,
          asOf,
          createType,
          vintageYear,
        });
        resolvedEntityId = sres.entity.entity_id;
        setStep("Saving members…");
        await api.capitalImportCommit({ entity_id: resolvedEntityId, ...memberPayload });
      }

      setResult({
        holdings: holdings?.count ?? 0,
        nav: holdings?.nav ?? 0,
        members: decisions.filter((d) => d.action !== "skip").length,
        created: decisions.filter((d) => d.action === "create").length,
        note: holdingsNote,
      });
      reset();
      api.listEntities().then(setEntities);
    } catch (e: any) {
      setError(e.message || "Import failed");
    } finally {
      setBusy(false);
      setStep("");
    }
  }

  if (!canImport) {
    return <div className="text-gray-500 text-sm">Import requires an admin role.</div>;
  }

  return (
    <div className="max-w-4xl">
      <h1 className="text-2xl font-semibold text-gray-900 mb-1">Import eNAV</h1>
      <p className="text-sm text-gray-500 mb-6">
        Upload the fund administrator's eNAV workbook once. Portal loads the fund's holdings and NAV
        (HLD tab) and the members with their capital — commitment, paid-in, distributions, and
        current value (ALLOC SI tab). You confirm new members before anything is saved.
      </p>

      {error && <div className="p-3 bg-red-50 border border-red-200 rounded text-sm text-red-700 mb-4">{error}</div>}

      {result ? (
        <div className="bg-green-50 border border-green-200 rounded-lg p-4 text-sm">
          <p className="font-medium text-green-800">Import complete.</p>
          <ul className="mt-2 text-green-700 list-disc list-inside">
            <li>{result.holdings} holdings loaded · NAV {formatMoneyExact(result.nav)}</li>
            <li>{result.members} members ({result.created} newly created)</li>
            {result.note && <li className="text-amber-700">{result.note}</li>}
          </ul>
          <button onClick={() => setResult(null)} className="mt-3 px-3 py-1.5 bg-brand-900 text-white rounded hover:bg-brand-800">
            Import another
          </button>
        </div>
      ) : (
        <div className="bg-white border border-gray-200 rounded-lg p-4 space-y-3">
          <div>
            <label className="block text-sm text-gray-700 mb-2">Fund</label>
            {!administrator && (
              <div className="flex gap-4 mb-2">
                <label className="flex items-center gap-2 text-sm text-gray-700 cursor-pointer">
                  <input type="radio" checked={entityMode === "existing"} onChange={() => { setEntityMode("existing"); reset(); }} className="text-accent-500" />
                  Use existing fund
                </label>
                <label className="flex items-center gap-2 text-sm text-gray-700 cursor-pointer">
                  <input type="radio" checked={entityMode === "from_file"} onChange={() => { setEntityMode("from_file"); reset(); }} className="text-accent-500" />
                  Create from file
                </label>
              </div>
            )}
            {entityMode === "existing" ? (
              <select value={entityId} onChange={(e) => { setEntityId(e.target.value); reset(); }} className={inputCls}>
                <option value="">Select fund…</option>
                {entities.map((e) => <option key={e.id} value={e.id}>{e.name}</option>)}
              </select>
            ) : (
              <div className="flex gap-3">
                <select value={createType} onChange={(e) => setCreateType(e.target.value as EntityType)} className={inputCls}>
                  <option value="fund">Fund</option>
                  <option value="spv">SPV</option>
                  <option value="gp">GP</option>
                  <option value="mgmt_co">Mgmt Co</option>
                  <option value="carry">Carry Vehicle</option>
                </select>
                <input className={inputCls} placeholder="Vintage year" value={vintageYear} onChange={(e) => setVintageYear(e.target.value)} />
              </div>
            )}
          </div>

          <div className="grid grid-cols-2 gap-3">
            <div>
              <label className="block text-xs text-gray-500 mb-1">eNAV workbook (.xlsx)</label>
              <input type="file" accept=".xlsx" onChange={(e) => { setFile(e.target.files?.[0] ?? null); reset(); }} className="text-sm" />
            </div>
            <div>
              <label className="block text-xs text-gray-500 mb-1">Spreadsheet password</label>
              <input type="text" className={inputCls} value={password} placeholder="If the file is protected" autoComplete="off" onChange={(e) => { setPassword(e.target.value); reset(); }} />
            </div>
          </div>

          <div className="flex justify-end">
            <button onClick={readEnav} disabled={busy || !file} className="px-3 py-1.5 bg-brand-900 text-white text-sm rounded hover:bg-brand-800 disabled:opacity-50">
              {busy ? "Reading…" : "Read eNAV"}
            </button>
          </div>
        </div>
      )}

      {memberPv && !result && (
        <div className="mt-6 space-y-4">
          {/* Holdings summary */}
          <div className="bg-white border border-gray-200 rounded-lg p-4 text-sm flex items-center gap-6">
            <div>
              <span className="text-gray-500">Holdings: </span>
              <span className="text-gray-900 font-medium">{holdings?.count ?? 0}</span>
            </div>
            <div>
              <span className="text-gray-500">Fund NAV: </span>
              <span className="text-gray-900 font-medium">{formatMoneyExact(holdings?.nav ?? 0)}</span>
            </div>
            <div className="ml-auto">
              <label className="text-xs text-gray-500 mr-2">As-of</label>
              <input type="date" className="px-2 py-1 border border-gray-300 rounded text-sm" value={asOf} onChange={(e) => setAsOf(e.target.value)} />
            </div>
          </div>

          {entityMode === "existing" && (
            <label className="flex items-start gap-2 text-sm text-gray-700 bg-amber-50 border border-amber-200 rounded-lg p-3">
              <input
                type="checkbox"
                className="mt-0.5"
                checked={replaceExisting}
                onChange={(e) => setReplaceExisting(e.target.checked)}
              />
              <span>
                <span className="font-medium">Replace existing holdings</span> — clear this fund's
                current holdings, positions, and valuation history first, then rebuild from this file.
                Use after switching source workbooks (e.g. Carta → eNAV) renamed the positions.
                Investor capital accounts are not affected.
              </span>
            </label>
          )}

          {/* Members review */}
          <div className="bg-white border border-gray-200 rounded-lg overflow-hidden">
            <table className="w-full text-sm">
              <thead className="bg-gray-50 text-gray-500 text-left">
                <tr>
                  <th className="px-3 py-2 font-medium">Member</th>
                  <th className="px-3 py-2 font-medium text-right">Commitment</th>
                  <th className="px-3 py-2 font-medium text-right">Paid-in</th>
                  <th className="px-3 py-2 font-medium text-right">Distrib.</th>
                  <th className="px-3 py-2 font-medium text-right">Value</th>
                  <th className="px-3 py-2 font-medium">Action</th>
                  <th className="px-3 py-2 font-medium">New account</th>
                </tr>
              </thead>
              <tbody>
                {decisions.map((d, i) => (
                  <tr key={i} className="border-t border-gray-100 align-top">
                    <td className="px-3 py-2 text-gray-900">{d.source_name}</td>
                    <td className="px-3 py-2 text-right text-gray-600">{formatMoneyExact(Math.round(d.commitment_dollars * 100))}</td>
                    <td className="px-3 py-2 text-right text-gray-600">{formatMoneyExact(Math.round(d.contributions_dollars * 100))}</td>
                    <td className="px-3 py-2 text-right text-gray-600">{formatMoneyExact(Math.round(d.distributions_dollars * 100))}</td>
                    <td className="px-3 py-2 text-right text-gray-900">{formatMoneyExact(Math.round(d.value_dollars * 100))}</td>
                    <td className="px-3 py-2">
                      <select className="px-2 py-1 border border-gray-300 rounded text-sm" value={d.action} onChange={(e) => update(i, { action: e.target.value as Decision["action"] })}>
                        {d.user_id != null && <option value="match">Match {d.matched_username}</option>}
                        <option value="create">Create new</option>
                        <option value="skip">Skip</option>
                      </select>
                    </td>
                    <td className="px-3 py-2">
                      {d.action === "create" ? (
                        <div className="flex gap-2">
                          <input className="px-2 py-1 border border-gray-300 rounded text-sm w-28" placeholder="Username" value={d.username} onChange={(e) => update(i, { username: e.target.value })} />
                          <span className="text-xs text-gray-400 self-center">no login until set</span>
                        </div>
                      ) : d.action === "match" ? (
                        <span className="text-xs text-gray-500">updates {d.matched_username}</span>
                      ) : (
                        <span className="text-xs text-gray-400">ignored</span>
                      )}
                    </td>
                  </tr>
                ))}
              </tbody>
            </table>
          </div>

          <div className="flex items-center justify-end gap-3">
            <span className="text-xs text-gray-400">
              {decisions.filter((d) => d.action === "create").length} new ·{" "}
              {decisions.filter((d) => d.action === "match").length} matched ·{" "}
              {decisions.filter((d) => d.action === "skip").length} skipped
            </span>
            <button onClick={handleConfirmClick} disabled={busy || !asOf} className="px-4 py-1.5 bg-brand-900 text-white text-sm rounded hover:bg-brand-800 disabled:opacity-50">
              {busy ? (step || "Importing…") : "Confirm import"}
            </button>
          </div>
        </div>
      )}

      {!memberPv && !result && <BatchBackfill entities={entities} />}

      {!memberPv && !result && !administrator && <BtcPrices />}

      {confirmReplace && (
        <div className="fixed inset-0 bg-black/40 flex items-center justify-center p-4 z-50">
          <div className="bg-white rounded-lg p-6 max-w-md w-full">
            <h3 className="text-sm font-semibold text-gray-900 mb-2">Replace existing holdings?</h3>
            <p className="text-sm text-gray-600">
              This will permanently clear this fund's current holdings, positions, and valuation
              history, then rebuild them from this file. Investor capital accounts are not
              affected. This can't be undone.
            </p>
            <div className="flex justify-end gap-2 mt-5">
              <button
                onClick={() => setConfirmReplace(false)}
                className="px-4 py-1.5 border border-gray-300 text-sm rounded hover:bg-gray-50"
              >
                Cancel
              </button>
              <button
                onClick={confirmImport}
                className="px-4 py-1.5 bg-red-600 text-white text-sm rounded hover:bg-red-700"
              >
                Replace and import
              </button>
            </div>
          </div>
        </div>
      )}
    </div>
  );
}

// Backfill several past quarters of investor capital in one shot. Each eNAV file's ALLOC SI
// roster is auto-matched to existing members and their statement is written at the file's own
// as-of date, so older files add trend-line history without disturbing the latest figures.
// Members not already in the system are skipped (never created here) and reported per file.
function BatchBackfill({ entities }: { entities: Entity[] }) {
  const [entityId, setEntityId] = useState("");
  const [files, setFiles] = useState<File[]>([]);
  const [password, setPassword] = useState("");
  const [busy, setBusy] = useState(false);
  const [error, setError] = useState("");
  const [result, setResult] = useState<BatchCapitalImportResult | null>(null);

  const inputCls = "w-full px-3 py-2 border border-gray-300 rounded text-sm";

  async function run() {
    if (!entityId || files.length === 0) {
      setError("Pick a fund and at least one eNAV file.");
      return;
    }
    setError("");
    setResult(null);
    setBusy(true);
    try {
      setResult(await api.capitalImportBatch(Number(entityId), files, password || undefined));
    } catch (e: any) {
      setError(e.message || "Batch import failed");
    } finally {
      setBusy(false);
    }
  }

  return (
    <div className="mt-10 border-t border-gray-200 pt-8">
      <h2 className="text-lg font-semibold text-gray-900 mb-1">Backfill historical capital</h2>
      <p className="text-sm text-gray-500 mb-4 max-w-3xl">
        Load several past quarters at once to build investors' trend-lines. Drop the eNAV
        workbooks for one fund; each file's members are matched to existing accounts and their
        capital statement is saved at that file's own as-of date. The latest figures are never
        replaced, and members not already in the portal are skipped (not created).
      </p>

      {error && <div className="p-3 bg-red-50 border border-red-200 rounded text-sm text-red-700 mb-4">{error}</div>}

      <div className="bg-white border border-gray-200 rounded-lg p-4 space-y-3">
        <div>
          <label className="block text-sm text-gray-700 mb-1">Fund</label>
          <select value={entityId} onChange={(e) => setEntityId(e.target.value)} className={inputCls}>
            <option value="">Select fund…</option>
            {entities.map((e) => <option key={e.id} value={e.id}>{e.name}</option>)}
          </select>
        </div>
        <div className="grid grid-cols-2 gap-3">
          <div>
            <label className="block text-xs text-gray-500 mb-1">eNAV workbooks (.xlsx — select several)</label>
            <input
              type="file"
              accept=".xlsx"
              multiple
              onChange={(e) => { setFiles(Array.from(e.target.files ?? [])); setResult(null); }}
              className="text-sm"
            />
            {files.length > 0 && <p className="text-xs text-gray-400 mt-1">{files.length} file(s) selected</p>}
          </div>
          <div>
            <label className="block text-xs text-gray-500 mb-1">Spreadsheet password</label>
            <input
              type="text"
              className={inputCls}
              value={password}
              placeholder="Shared open password, if protected"
              autoComplete="off"
              onChange={(e) => setPassword(e.target.value)}
            />
          </div>
        </div>
        <div className="flex justify-end">
          <button
            onClick={run}
            disabled={busy || !entityId || files.length === 0}
            className="px-3 py-1.5 bg-brand-900 text-white text-sm rounded hover:bg-brand-800 disabled:opacity-50"
          >
            {busy ? "Loading history…" : "Load history"}
          </button>
        </div>
      </div>

      {result && (
        <div className="mt-4 bg-white border border-gray-200 rounded-lg overflow-hidden">
          <div className="px-4 py-2 bg-gray-50 text-sm text-gray-600 border-b border-gray-100">
            {result.total_statements} statement(s) written across {result.files.length} file(s)
          </div>
          <table className="w-full text-sm">
            <thead className="text-gray-500 text-left">
              <tr>
                <th className="px-4 py-2 font-medium">File</th>
                <th className="px-4 py-2 font-medium">As-of</th>
                <th className="px-4 py-2 font-medium text-right">Loaded</th>
                <th className="px-4 py-2 font-medium">Skipped (no account)</th>
              </tr>
            </thead>
            <tbody>
              {result.files.map((f, i) => (
                <tr key={i} className="border-t border-gray-100 align-top">
                  <td className="px-4 py-2 text-gray-900">{f.filename}</td>
                  <td className="px-4 py-2 text-gray-600">{f.as_of_date ? formatDate(f.as_of_date) : "—"}</td>
                  <td className="px-4 py-2 text-right text-gray-900">
                    {f.error ? "—" : f.statements_written}
                  </td>
                  <td className="px-4 py-2 text-gray-500">
                    {f.error ? (
                      <span className="text-red-600">{f.error}</span>
                    ) : f.skipped.length === 0 ? (
                      <span className="text-gray-400">none</span>
                    ) : (
                      <span title={f.skipped.join(", ")}>
                        {f.skipped.length}: {f.skipped.slice(0, 3).join(", ")}
                        {f.skipped.length > 3 ? "…" : ""}
                      </span>
                    )}
                  </td>
                </tr>
              ))}
            </tbody>
          </table>
        </div>
      )}
    </div>
  );
}

// BTC/USD price history for the bitcoin-denominated LP view: upload a CSV (date + close
// price); statements are valued at the newest price on or before their date, and paid-in
// at the price on each fund's close date (set on the fund's overview page).
function BtcPrices() {
  const [status, setStatus] = useState<BtcPricesStatus | null>(null);
  const [file, setFile] = useState<File | null>(null);
  const [busy, setBusy] = useState(false);
  const [error, setError] = useState("");
  const [msg, setMsg] = useState("");

  useEffect(() => {
    api.btcPricesStatus().then(setStatus).catch(() => {});
  }, []);

  async function run() {
    if (!file) return;
    setError("");
    setMsg("");
    setBusy(true);
    try {
      const r = await api.importBtcPrices(file);
      setStatus(r);
      setMsg(
        `Loaded ${r.imported} price${r.imported === 1 ? "" : "s"}` +
          (r.skipped_rows ? ` (${r.skipped_rows} unreadable row${r.skipped_rows === 1 ? "" : "s"} skipped)` : "") +
          ".",
      );
      setFile(null);
    } catch (e: any) {
      setError(e.message || "Price import failed");
    } finally {
      setBusy(false);
    }
  }

  return (
    <div className="mt-10 border-t border-gray-200 pt-8">
      <h2 className="text-lg font-semibold text-gray-900 mb-1">Bitcoin prices</h2>
      <p className="text-sm text-gray-500 mb-3">
        Upload a CSV of BTC/USD prices (a date column and a close/price column). Investors
        then see their capital in bitcoin terms; paid-in is valued at the price on each
        fund's close date — set that on the fund's overview page.
      </p>
      {status && status.count > 0 && (
        <p className="text-xs text-gray-400 mb-3">
          {status.count} prices on file
          {status.first_date && status.last_date && (
            <> · {formatDate(status.first_date)} → {formatDate(status.last_date)}</>
          )}
          {status.latest_price_cents != null && (
            <> · latest ${(status.latest_price_cents / 100).toLocaleString()}</>
          )}
        </p>
      )}
      <div className="flex flex-wrap items-center gap-3">
        <input
          type="file"
          accept=".csv"
          onChange={(e) => setFile(e.target.files?.[0] ?? null)}
          className="text-sm"
        />
        <button
          onClick={run}
          disabled={busy || !file}
          className="px-3 py-1.5 bg-brand-900 text-white text-sm rounded hover:bg-brand-800 disabled:opacity-50"
        >
          {busy ? "Loading…" : "Load prices"}
        </button>
      </div>
      {error && <p className="text-sm text-red-600 mt-2">{error}</p>}
      {msg && <p className="text-sm text-green-700 mt-2">{msg}</p>}
    </div>
  );
}
