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
const session = await sdk.initializeGameSession({
  campaignId: 'campaign-123',
  gameId: 'game-456',
  playerFingerprint: 'unique-player-fingerprint',
  playerEmail: 'player@example.com',
});

// Start the game
await sdk.startGameSession(session.sessionId);

// Update progress during gameplay
await sdk.updateGameProgress(session.sessionId, {
  currentScore: 1500,
  elapsedTime: 120, // seconds
  gameState: { level: 3, lives: 2 },
});

// Complete the game
const result = await sdk.completeGame(session.sessionId, {
  finalScore: 2500,
  gameMetrics: {
    totalPlayTime: 300,
    actionsPerformed: 150,
    powerUpsUsed: 5,
    levelsCompleted: 5,
  },
});

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 a new game session
await sdk.initializeGameSession({
  campaignId: string;
  gameId: string;
  playerFingerprint: string;
  playerEmail?: string;
  deviceInfo?: DeviceInfo;
  receiptImage?: string;        // Base64 encoded
  geolocationData?: GeolocationData;
});

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

// Update game progress
await sdk.updateGameProgress(sessionId: string, {
  currentScore: number;
  gameState?: Record<string, any>;
  elapsedTime: number;
  achievements?: Achievement[];
  clientTimestamp?: string;
});

// Complete the game
await sdk.completeGame(sessionId: string, {
  finalScore: number;
  gameMetrics?: GameMetrics;
  finalGameState?: Record<string, any>;
});

// Abandon the game
await sdk.abandonGame(sessionId: string, reason?: string, lastKnownScore?: number);

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

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

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

// Validate game session
await sdk.validateGameSession(sessionId: string, validationData?: Record<string, any>);

// Send heartbeat (usually handled automatically)
await sdk.sendHeartbeat(sessionId: string, currentScore?: number);

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

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

// Game lifecycle events
sdk.gameLoadingStart();
sdk.gameLoadingFinished();
sdk.gamePlayStop();

// Clean up resources
sdk.destroy();

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');
});

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

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