# Using npm
npm install @dragonfire/client

# Using yarn
yarn add @dragonfire/client

import { DragonFireClient } from '@dragonfire/client';

// Initialize client with API key
const dragonfire = new DragonFireClient({
  apiKey: 'YOUR_API_KEY',
  region: 'us-west'
});

// Attempt to connect with verification
try {
  await dragonfire.connect();
  console.log('Connection established successfully');
} catch (error) {
  console.error('Authentication failed:', error.message);
}

// Get the current session token
const sessionToken = await dragonfire.getSessionToken();

// Session token will automatically refresh when needed

// Listen for connection state changes
dragonfire.on('connected', () => {
  console.log('Connected to DragonFire service');
});

dragonfire.on('disconnected', (reason) => {
  console.log(`Disconnected: ${reason}`);
});

dragonfire.on('error', (error) => {
  console.error('Connection error:', error);
});

dragonfire.on('resonance-change', (quality) => {
  console.log(`Resonance quality changed: ${quality}%`);
});

// Connect to EU Central region
const dragonfire = new DragonFireClient({
  apiKey: 'YOUR_API_KEY',
  region: 'eu-central'
});

// Automatically select region
const dragonfire = new DragonFireClient({
  apiKey: 'YOUR_API_KEY',
  region: 'auto'
});

// Connect and identify the selected region
const result = await dragonfire.connect();
console.log(`Auto-selected region: ${result.region}`);

// Use Pi resonance pattern for signal processing
const dragonfire = new DragonFireClient({
  apiKey: 'YOUR_API_KEY',
  region: 'us-west',
  resonancePattern: 'pi'
});

// Switch to a different resonance pattern
await dragonfire.setResonancePattern('sqrt2', {
  transitionDuration: 500  // Transition over 500ms for smooth shift
});

// Basic error handling
try {
  await dragonfire.connect();
} catch (error) {
  if (error instanceof AuthenticationError) {
    console.error('Invalid API key');
  } else if (error instanceof ConnectionError) {
    console.error('Connection failed, retrying...');
    setTimeout(() => dragonfire.connect(), 5000);
  } else {
    console.error('Unexpected error:', error);
  }
}

// Using the error's retry capability
try {
  await dragonfire.connect();
} catch (error) {
  if (error.canRetry()) {
    console.log(`Retrying in ${error.recommendedRetryMs()}ms`);
    setTimeout(() => dragonfire.connect(), error.recommendedRetryMs());
  } else {
    console.error('Cannot retry:', error.message);
  }
}

// Enable automatic recovery
const dragonfire = new DragonFireClient({
  apiKey: 'YOUR_API_KEY',
  region: 'us-west',
  recovery: {
    enabled: true,
    maxRetries: 5,
    backoffFactor: 1.5,
    initialDelayMs: 1000
  }
});

// Monitor service health with periodic checks
const monitor = dragonfire.monitorHealth({
  intervalMs: 60000,  // Check every minute
  callback: (status) => {
    if (!status.isFullyOperational()) {
      console.warn('Service degradation detected');
    }
  }
});

// Later, stop monitoring
monitor.stop();

// Create a multi-region client
const multiRegionClient = new DragonFireMultiRegionClient({
  apiKey: 'YOUR_API_KEY',
  regions: ['us-west', 'us-east', 'eu-west'],
  strategy: 'failover'  // 'failover', 'loadbalance', or 'nearest'
});

// Connect to all regions
await multiRegionClient.connect();

// Operations automatically use the optimal or available region
const result = await multiRegionClient.executeOperation(operation);

// Enable detailed metrics collection
dragonfire.enableMetrics({
  detailed: true,
  historySize: 100  // Keep last 100 measurements
});

// Get current metrics
const metrics = dragonfire.getMetrics();
console.log('Average latency:', metrics.latency.average);
console.log('Packet loss:', metrics.packetLoss);
console.log('Bandwidth:', metrics.bandwidth);

// Export metrics as JSON
const metricsJson = dragonfire.exportMetrics();
saveToFile(metricsJson, 'connection-metrics.json');

// Define a custom resonance pattern
const customPattern = {
  name: 'custom-hybrid',
  baseConstant: Math.PI * Math.sqrt(2),
  harmonics: [1, 1/2, 1/3, 1/5, 1/8],
  phaseShift: Math.PI / 4
};

// Register custom pattern
dragonfire.registerResonancePattern(customPattern);

// Use custom pattern
await dragonfire.setResonancePattern('custom-hybrid');

// Access low-level hexwave transmission (requires special permissions)
const hexwaveController = await dragonfire.getHexwaveController();

// Send direct hexwave packet
await hexwaveController.transmit({
  frequency: 437.0,
  amplitude: 0.8,
  modulationPattern: [1, 1, 0, 1, 0, 0, 1],
  phaseShift: Math.PI / 3
});