Type Definitions

interface PlaycastUser {
  id: string;                    // Unique user identifier
  authId: string;               // Authentication provider ID
  displayName: string;          // User's display name
  avatar?: string;              // Avatar URL (optional)
  platform: IdentityPlatform;  // Authentication platform
  profile?: UserProfile;        // Extended profile information
}

type Vector2 = {
  x: number;  // X coordinate
  y: number;  // Y coordinate
}

type Serializable =
  | string
  | number
  | boolean
  | null
  | undefined
  | Serializable[]
  | { [key: string]: Serializable }

interface StateStore<T> {
  get(): T;                              // Get current value
  set(value: T): void;                   // Set new value
  subscribe(callback: (value: T) => void): () => void; // Subscribe to changes
  update(updater: (current: T) => T): void; // Update with function
}

type PlaycastMessage<T extends PlaycastMessageTarget> = {
  signature: string;                     // Message signature
  header: PlaycastMessageHeader & Pick<T, 'target' | 'action' | 'isReply'>;
  body: {
    message: T['message'];              // Message payload
    timings: PlaycastTimingEntry[];     // Performance timings
    stats: PlaycastNameValuePair[];     // Statistics data
    echo: boolean;                      // Echo flag
  };
}

interface PlaycastMessageHeader {
  tag: string;                    // Unique message tag
  source: PlaycastMessageSource; // Message source
  schemaVersion: 5;              // Message schema version
  timestamp: number;             // Unix timestamp
  user: PlaycastUser;            // User context
}

interface PlaycastTimingEntry {
  app: PlaycastMessageSource;        // Application that recorded timing
  timestamp: number;                 // When timing was recorded
  description: string;               // Description of the timing point
  metadata: Record<string, string>; // Additional metadata
}

type WebsocketMessage =
  | AuthMessage
  | ConnectionMessage
  | HostMessage
  | InvitationMessage
  | MetricsMessage
  | LobbyMessage
  | PeerMessage
  | PresenceMessage
  | SystemMessage
  | OutboundMessage
  | ProfileMessage
  | MatchmakingMessage
  | UserEventMessage
  | AnalyticsMessage
  | NotificationMessage
  | AdminMessage
  | VpnMessage;

interface PlaycastPeerBase {
  peerId: string;                                    // Unique peer identifier
  qualityPresetStore: StateStore<PlaycastWebrtcPresetGroup>;
  changeQualityProfile: (profile: PlaycastDefaultProfiles) => void;
  setQualityPreset: (channel: PlaycastChannels, preset: Partial<PlaycastWebrtcPreset>) => void;
  setQualityPresetGroup: (presetGroup: PlaycastWebrtcPresetGroup) => void;
  handlePeerMessage: (message: PeerMessage) => void;
  close: (kickReason?: string) => void;
}

interface PlaycastWebrtcStats {
  bitrate: number;                    // Current bitrate (bps)
  packetLoss: number;                // Packet loss ratio (0-1)
  roundTripTime: number;             // RTT in milliseconds
  jitter: number;                    // Jitter in milliseconds
  frameRate: number;                 // Current frame rate
  resolution: {                      // Current resolution
    width: number;
    height: number;
  };
  codecName: string;                 // Active codec name
  bandwidth: number;                 // Available bandwidth
}

interface PlaycastWebrtcPreset {
  maxBitrate: number;               // Maximum bitrate (bps)
  maxFramerate?: number;            // Maximum frame rate
  scaleResolutionDownBy?: number;   // Resolution scaling factor
  minBitrate?: number;              // Minimum bitrate (bps)
  startBitrate?: number;            // Starting bitrate (bps)
}

type PlaycastTrackSet = {
  [trackName: string]: MediaStreamTrack | null;
}

interface PlaycastPeerClientMetadata {
  userId: string;              // User identifier
  displayName: string;         // User's display name
  avatar?: string;            // Avatar URL
  browserType: string;        // Browser type
  browserVersion: string;     // Browser version
  os: string;                 // Operating system
  deviceType: 'mobile' | 'desktop' | 'tablet';
  isAppleDevice: boolean;     // Apple device flag
  connectionType: string;     // Connection type
  networkQuality?: 'poor' | 'good' | 'excellent';
}

interface PlaycastPeerHostMetadata {
  hostId: string;             // Host identifier
  sessionId: string;          // Session identifier
  gameTitle?: string;         // Game being hosted
  maxClients: number;         // Maximum client connections
  currentClients: number;     // Current client count
  hostCapabilities: {         // Host capabilities
    video: boolean;
    audio: boolean;
    input: boolean;
    fileTransfer: boolean;
  };
}

interface PlaycastGamepadInput {
  buttons: {                  // Button states
    [button: string]: {
      pressed: boolean;       // Is button pressed
      value: number;          // Button pressure (0-1)
    };
  };
  axes: {                    // Analog stick/trigger values
    leftStick: Vector2;      // Left stick (-1 to 1)
    rightStick: Vector2;     // Right stick (-1 to 1)
    leftTrigger: number;     // Left trigger (0-1)
    rightTrigger: number;    // Right trigger (0-1)
  };
  timestamp: number;         // Input timestamp
}

interface PlaycastMouseInput {
  position: Vector2;          // Current mouse position
  deltaPosition: Vector2;     // Movement delta
  buttons: {                  // Button states
    left: boolean;
    right: boolean;
    middle: boolean;
  };
  wheelDelta: {              // Scroll wheel
    x: number;
    y: number;
  };
  timestamp: number;         // Input timestamp
}

interface PlaycastKeyboardInput {
  key: string;               // Key identifier
  code: string;              // Physical key code
  pressed: boolean;          // Key press state
  repeat: boolean;           // Is key repeat
  modifiers: {               // Modifier keys
    ctrl: boolean;
    alt: boolean;
    shift: boolean;
    meta: boolean;
  };
  timestamp: number;         // Input timestamp
}

enum IdentityPlatform {
  DISCORD = 'discord',
  TWITCH = 'twitch',
  CLERK = 'clerk'
}

type PlaycastDefaultProfiles =
  | 'ultra'    // Highest quality
  | 'high'     // High quality
  | 'medium'   // Balanced quality
  | 'low'      // Lower quality for bandwidth saving
  | 'potato'   // Lowest quality for poor connections

type PlaycastMessageSource =
  | 'player'      // Player/client application
  | 'host'        // Host application
  | 'playjector'  // Native Playjector process

type PlaycastWindowState =
  | 'minimized'   // Window is minimized
  | 'maximized'   // Window is maximized
  | 'normal'      // Window is in normal state
  | 'closed'      // Window is closed

interface NonSerializableStateStore<T> {
  get(): T;                              // Get current value
  set(value: T): void;                   // Set new value
  subscribe(callback: (value: T) => void): () => void; // Subscribe to changes
  clear(): void;                         // Clear all values
}

type PayloadForMessageType<T extends WebsocketMessageType> =
  T extends SystemMessageType
    ? Parameters<typeof generateSystemMessage>[1]
    : T extends AuthMessageType
      ? Parameters<typeof generateAuthMessage>[1]
      : T extends ConnectionMessageType
        ? Parameters<typeof generateConnectionMessage>[1]
        // ... additional conditional types for other message types
        : never;

interface PlaycastNameValuePair {
  name: string;    // Parameter or statistic name
  value: string;   // Parameter or statistic value
}