import { createPlayeSDK } from "playe-developer-sdk";

// Initialize the SDK
const sdk = createPlayeSDK({
  apiBaseUrl: "https://api.playe.com",
  apiKey: "your-api-key",
  enableDebugMode: true, // Enable for development
});

// Initialize a game session (gets sessionId from URL query parameter)
const session = await sdk.initializeGameSession();

console.log("Game session initialized:", {
  sessionId: session.sessionId,
  campaignId: session.campaign.id,
  playerId: session.player.id,
});

// Start the game
await sdk.startGameSession({
  difficulty: "normal",
  mode: "classic",
});

// Update progress during gameplay (includes automatic integrity verification)
await sdk.updateGameProgress({
  currentScore: 1500,
  elapsedTime: 120, // seconds
  gameState: {
    level: 3,
    lives: 2,
    powerUps: ["speed", "shield"],
  },
  achievements: [
    {
      id: "level-3",
      name: "Level 3 Complete",
      unlockedAt: new Date().toISOString(),
    },
  ],
});

// Complete the game (includes integrity verification)
const result = await sdk.completeGame({
  finalScore: 2500,
  validationChecksum: "client-checksum",
  gameMetrics: {
    totalPlayTime: 300,
    actionsPerformed: 150,
    powerUpsUsed: 5,
    levelsCompleted: 5,
  },
  finalGameState: {
    level: 5,
    finalLives: 1,
  },
});

console.log("Game completed!", {
  isWinner: result.isWinner,
  finalRank: result.finalRank,
  prizeAmount: result.prizeAmount,
});

interface SDKConfig {
  apiBaseUrl: string; // Required: API base URL
  apiKey?: string; // Optional: API key for authentication
  enableDebugMode?: boolean; // Optional: Enable debug logging
  retryAttempts?: number; // Optional: Number of retry attempts (default: 3)
  timeoutMs?: number; // Optional: Request timeout in ms (default: 30000)
  enableOfflineMode?: boolean; // Optional: Enable offline mode (default: false)
}

// Initialize game session (gets sessionId from URL query parameter)
const session = await sdk.initializeGameSession(): Promise<GameSessionResponse>;

// Start the game session
await sdk.startGameSession(config?: Record<string, any>): Promise<GameSessionResponse>;

// Update game progress with integrity verification
await sdk.updateGameProgress({
  currentScore: number;
  gameState?: Record<string, any>;  // Automatically hashed for integrity
  elapsedTime: number;
  achievements?: Achievement[];
  clientTimestamp?: string;
}): Promise<ProgressUpdateResponse>;

// Complete the game with integrity verification
await sdk.completeGame({
  finalScore: number;
  validationChecksum: string;
  gameMetrics?: GameMetrics;
  finalGameState?: Record<string, any>;  // Automatically hashed for integrity
}): Promise<GameCompletionResponse>;

// Abandon the game
await sdk.abandonGame(reason?: string, lastKnownScore?: number): Promise<AbandonGameResponse>;

// Get campaign status
await sdk.getCampaignStatus(campaignId: string, playerId?: string): Promise<CampaignStatusResponse>;

// Get leaderboard
await sdk.getLeaderboard(campaignId: string, limit?: number, playerId?: string): Promise<LeaderboardResponse>;

// Get player attempts
await sdk.getPlayerAttempts(campaignId: string, playerId: string): Promise<PlayerAttemptsResponse>;

// Validate game session with integrity verification
await sdk.validateGameSession({
  clientChecksum: string;
  stateSnapshot?: Record<string, unknown>;  // Automatically hashed
  timingData?: unknown;
  behaviorMetrics?: unknown;
}): Promise<ValidationResponse>;

// Send heartbeat (usually handled automatically)
await sdk.sendHeartbeat(currentScore?: number): Promise<HeartbeatResponse>;

// Create test game session for development
await sdk.createTestGameSession(testConfig?: Record<string, any>): Promise<TestGameResponse>;

// Test SDK functionality
sdk.test('Custom test message'): void;

// Check if running in demo mode
const isDemoMode = sdk.isDemo(): boolean;

// Game lifecycle events
sdk.gameLoadingStart(): void;     // Emit loading start event
sdk.gameLoadingFinished(): void;  // Emit loading finished event
sdk.gamePlayStop(): void;         // Stop heartbeat and emit stop event

// Clean up resources
sdk.destroy(): void;              // Clean up session artifacts and stop heartbeat

import { canonicalStringify, sha256Hex, buildIntegrityHeaders, computeGameStateHash } from "playe-developer-sdk";

// Canonical JSON stringification (deterministic)
const canonical = canonicalStringify({ b: 1, a: 2 }); // '{"a":2,"b":1}'

// SHA-256 hashing
const hash = await sha256Hex("data to hash");

// Build integrity headers (used internally)
const headers = buildIntegrityHeaders(sessionToken);

// Compute game state hash with session salt
const gameStateHash = await computeGameStateHash(gameState, sessionSalt);

import { DeviceUtils } from "@workspace/playe-developer-sdk";

// Get device information
const deviceInfo = DeviceUtils.getDeviceInfo();

// Get geolocation
const location = await DeviceUtils.getGeolocationData();

// Generate fingerprint
const fingerprint = DeviceUtils.generateFingerprint();

// Check browser support
const isSupported = DeviceUtils.isBrowser();
const features = DeviceUtils.getFeatureSupport();

import {
  PlayeSDKError,
  ValidationError,
  NetworkError,
  AuthenticationError,
  GameSessionError,
} from "@workspace/playe-developer-sdk";

try {
  await sdk.initializeGameSession(params);
} catch (error) {
  if (error instanceof ValidationError) {
    console.error("Validation failed:", error.message);
  } else if (error instanceof NetworkError) {
    console.error("Network error:", error.message);
  } else if (error instanceof AuthenticationError) {
    console.error("Authentication failed:", error.message);
  } else if (error instanceof PlayeSDKError) {
    console.error("SDK error:", error.toJSON());
  }
}

// Listen for SDK events
window.addEventListener("playe:game-loading-start", () => {
  console.log("Game loading started");
});

window.addEventListener("playe:game-loading-finished", () => {
  console.log("Game loading finished");
});

window.addEventListener("playe:game-play-stop", () => {
  console.log("Game play stopped");
});

// Manually validate game session
const validation = await sdk.validateGameSession({
  clientChecksum: "calculated-checksum",
  stateSnapshot: currentGameState,
  timingData: { avgResponseTime: 250 },
  behaviorMetrics: { clicksPerSecond: 5.2 },
});

if (!validation.isValid) {
  console.log("Validation issues:", validation.validationIssues);
}

// Create a test game session for development
const testSession = await sdk.createTestGameSession({
  testConfig: {
    mockCampaign: true,
    mockPlayers: 10,
    testScenario: "leaderboard",
  },
});

console.log("Test session created:", testSession.testSessionId);

const sdk = createPlayeSDK({
  apiBaseUrl: "https://api.playe.com",
  enableDebugMode: true, // This will log all API calls, integrity operations, and responses
});