// Type definitions for the Inngame web SDK (inngame.js).
// Use with a <script> tag (global `Inngame`) or `const Inngame = require("./inngame.js")`.

interface InngameIdentity {
  /** Your game's player id. Without `token` it's only a label: it never merges players across devices. */
  userId?: string;
  name?: string;
  email?: string;
  /** HS256 JWT signed by your server with the app's identity secret (sub = userId). */
  token?: string;
  /** Free fields shown on the player card and usable in automations ("level", "vip"…). */
  metadata?: Record<string, unknown>;
}

interface InngameItem {
  /** The message that carried the item card. */
  messageId: string;
  id: string;
  name: string;
  quantity: number;
}

interface InngameOptions {
  /** Public key from inbox → Settings → Apps (starts with `app_`). */
  appKey: string;
  /** Server URL. Default: https://app.inngame.app */
  baseUrl?: string;
  /** BCP 47 language for the chat and translations. Default: the browser language. */
  language?: string;
  /** Shown in the conversation context (your build number). */
  appVersion?: string;
  /** Identify the player at startup (same as calling identify()). */
  user?: InngameIdentity;
  /** Show the floating button. Set false to open the chat from your own menu. Default: true. */
  launcher?: boolean;
  position?: "right" | "left";
  /** Default: follows the system setting. */
  theme?: "light" | "dark" | "auto";
  zIndex?: number;
  /** Attach the last console errors and warnings to each message. Default: true. */
  captureLogs?: boolean;
  /** Game state attached to each message (level, mode…). Keep it small. */
  context?: () => Record<string, unknown> | null | undefined;
  /** The player claimed a compensation item: grant it in your game. Without this, item cards stay disabled. */
  onItemGranted?: (item: InngameItem) => void;
  /** Offer card tapped: show your paywall or store page for this offer id. */
  onOffer?: (offerId: string | undefined) => void;
  /** Screen card tapped: navigate to this screen of your game. */
  onScreen?: (screen: string | undefined, value: string | undefined) => void;
  /** "Restore purchases" card tapped. */
  onRestorePurchases?: () => void;
}

interface InngamePlayer {
  /** Inngame's id for this player. */
  id: string;
  name: string | null;
  /** True when identified with a signed token or Steam. */
  verified: boolean;
  /** Linked to your userId or a Steam account. */
  identified: boolean;
  language: string | null;
  blocked: boolean;
  /** Pass to your store as appAccountToken / obfuscatedAccountId to match purchases. */
  purchaseToken: string | null;
}

interface InngameMessage {
  id?: string;
  clientId?: string;
  authorType: "user" | "team" | "ai" | "system";
  body: string;
  createdAt: number;
  [key: string]: unknown;
}

interface InngameEvents {
  unread: number;
  message: InngameMessage;
  open: undefined;
  close: undefined;
}

interface InngameSDK {
  readonly version: string;
  /** Starts the SDK once; later calls return the same promise. */
  init(options: InngameOptions): Promise<void>;
  open(): void;
  close(): void;
  toggle(): void;
  readonly isOpen: boolean;
  /** Unread replies, for a badge on your own Help button. */
  readonly unread: number;
  readonly user: InngamePlayer | null;
  /** Remote settings (appearance, announcement, availability), refreshed when the team changes them. */
  readonly config: Record<string, unknown> | null;
  /** Resolves null while support is unavailable (the identity is kept for the next session). */
  identify(identity: InngameIdentity): Promise<InngamePlayer | null>;
  /** Game event for automations. Resolves true if an automation opened the chat (false while support is unavailable). */
  track(name: string, props?: Record<string, unknown>, opensChat?: boolean): Promise<boolean>;
  /** Back to a new anonymous player on this browser. */
  logout(): Promise<void>;
  /** Erases the player and their conversations on the server. Resolves true, or false while support is unavailable (nothing erased). */
  deleteData(): Promise<boolean>;
  /**
   * True while the studio's support is unavailable (its Inngame workspace is suspended): the chat shows
   * "Support is unavailable right now", unsent messages wait, and the SDK checks again every 10 minutes while
   * the chat is open and at each open. Back to normal on its own when support is available again.
   */
  isUnavailable(): boolean;
  /** Returns a function that removes the listener. */
  on<K extends keyof InngameEvents>(event: K, fn: (value: InngameEvents[K]) => void): () => void;
}

declare const Inngame: InngameSDK;
declare namespace Inngame {
  export type Options = InngameOptions;
  export type Identity = InngameIdentity;
  export type Item = InngameItem;
  export type Player = InngamePlayer;
  export type Message = InngameMessage;
  export type SDK = InngameSDK;
}
export = Inngame;

declare global {
  interface Window { Inngame: InngameSDK }
}