// Subscribe
const unsubscribe = fanfare.on("queue:admitted", (data) => {
  console.log("Admitted to queue:", data.queueId);
  console.log("Token:", data.token);
});

// Later: unsubscribe
unsubscribe();

interface SDKEvents {
  // Authentication events
  "auth:authenticated": { session: Session };
  "auth:logout": void;

  // Queue events
  "queue:entered": { queueId: string; position: number };
  "queue:left": { queueId: string };
  "queue:position-changed": { queueId: string; position: number; estimatedWait: number };
  "queue:admitted": { queueId: string; token: string; expiresAt?: string };
  "queue:expired": { queueId: string };
  "queue:denied": { queueId: string; reason: string };
  "queue:error": { queueId: string; error: Error };

  // Draw events
  "draw:entered": { drawId: string };
  "draw:left": { drawId: string };
  "draw:won": { drawId: string; result: DrawResult };
  "draw:lost": { drawId: string; result: DrawResult };
  "draw:expired": { drawId: string };
  "draw:status-updated": { drawId: string };
  "draw:error": { drawId: string; error: Error };

  // Auction events
  "auction:entered": { auctionId: string };
  "auction:left": { auctionId: string };
  "auction:bid-placed": { auctionId: string; amount: string; status: string };
  "auction:outbid": { auctionId: string; highestBid: string };
  "auction:winning": { auctionId: string; amount: string; highestBid: string };
  "auction:won": { auctionId: string };
  "auction:lost": { auctionId: string; highestBid: string };
  "auction:status-updated": { auctionId: string; status: AuctionStatus };
  "auction:bid-updated": { auctionId: string; highestBid: string; bidCount: number };
  "auction:auto-rebid-enabled": { auctionId: string };
  "auction:auto-rebid-disabled": { auctionId: string };
  "auction:error": { auctionId: string; error: Error };

  // Waitlist events
  "waitlist:entered": { waitlistId: string; enteredAt: string };
  "waitlist:left": { waitlistId: string };
  "waitlist:error": { waitlistId: string; error: string };

  // Timed release events
  "timed_release:entered": { timedReleaseId: string; enteredAt: string };
  "timed_release:left": { timedReleaseId: string };
  "timed_release:completed": { timedReleaseId: string; completedAt: string };
  "timed_release:status-updated": { timedReleaseId: string };
  "timed_release:error": { timedReleaseId: string; error: Error };
}

fanfare.on("auth:authenticated", ({ session }) => {
  console.log("Session created:", session.consumerId);
  console.log("Type:", session.type);

  if (session.type === "authenticated") {
    console.log("Email:", session.email);
  }
});

fanfare.on("auth:logout", () => {
  console.log("Session ended");
  redirectToLogin();
});

fanfare.on("queue:entered", ({ queueId, position }) => {
  console.log(`Entered queue ${queueId} at position ${position}`);
});

fanfare.on("queue:left", ({ queueId }) => {
  console.log(`Left queue ${queueId}`);
});

fanfare.on("queue:position-changed", ({ queueId, position, estimatedWait }) => {
  console.log(`Position: ${position}, Wait: ${estimatedWait}s`);
  updatePositionDisplay(position, estimatedWait);
});

fanfare.on("queue:admitted", ({ queueId, token, expiresAt }) => {
  console.log("Admitted! Token:", token);
  if (expiresAt) {
    console.log("Token expires:", expiresAt);
  }
  redirectToCheckout(token);
});

fanfare.on("queue:expired", ({ queueId }) => {
  console.log("Admission expired");
  showExpiredMessage();
});

fanfare.on("queue:denied", ({ queueId, reason }) => {
  console.log("Denied:", reason);
  showDeniedMessage(reason);
});

fanfare.on("draw:entered", ({ drawId }) => {
  console.log("Entered draw:", drawId);
  showEnteredState();
});

fanfare.on("draw:won", ({ drawId, result }) => {
  console.log("Won draw:", drawId);
  console.log("Admission token:", result.admissionToken);
  showWinnerConfetti();
  redirectToCheckout(result.admissionToken);
});

fanfare.on("draw:lost", ({ drawId, result }) => {
  console.log("Did not win:", drawId);
  showBetterLuckMessage();
});

fanfare.on("draw:status-updated", ({ drawId }) => {
  // Refresh UI with latest status
  refreshDrawDisplay(drawId);
});

fanfare.on("auction:entered", ({ auctionId }) => {
  console.log("Entered auction:", auctionId);
});

fanfare.on("auction:bid-placed", ({ auctionId, amount, status }) => {
  console.log(`Bid placed: ${amount}`);
  console.log(`Status: ${status}`); // "winning" | "outbid" | "accepted"
});

fanfare.on("auction:outbid", ({ auctionId, highestBid }) => {
  console.log(`Outbid! Current highest: ${highestBid}`);
  showOutbidNotification(highestBid);
});

fanfare.on("auction:winning", ({ auctionId, amount, highestBid }) => {
  console.log("You are winning!");
  showWinningBadge();
});

fanfare.on("auction:won", ({ auctionId }) => {
  console.log("Auction won!");
  showWinnerCelebration();
});

fanfare.on("auction:lost", ({ auctionId, highestBid }) => {
  console.log(`Auction lost. Winning bid: ${highestBid}`);
  showLostMessage();
});

fanfare.on("auction:bid-updated", ({ auctionId, highestBid, bidCount }) => {
  updateBidDisplay(highestBid, bidCount);
});

fanfare.on("waitlist:entered", ({ waitlistId, enteredAt }) => {
  console.log("Joined waitlist at:", enteredAt);
  showWaitlistConfirmation();
});

fanfare.on("waitlist:left", ({ waitlistId }) => {
  console.log("Left waitlist");
});

fanfare.on("timed_release:entered", ({ timedReleaseId, enteredAt }) => {
  console.log("Entered timed release at:", enteredAt);
  redirectToShop();
});

fanfare.on("timed_release:completed", ({ timedReleaseId, completedAt }) => {
  console.log("Timed release completed!");
  showThankYouMessage();
});

fanfare.on("queue:error", ({ queueId, error }) => {
  console.error(`Queue error (${queueId}):`, error.message);
  showErrorToast(error.message);
});

fanfare.on("draw:error", ({ drawId, error }) => {
  console.error(`Draw error (${drawId}):`, error.message);
});

fanfare.on("auction:error", ({ auctionId, error }) => {
  console.error(`Auction error (${auctionId}):`, error.message);
});

fanfare.on("timed_release:error", ({ timedReleaseId, error }) => {
  console.error(`Timed release error (${timedReleaseId}):`, error.message);
});

// Analytics tracking
fanfare.on("queue:admitted", ({ queueId, token }) => {
  analytics.track("queue_admitted", { queueId });
});

// UI updates
fanfare.on("queue:admitted", ({ token }) => {
  redirectToCheckout(token);
});

// React example
useEffect(() => {
  const unsubscribes = [
    fanfare.on("queue:position-changed", handlePositionChange),
    fanfare.on("queue:admitted", handleAdmitted),
    fanfare.on("queue:error", handleError),
  ];

  return () => {
    unsubscribes.forEach((unsub) => unsub());
  };
}, [fanfare]);

// TypeScript infers data type from event name
fanfare.on("queue:admitted", (data) => {
  // data is typed as { queueId: string; token: string; expiresAt?: string }
  console.log(data.token); // string
  console.log(data.queueId); // string
});

fanfare.on("auction:bid-placed", (data) => {
  // data is typed as { auctionId: string; amount: string; status: string }
  console.log(data.amount); // string
});