import type {
  FanfareConfig,
  FanfareSDK,
  Session,
  Queue,
  QueueConsumerState,
  Draw,
  DrawResult,
  AuctionDetails,
  BidResult,
  ExperienceJourney,
  JourneySnapshot,
} from "@waitify-io/fanfare-sdk-core";

interface FanfareConfig {
  organizationId: string;
  publishableKey: string;
  environment?: "production" | "staging" | "development";
  apiUrl?: string;
  debug?: boolean;
  auth?: {
    persistSession?: boolean;
    sessionDuration?: number;
  };
  logging?: {
    level?: "error" | "warn" | "info" | "debug" | "metrics";
  };
  sync?:
    | boolean
    | {
        enabled?: boolean;
        syncKeys?: string[];
        channelName?: string;
      };
  features?: {
    fingerprinting?: boolean;
  };
  beacon?: BeaconConfig;
}

interface BeaconConfig {
  enabled?: boolean;
  batchSize?: number;
  flushInterval?: number;
  maxRetries?: number;
}

interface Session {
  type: "guest" | "authenticated";
  consumerId: string;
  email?: string;
  phone?: string;
  expiresAt: string;
  deviceFingerprint?: string;
}

interface GuestSession extends Session {
  type: "guest";
  guestId: string;
  email: undefined;
}

interface AuthenticatedSession extends Session {
  type: "authenticated";
  email?: string;
  phone?: string;
}

interface AuthStatus {
  isAuthenticated: boolean;
  isGuest?: boolean;
  session?: Session;
}

interface OtpRequest {
  email?: string;
  phone?: string;
  defaultCountry?: string;
  name?: string;
}

interface OtpVerify {
  email?: string;
  phone?: string;
  code: string;
  defaultCountry?: string;
}

interface ExternalExchange {
  exchangeCode: string;
}

interface LoginOptions {
  email: string;
}

interface Queue {
  id: string;
  experienceId: string;
  name: string;
  status: "pending" | "open" | "closed" | "paused";
  capacity?: number;
  currentSize: number;
  estimatedWaitTime?: number;
  openAt?: string;
  closeAt?: string;
}

interface QueueEnterResult {
  position: number;
  estimatedWaitTimeInSeconds: number;
  status: "QUEUED";
}

type QueueConsumerState =
  | QueuedConsumerState
  | AdmittedConsumerState
  | CompletedConsumerState
  | LeftConsumerState
  | DeniedConsumerState
  | NotQueuedConsumerState
  | ExpiredConsumerState;

interface QueuedConsumerState {
  status: "QUEUED";
  position: number;
  estimatedWaitTimeInSeconds: number;
}

interface AdmittedConsumerState {
  status: "ADMITTED";
  admissionToken: string;
  position?: number;
  dequeuedAt?: string;
  expiresAt?: string;
}

interface CompletedConsumerState {
  status: "COMPLETED";
  admissionToken: string;
  completedAt?: string;
  position?: number;
}

interface LeftConsumerState {
  status: "LEFT";
  dequeuedAt?: string;
  position?: number;
}

interface DeniedConsumerState {
  status: "DENIED";
  reason: string;
  dequeuedAt?: string;
  position?: number;
}

interface NotQueuedConsumerState {
  status: "NOT_QUEUED";
  dequeuedAt?: string;
  position?: number;
}

interface ExpiredConsumerState {
  status: "EXPIRED";
  expiredAt?: string;
  position?: number;
}

interface QueueParticipation {
  queueId: string;
  enteredAt: string;
  status: "QUEUED" | "ADMITTED" | "COMPLETED" | "LEFT" | "DENIED" | "NOT_QUEUED" | "EXPIRED";
  position?: number;
  estimatedWaitTime?: number;
  metadata?: Record<string, unknown>;
  admissionToken?: string;
  admittedAt?: string;
  expiresAt?: string;
}

interface Draw {
  id: string;
  openAt?: string | null;
  closeAt?: string | null;
  timeZone: string;
  supportsGuest: boolean;
  drawAt: string;
  capacity?: number | null;
  continueSelectingUntilCompleted?: boolean | null;
}

type DrawConsumerState = DrawNotEnteredState | DrawEnteredState | DrawWonState | DrawCompletedState | DrawDeniedState;

interface DrawNotEnteredState {
  status: "NOT_ENTERED";
}

interface DrawEnteredState {
  status: "ENTERED";
}

interface DrawWonState {
  status: "WON";
  wonAt: string;
  admissionToken: string;
  fingerprint?: string;
}

interface DrawCompletedState {
  status: "COMPLETED";
  completedAt: string;
  admissionToken: string;
  fingerprint?: string;
}

interface DrawDeniedState {
  status: "DENIED";
  reason: string;
  deniedAt: string;
}

interface DrawResult {
  won: boolean;
  drawTime: string;
  admissionToken?: string;
  prizeDetails?: Record<string, unknown>;
  nextSteps?: string;
}

interface DrawParticipation {
  drawId: string;
  enteredAt: string;
  status: "entered" | "drawn" | "won" | "lost" | "expired";
  entryNumber?: string;
  metadata?: Record<string, unknown>;
  result?: DrawResult;
  checkedAt?: string;
  fingerprint?: string;
}

interface AuctionDetails {
  id: string;
  openAt?: string | null;
  closeAt?: string | null;
  settleAt: string;
  currencyCode: string;
  reservePrice?: string | null;
  minBidIncrement?: string | null;
  autoExtendSeconds?: number | null;
  timeZone: string;
  supportsGuest: boolean;
}

interface AuctionStatus {
  auctionId: string;
  status: "winning" | "outbid" | "watching";
  currentBid?: string;
  highestBid: string;
  timeRemaining: number;
  bidCount?: number;
  position?: number;
}

interface Bid {
  id?: string;
  amount: string;
  timestamp: string;
  isWinning: boolean;
  bidderAlias?: string;
  isYours?: boolean;
}

interface BidResult {
  status: "winning" | "outbid" | "accepted";
  amount: string;
  highestBid: string;
  bidCount: number;
  position?: number;
}

interface AutoRebidConfig {
  enabled: boolean;
  maxBid: string;
  increment: string;
  remainingBudget?: string;
  lastRebidAt?: string;
  rebidCount?: number;
}

interface AuctionParticipation {
  auctionId: string;
  enteredAt: string;
  status: "watching" | "bidding" | "winning" | "outbid" | "won" | "lost";
  currentBid?: string;
  highestBid?: string;
  bidCount?: number;
  lastBidAt?: string;
  metadata?: Record<string, unknown>;
  fingerprint?: string;
}

interface WaitlistStatus {
  waitlistId: string;
  isEntered: boolean;
  enteredAt?: string;
}

interface WaitlistEntry {
  id: string;
  waitlistId: string;
  sequenceId: string;
  consumerId: string;
  enteredAt: string;
}

interface WaitlistParticipation {
  id: string;
  waitlistId: string;
  sequenceId: string;
  isEntered: boolean;
  enteredAt?: string;
}

interface TimedRelease {
  id: string;
  openAt?: string;
  closeAt?: string;
  timeZone: string;
  supportsGuest: boolean;
}

type TimedReleaseConsumerState =
  | TimedReleaseNotEnteredState
  | TimedReleaseEnteredState
  | TimedReleaseCompletedState
  | TimedReleaseLeftState;

interface TimedReleaseNotEnteredState {
  status: "NOT_ENTERED";
}

interface TimedReleaseEnteredState {
  status: "ENTERED";
  enteredAt: string;
  selectedVariantId?: string;
}

interface TimedReleaseCompletedState {
  status: "COMPLETED";
  completedAt: string;
  selectedVariantId?: string;
}

interface TimedReleaseLeftState {
  status: "LEFT";
  leftAt: string;
}

interface TimedReleaseParticipation {
  timedReleaseId: string;
  enteredAt: string;
  status: "entered" | "completed" | "left";
  selectedVariantId?: string;
  metadata?: Record<string, unknown>;
}

type JourneyStage = "not_started" | "entering" | "needs_auth" | "needs_access_code" | "routing" | "routed";

type SequenceStage =
  | "none"
  | "upcoming"
  | "waitlist_entered"
  | "active_enterable"
  | "participating"
  | "admitted"
  | "admission_expired"
  | "ended";

interface JourneySnapshot {
  revision: number;
  updatedAt: number;
  journeyStage: JourneyStage;
  sequenceStage: SequenceStage;
  requirements: Requirement[];
  availableActions: {
    journey: JourneyAction[];
    sequence: SequenceAction[];
  };
  context: JourneyContext;
  events: JourneyEvent[];
  lastSeenEventId?: string;
}

interface Requirement {
  type: "authentication" | "access_code" | "bot_check";
  required: boolean;
  reason?: string;
  metadata?: Record<string, unknown>;
}

interface JourneyContext {
  experienceId: string;
  experience?: ExperienceSession;
  sequenceId?: string;
  distribution?: DistributionSummary;
  participation?: {
    id: string;
    type: "queue" | "draw" | "auction" | "waitlist" | "timed_release";
  };
  accessCode?: string;
  admittanceToken?: string;
  admittanceExpiresAt?: number;
}

interface JourneyEvent {
  id: string;
  ts: number;
  kind: "reroute" | "sequence_change" | "distribution_change" | "requirement" | "error" | "info";
  severity: "info" | "success" | "warning" | "error";
  audience: "user" | "system" | "analytics";
  message: string;
  detail?: Record<string, unknown>;
}

type JourneyAction =
  | "start"
  | "authenticate"
  | "provide_access_code"
  | "skip_access_code"
  | "request_reroute"
  | "retry"
  | "complete_bot_check"
  | "refresh_distribution";

type SequenceAction =
  | "enter_waitlist"
  | "leave_waitlist"
  | "enter_queue"
  | "enter_draw"
  | "enter_auction"
  | "enter_timed_release"
  | "complete_timed_release"
  | "leave_participation";

interface FanfareSDK {
  readonly auth: AuthModule;
  readonly queues: QueueModule;
  readonly draws: DrawModule;
  readonly auctions: AuctionModule;
  readonly experiences: ExperienceModule;
  readonly waitlists: WaitlistModule;
  readonly timedReleases: TimedReleaseModule;
  readonly beacon: BeaconModule;

  restore(): Promise<RestoreResult>;
  resume(): Promise<void>;
  getActiveExperiences(): Promise<ActiveExperiences>;
  on<K extends keyof SDKEvents>(event: K, handler: (data: SDKEvents[K]) => void): () => void;
  destroy(): Promise<void>;
}

interface RestoreResult {
  session: Session | null;
  experiences: {
    queues: Record<string, QueueParticipation>;
    draws: Record<string, DrawParticipation>;
    auctions: Record<string, AuctionParticipation>;
    appointments: Record<string, unknown>;
    waitlists: Record<string, WaitlistParticipation>;
    timedReleases: Record<string, TimedReleaseParticipation>;
    experiences: Record<string, ExperienceSession>;
  };
}

interface ActiveExperiences {
  queues: string[];
  draws: string[];
  auctions: string[];
  appointments: string[];
  waitlists: string[];
  timedReleases: string[];
  experiences: string[];
}

interface Consumer {
  id: string;
  email?: string;
  createdAt: string;
  metadata?: Record<string, unknown>;
}