# Using npm
npm install @dragonfire/rwt-client

# Using yarn
yarn add @dragonfire/rwt-client

import { DragonFireClient } from '@dragonfire/client';
import { RWTClient } from '@dragonfire/rwt-client';

// Initialize and connect DragonFire client
const dragonfire = new DragonFireClient({
  apiKey: 'YOUR_API_KEY',
  region: 'us-west'
});
await dragonfire.connect();

// Initialize RWT client with the DragonFire connection
const rwt = new RWTClient(dragonfire);

// Configure token rotation (optional - has sensible defaults)
rwt.configureTokenRotation({
  interval: 60000,         // Rotate tokens every 60 seconds
  pattern: 'fibonacci',    // Use Fibonacci sequence for rotation timing
  renewThreshold: 0.8      // Renew tokens at 80% of their lifetime
});

// Enable automatic reconnection
rwt.configureReconnection({
  enabled: true,
  maxAttempts: 10,
  baseDelay: 1000,          // Base delay in ms
  maxDelay: 30000,          // Maximum delay in ms
  backoffFactor: 1.5,       // Exponential backoff factor
  jitter: 0.2,              // Random jitter factor (0-1)
  preserveSession: true     // Maintain session across reconnects
});

// Listen for messages
rwt.on('message', (data, metadata) => {
  console.log('Received message:', data);
  console.log('Channel:', metadata.channel);
  console.log('Sender:', metadata.sender);
});

// Listen for messages on a specific channel
rwt.on('message:auth', (data, metadata) => {
  console.log('Received auth message:', data);
});

// Wait for a specific message
const message = await rwt.waitForMessage({
  type: 'response',
  timeout: 5000,          // Wait up to 5 seconds
  channel: 'auth'         // Listen on 'auth' channel
});

console.log('Received response:', message.data);

// Listen with filter
rwt.onMessage({
  channel: 'notifications',
  filter: msg => msg.priority === 'high'
}, (data) => {
  console.log('High priority notification:', data);
});

// Create authentication channel
const authChannel = rwt.createChannel('auth', {
  encryption: true,
  priority: 'high'
});

// Send on the channel
await authChannel.send({
  action: 'verify',
  token: userToken
});

// Listen on the channel
authChannel.onMessage((data) => {
  console.log('Auth channel message:', data);
});

// Wait for specific message on channel
const response = await authChannel.waitForMessage({
  type: 'verify-response',
  timeout: 5000
});

// Close a channel when no longer needed
await authChannel.close();

// Reopen a closed channel
await authChannel.open();

// Check if channel is active
if (authChannel.isActive()) {
  // Use the channel
}

// Get all active channels
const channels = rwt.getChannels();
console.log(`Active channels: ${channels.length}`);

// Configure encryption
rwt.configureEncryption({
  algorithm: 'AES-GCM',       // Encryption algorithm
  keySize: 256,               // Key size in bits
  keyRotation: {
    enabled: true,
    interval: 3600000,        // Rotate keys every hour
    pattern: 'phi-based'      // Use phi-based rotation pattern
  },
  payloadEncryption: 'auto'   // 'always', 'never', or 'auto'
});

// Send with explicit encryption
await rwt.send(sensitiveData, {
  encrypt: true,                // Explicitly encrypt this message
  encryptionLevel: 'maximum'    // Use maximum encryption strength
});

// Send without encryption for non-sensitive data
await rwt.send(publicData, {
  encrypt: false               // Skip encryption for this message
});

// Enable end-to-end encryption
await rwt.enableE2E({
  keyExchangeMethod: 'ECDHE',    // Elliptic Curve Diffie-Hellman Exchange
  curve: 'P-256',                // Curve to use for key exchange
  verificationCallback: (fingerprint) => {
    // Verify the remote fingerprint
    return isValidFingerprint(fingerprint);
  }
});

// Send with end-to-end encryption
await rwt.send(sensitiveData, {
  endToEnd: true                // Use end-to-end encryption
});

// Basic event subscription
rwt.on('connect', (info) => {
  console.log('Connected with ID:', info.connectionId);
});

// Subscribe to channel-specific message events
rwt.on('message:system', (data) => {
  console.log('System message:', data);
});

// Subscribe with a once handler (fires only once)
rwt.once('token-rotate', (info) => {
  console.log('First token rotation complete');
});

// Subscribe with filtering
rwt.on('message', {
  filter: (data) => data.type === 'alert'
}, (data) => {
  console.log('Alert received:', data.message);
});

// Store reference to handler for later removal
const handler = (data) => {
  console.log('Message received:', data);
};

// Subscribe with handler
rwt.on('message', handler);

// Unsubscribe specific handler
rwt.off('message', handler);

// Unsubscribe all handlers for an event
rwt.off('message');

// Unsubscribe all event handlers
rwt.offAll();

// Try-catch error handling
try {
  await rwt.connect();
  await rwt.send(message);
} catch (error) {
  if (error instanceof RWTConnectionError) {
    console.error('Connection error:', error.message);
  } else if (error instanceof RWTAuthenticationError) {
    console.error('Authentication error:', error.message);
  } else if (error instanceof RWTSendError) {
    console.error('Failed to send message:', error.message);
  } else {
    console.error('Unexpected error:', error);
  }
}

// Event-based error handling
rwt.on('error', (error) => {
  console.error('RWT error:', error.message);
  
  // Check if error has recovery info
  if (error.recovery) {
    console.log(`Recovery suggested: ${error.recovery.strategy}`);
    console.log(`Retry in: ${error.recovery.retryAfterMs}ms`);
  }
});

try {
  await rwt.send(message);
} catch (error) {
  console.error(`Error: ${error.message}`);
  console.error(`Error code: ${error.code}`);
  console.error(`Operation: ${error.operation}`);
  
  // Detailed information
  console.error(`Details: ${JSON.stringify(error.details)}`);
  
  // Recovery information
  if (error.canRetry()) {
    console.log(`Retry recommended in ${error.retryAfterMs}ms`);
    
    // Automatic retry
    setTimeout(() => {
      rwt.send(message).catch(handleError);
    }, error.retryAfterMs);
  }
}