import SteamworksSDK from 'steamworks-ffi-node';

const steam = SteamworksSDK.getInstance();

if (steam.user.isLoggedOn()) {
  console.log('User is logged into Steam');
} else {
  console.log('User is offline or not logged in');
}

interface GetAuthSessionTicketResult {
  success: boolean;      // Whether the operation was successful
  authTicket: number;    // The auth ticket handle (0 if failed)
  ticketData: Buffer;    // The ticket data as a Buffer
  ticketSize: number;    // The actual ticket size in bytes
  error?: string;        // Error message if failed
}

interface SteamNetworkingIdentityOptions {
  steamId?: string;      // Restrict ticket to specific Steam ID
  ipAddress?: string;    // Restrict ticket to specific IP address (e.g., '192.168.1.100')
  genericString?: string; // Restrict ticket to specific service/recipient identifier
}

// Get an unrestricted ticket (works with any recipient)
const result = steam.user.getAuthSessionTicket();

// Restrict ticket to a specific Steam ID
const result = steam.user.getAuthSessionTicket({
  steamId: '76561198001234567'
});

// Restrict ticket to a specific IP address
const result = steam.user.getAuthSessionTicket({
  ipAddress: '192.168.1.100'
});

// Restrict ticket to a service identifier
const result = steam.user.getAuthSessionTicket({
  genericString: 'my-dedicated-server'
});

if (result.success) {
  console.log(`Got ticket handle: ${result.authTicket}`);
  console.log(`Ticket size: ${result.ticketSize} bytes`);
  
  // Send to server for validation
  sendToServer({
    ticket: result.ticketData,
    steamId: steam.getSteamId()
  });
}

interface GetAuthTicketForWebApiResult {
  success: boolean;      // Whether the operation was successful
  authTicket: number;    // The auth ticket handle (0 if failed)
  ticketData: Buffer;    // The ticket data as a Buffer
  ticketSize: number;    // The actual ticket size in bytes
  ticketHex: string;     // The ticket as a hex string (for web API usage)
  error?: string;        // Error message if failed
}

interface SteamNetworkingIdentityOptions {
  steamId?: string;      // Restrict ticket to specific Steam ID
  ipAddress?: string;    // Restrict ticket to specific IP address (e.g., '192.168.1.100')
  genericString?: string; // Restrict ticket to specific service/recipient identifier
}

// Get an unrestricted web API ticket
const result = await steam.user.getAuthTicketForWebApi();

// Restrict ticket to a specific Steam ID
const result = await steam.user.getAuthTicketForWebApi({
  steamId: '76561198001234567'
});

// Restrict ticket to a specific IP address
const result = await steam.user.getAuthTicketForWebApi({
  ipAddress: '192.168.1.100'
});

// Restrict ticket to a service identifier
const result = await steam.user.getAuthTicketForWebApi({
  genericString: 'my-backend-server'
});

if (result.success) {
  // Use hex string for API authentication
  const response = await fetch('https://api.example.com/auth', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'X-Steam-Auth-Ticket': result.ticketHex
    },
    body: JSON.stringify({ steamId: steam.getSteamId() })
  });
}

// Get a ticket
const ticket = steam.user.getAuthSessionTicket();

// ... use the ticket ...

// Clean up when done
steam.user.cancelAuthTicket(ticket.authTicket);

interface BeginAuthSessionResult {
  success: boolean;                     // Whether the initial validation passed
  result: EBeginAuthSessionResult;      // The result code from BeginAuthSession
  error?: string;                       // Error message if failed
}

enum EBeginAuthSessionResult {
  OK = 0,                  // Ticket is valid for this game and this steamID
  InvalidTicket = 1,       // Ticket is not valid
  DuplicateRequest = 2,    // A ticket has already been submitted for this steamID
  InvalidVersion = 3,      // Ticket is from an incompatible interface version
  GameMismatch = 4,        // Ticket is not for this game
  ExpiredTicket = 5,       // Ticket has expired
}

// Server receives ticket from client
function onClientConnect(ticketData: Buffer, clientSteamId: string) {
  const result = steam.user.beginAuthSession(ticketData, clientSteamId);
  
  if (result.success) {
    console.log(`Auth session started for ${clientSteamId}`);
  } else {
    console.log(`Auth failed: ${result.error}`);
    disconnectClient(clientSteamId, result.result);
  }
}

function onClientDisconnect(clientSteamId: string) {
  steam.user.endAuthSession(clientSteamId);
  console.log(`Ended auth session for ${clientSteamId}`);
}

enum EUserHasLicenseForAppResult {
  HasLicense = 0,        // User has a license for specified app
  DoesNotHaveLicense = 1, // User does not have a license for the specified app
  NoAuth = 2,            // User has not been authenticated
}

// Check if user owns a DLC
const dlcResult = steam.user.userHasLicenseForApp(clientSteamId, 12345);

if (dlcResult === EUserHasLicenseForAppResult.HasLicense) {
  console.log('User owns the DLC');
} else if (dlcResult === EUserHasLicenseForAppResult.DoesNotHaveLicense) {
  console.log('User does not own the DLC');
} else {
  console.log('User not authenticated');
}

// 1. Receive and validate the user's auth ticket
const authResult = steam.user.beginAuthSession(ticketData, clientSteamId);

if (authResult.success) {
  // 2. Now check if they own specific DLC/app
  const licenseResult = steam.user.userHasLicenseForApp(clientSteamId, dlcAppId);
  
  if (licenseResult === EUserHasLicenseForAppResult.HasLicense) {
    console.log('User authenticated and owns the DLC');
  } else if (licenseResult === EUserHasLicenseForAppResult.NoAuth) {
    console.log('User not yet authenticated - call beginAuthSession first');
  }
  
  // 3. Clean up when done
  // steam.user.endAuthSession(clientSteamId);
}

interface RequestEncryptedAppTicketResult {
  success: boolean;    // Whether the request was successful
  error?: string;      // Error message if failed
}

// Request an encrypted ticket
const result = await steam.user.requestEncryptedAppTicket();
if (result.success) {
  // Now retrieve the ticket
  const ticket = steam.user.getEncryptedAppTicket();
  if (ticket.success) {
    // Send to your backend for verification
    sendToBackend(ticket.ticketData);
  }
}

interface GetEncryptedAppTicketResult {
  success: boolean;      // Whether the operation was successful
  ticketData: Buffer;    // The encrypted ticket data
  ticketSize: number;    // The actual ticket size in bytes
  ticketHex: string;     // The ticket as a hex string
  error?: string;        // Error message if failed
}

const result = steam.user.getEncryptedAppTicket();
if (result.success) {
  console.log(`Got encrypted ticket (${result.ticketSize} bytes)`);
  // Send ticketHex to your backend
  authenticateWithBackend(result.ticketHex);
}

interface UserSecurityInfo {
  phoneVerified: boolean;             // Whether the user's phone number is verified
  twoFactorEnabled: boolean;          // Whether the user has 2FA enabled
  phoneIdentifying: boolean;          // Whether the user's phone number is identifying
  phoneRequiringVerification: boolean; // Whether the user's phone number needs verification
}

const security = steam.user.getUserSecurityInfo();

if (security.twoFactorEnabled) {
  console.log('User has 2FA enabled');
}

if (security.phoneVerified) {
  console.log('Phone number is verified');
}

if (steam.user.isBehindNAT()) {
  console.log('User is behind NAT - may need relay');
}

const level = steam.user.getPlayerSteamLevel();
console.log(`Steam Level: ${level}`);

// Get regular badge level
const regularLevel = steam.user.getGameBadgeLevel(1, false);
console.log(`Regular badge level: ${regularLevel}`);

// Get foil badge level
const foilLevel = steam.user.getGameBadgeLevel(1, true);
console.log(`Foil badge level: ${foilLevel}`);

const folder = steam.user.getUserDataFolder();
if (folder) {
  console.log(`User data folder: ${folder}`);
  // Typically: C:\Program Files\Steam\userdata\<steamid>\<appid>\local
}

interface MarketEligibilityResult {
  allowed: boolean;             // Whether the user is allowed to use the market
  notAllowedReason: number;     // The reason why the user is not allowed (if not allowed)
  allowedAtTime: number;        // When the user will be allowed (Unix timestamp)
  steamGuardRequiredDays: number; // Days of Steam Guard required
  newDeviceCooldownDays: number;  // New device cooldown days
}

const eligibility = await steam.user.getMarketEligibility();
if (eligibility.allowed) {
  console.log('User can use the Steam Market');
} else {
  console.log(`Market restricted: reason ${eligibility.notAllowedReason}`);
}

interface StoreAuthURLResult {
  success: boolean;    // Whether the request was successful
  url: string | null;  // The authenticated URL for in-game browser checkout
  error?: string;      // Error message if failed
}

const result = await steam.user.requestStoreAuthURL('https://store.steampowered.com/');
if (result.success && result.url) {
  // Open in-game browser immediately (URL has short lifetime)
  openBrowser(result.url);
}

interface DurationControlResult {
  success: boolean;        // Whether the call was successful
  appId: number;           // App ID generating playtime
  applicable: boolean;     // Whether duration control applies to this user + game
  secondsLast5Hours: number; // Seconds of playtime in last 5 hours
  progress: number;        // Recommended progress (0 = ok, 1 = exit game)
  notification: number;    // Notification to show (0 = none)
  secondsToday: number;    // Playtime on current calendar day in seconds
  secondsRemaining: number; // Playtime remaining until regulatory limit in seconds
}

const duration = await steam.user.getDurationControl();
if (duration.applicable) {
  console.log(`Time remaining: ${duration.secondsRemaining} seconds`);
  if (duration.progress === 1) {
    console.log('Player should exit the game');
  }
}

enum EDurationControlOnlineState {
  Invalid = 0,       // Default state
  Offline = 1,       // Player is in offline mode
  Online = 2,        // Player is online
  OnlineHighPri = 3, // Player is online in high priority mode (competitive match)
}

// Player is in an online match
steam.user.setDurationControlOnlineState(EDurationControlOnlineState.Online);

// Player is in an important competitive match
steam.user.setDurationControlOnlineState(EDurationControlOnlineState.OnlineHighPri);

// Player is playing offline
steam.user.setDurationControlOnlineState(EDurationControlOnlineState.Offline);

// Advertise that the user is on a game server
steam.user.advertiseGame('90071234567890', ipToInt('192.168.1.100'), 27015);

// Clear the advertisement
steam.user.advertiseGame('0', 0, 0);

// Start recording when push-to-talk key is pressed
steam.user.startVoiceRecording();

// In your game loop, retrieve and send voice data
const voice = steam.user.getVoice();
if (voice.result === EVoiceResult.OK) {
  sendToOtherPlayers(voice.voiceData);
}

// Stop recording when push-to-talk key is released
steam.user.stopVoiceRecording();

// Keep fetching voice data until recording fully stops
let voice = steam.user.getVoice();
while (voice.result !== EVoiceResult.NotRecording) {
  if (voice.result === EVoiceResult.OK) {
    sendToOtherPlayers(voice.voiceData);
  }
  voice = steam.user.getVoice();
}

interface GetAvailableVoiceResult {
  result: EVoiceResult;    // Voice result code
  compressedBytes: number; // Number of compressed bytes available
}

enum EVoiceResult {
  OK = 0,                // Voice call was successful
  NotInitialized = 1,    // Steam voice chat has not been initialized
  NotRecording = 2,      // Voice recording is not active
  NoData = 3,            // No data is available (microphone may be off or silent)
  BufferTooSmall = 4,    // The provided buffer was too small
  DataCorrupted = 5,     // Voice data is corrupted
  Restricted = 6,        // Voice chat is restricted for this user
  UnsupportedCodec = 7,  // The voice codec is not supported
  ReceiverOutOfDate = 8, // The receiver is using an outdated voice codec
  ReceiverDidNotAnswer = 9, // The receiver did not answer
}

const available = steam.user.getAvailableVoice();
if (available.result === EVoiceResult.OK && available.compressedBytes > 0) {
  console.log(`${available.compressedBytes} bytes of voice data ready`);
}

interface GetVoiceResult {
  result: EVoiceResult;        // Voice result code
  voiceData: Buffer | null;    // Buffer containing compressed voice data (if successful)
  bytesWritten: number;        // Number of bytes written to the buffer
}

// In your game loop:
const voice = steam.user.getVoice();

switch (voice.result) {
  case EVoiceResult.OK:
    // Send compressed voice data to other players
    network.broadcast(voice.voiceData);
    break;
  case EVoiceResult.NoData:
    // Microphone is silent, nothing to do
    break;
  case EVoiceResult.NotRecording:
    // Recording has stopped
    break;
}

interface DecompressVoiceResult {
  result: EVoiceResult;       // Voice result code
  audioData: Buffer | null;   // Buffer containing decompressed PCM audio data
  bytesWritten: number;       // Number of bytes written to the buffer
}

// Receive compressed voice data from another player
const compressedData = network.receiveVoiceData();

// Decompress at optimal sample rate
const sampleRate = steam.user.getVoiceOptimalSampleRate();
const audio = steam.user.decompressVoice(compressedData, sampleRate);

if (audio.result === EVoiceResult.OK) {
  // Play the PCM audio through your audio system
  audioPlayer.playPCM(audio.audioData, sampleRate);
}

const optimalRate = steam.user.getVoiceOptimalSampleRate();
console.log(`Optimal sample rate: ${optimalRate} Hz`);

// Use for decompression
const audio = steam.user.decompressVoice(voiceData, optimalRate);

// Clean up when shutting down
steam.user.cancelAllTickets();