import { WioexStreamClient } from '@wioex/stream-sdk';

// Backend usage: Just provide your API key!
// SDK automatically fetches secure token and handles everything
const client = new WioexStreamClient({
  apiKey: process.env.WIOEX_API_KEY,  // That's it! SDK handles token fetch
  maxSymbols: 8
});

// Listen for ticker updates
client.on('ticker', (data) => {
  console.log(`${data.ticket}: $${data.last} (${data.changePercent}%)`);
});

// Connect and subscribe - SDK auto-fetches token before connecting!
await client.connect();
client.subscribe(['AAPL', 'TSLA', 'GOOGL']);

new WioexStreamClient(config: WioexStreamConfig)

const client = new WioexStreamClient({
  tokenEndpoint: '/api/stream/token',
  tokenFetchRetry: {
    maxAttempts: 5,
    delay: 2000,
    backoff: 'exponential',  // 2s → 4s → 8s → 16s → 32s
  },
});

// Default (balanced - 60 FPS throttling)
const client = new WioexStreamClient({ apiKey: 'xxx' });

// High-performance (no throttling, immediate events)
const client = new WioexStreamClient({
  apiKey: 'xxx',
  performance: {
    tickerThrottle: 0,           // No throttling
    errorBatchSize: 1,           // Immediate error reporting
    errorDeduplication: false,   // No deduplication
  }
});

// High-volume (optimized for charts - 20 FPS batching)
const client = new WioexStreamClient({
  apiKey: 'xxx',
  performance: {
    tickerThrottle: 50,         // 20 FPS
    batchTickers: true,         // Enable batching
    tickerBatchSize: 20,        // Larger batches
  }
});

// Memory-optimized (aggressive batching)
const client = new WioexStreamClient({
  apiKey: 'xxx',
  performance: {
    errorBatchSize: 50,         // Large error batches
    errorBatchInterval: 10000,  // 10s flush interval
  }
});

// Backend (with apiKey) - await to ensure token fetch completes
await client.connect();

// Frontend (with token) - can be called without await
client.connect();

client.disconnect();

client.subscribe('AAPL');
client.subscribe(['AAPL', 'TSLA', 'GOOGL']);

client.unsubscribe('AAPL');
client.unsubscribe(['AAPL', 'TSLA']);

const state = client.getState();
// Returns: 'disconnected' | 'connecting' | 'connected' | 'registered' | 'reconnecting' | 'failed'

const stocks = client.getSubscribedStocks();
console.log(stocks); // ['AAPL', 'TSLA', 'GOOGL']

const stats = client.getStats();
console.log(stats);
// {
//   connectedAt: 1704067200000,
//   reconnectAttempts: 0,
//   messagesReceived: 152,
//   messagesSent: 3,
//   tickersReceived: 148,
//   subscribedStocks: ['AAPL', 'TSLA'],
//   state: 'registered'
// }

if (client.isConnected()) {
  console.log('Connected!');
}

// Update token and schedule auto-refresh
client.updateToken(newToken, newExpiresAt);

client.on('connected', () => {
  console.log('Connected to WioEX stream');
});

client.on('registered', (data) => {
  console.log('Registered:', data.message);
});

client.on('subscribed', (stocks: string[]) => {
  console.log('Subscribed to:', stocks);
});

client.on('unsubscribed', (stocks: string[]) => {
  console.log('Unsubscribed from:', stocks);
});

client.on('ticker', (data: TickerData) => {
  console.log(`${data.ticket}: $${data.last}`);
});

interface TickerData {
  ticket: string;        // Stock symbol
  last: string;          // Last price
  open: string;          // Opening price
  high: string;          // High price
  low: string;           // Low price
  volume: string;        // Trading volume
  bid: string;           // Bid price
  ask: string;           // Ask price
  change: string;        // Price change
  changePercent: string; // Change percentage
  timestamp: number;     // Unix timestamp
}

client.on('error', (error: Error) => {
  console.error('Error:', error.message);
});

client.on('disconnected', (code: number, reason: string) => {
  console.log(`Disconnected (${code}): ${reason}`);
});

client.on('reconnecting', (attempt: number) => {
  console.log(`Reconnecting... (attempt ${attempt})`);
});

client.on('stateChange', (state: ConnectionState) => {
  console.log(`State: ${state}`);
});

client.on('tokenExpiring', ({ currentToken, expiresAt }) => {
  console.log(`Token expiring at ${new Date(expiresAt * 1000)}`);
});

client.on('tokenRefreshed', ({ token, expiresAt }) => {
  console.log(`Token refreshed! New expiry: ${new Date(expiresAt * 1000)}`);
});

client.on('tokenRefreshFailed', (error: Error) => {
  console.error('Token refresh failed:', error.message);
});

client.on('tokenFetchStarted', (source: 'endpoint' | 'api') => {
  console.log(`Fetching token from ${source}...`);
});

client.on('tokenFetchSucceeded', ({ token, expiresAt, source }) => {
  console.log(`Token fetched from ${source}`);
  console.log(`Expires at: ${new Date(expiresAt * 1000)}`);
});

client.on('tokenFetchFailed', (error: Error, attempt: number, willRetry: boolean) => {
  console.error(`Token fetch failed (attempt ${attempt}):`, error.message);
  if (willRetry) {
    console.log('Will retry...');
  }
});

import { WioexStreamClient } from '@wioex/stream-sdk';

// Super simple! Just provide API key, SDK handles token automatically
const client = new WioexStreamClient({
  apiKey: process.env.WIOEX_API_KEY,
  maxSymbols: 5
});

client.on('ticker', (data) => {
  const change = parseFloat(data.changePercent);
  const arrow = change >= 0 ? '↑' : '↓';
  console.log(`${arrow} ${data.ticket}: $${data.last} (${change.toFixed(2)}%)`);
});

await client.connect();  // SDK auto-fetches token here
client.subscribe(['AAPL', 'TSLA', 'GOOGL', 'MSFT', 'AMZN']);

// Get token first
const { token } = await fetch('/api/stream/token', { method: 'POST' })
  .then(r => r.json());

const client = new WioexStreamClient({
  token,
  maxSymbols: 3
});

client.on('registered', () => {
  // Subscribe to initial stocks
  client.subscribe(['AAPL', 'TSLA', 'GOOGL']);
});

// After 30 seconds, switch to different stocks
setTimeout(() => {
  client.unsubscribe(['GOOGL']);
  client.subscribe(['MSFT']);
}, 30000);

client.connect();

const { token } = await fetch('/api/stream/token', { method: 'POST' })
  .then(r => r.json());

const client = new WioexStreamClient({
  token,
  autoReconnect: true,
  maxReconnectAttempts: 5
});

client.on('error', (error) => {
  console.error('Error:', error.message);
});

client.on('disconnected', (code, reason) => {
  console.log(`Disconnected: ${reason}`);
  if (code !== 1000) {
    console.log('Unexpected disconnection');
  }
});

client.on('reconnecting', (attempt) => {
  console.log(`Reconnecting... attempt ${attempt}`);
});

client.connect();

const { token } = await fetch('/api/stream/token', { method: 'POST' })
  .then(r => r.json());

const client = new WioexStreamClient({ token });

client.connect();
client.subscribe(['AAPL', 'TSLA']);

// Log statistics every minute
setInterval(() => {
  const stats = client.getStats();
  console.log('Statistics:', {
    uptime: Date.now() - stats.connectedAt!,
    messagesReceived: stats.messagesReceived,
    tickersReceived: stats.tickersReceived,
    subscribedStocks: stats.subscribedStocks
  });
}, 60000);

// Backend: Automatic token refresh with API key
const client = new WioexStreamClient({
  apiKey: process.env.WIOEX_API_KEY,

  // Enable auto-refresh (default: true)
  autoRefreshToken: true,

  // Refresh 1 hour before expiry (default: 3600000ms)
  refreshBeforeExpiry: 3600000,

  // Callback for custom token fetching
  onTokenExpiring: async () => {
    console.log('Fetching new token...');

    const response = await fetch(
      `https://api.wioex.com/v1/stream/token?api_key=${process.env.WIOEX_API_KEY}`,
      { method: 'POST' }
    );
    const data = await response.json();

    return {
      token: data.token,
      expiresAt: data.expires_at
    };
  }
});

// Monitor token refresh events
client.on('tokenExpiring', ({ expiresAt }) => {
  console.log(`Token expiring at ${new Date(expiresAt * 1000)}`);
});

client.on('tokenRefreshed', ({ expiresAt }) => {
  console.log(`Token refreshed! Valid until ${new Date(expiresAt * 1000)}`);
});

client.on('tokenRefreshFailed', (error) => {
  console.error('Token refresh failed:', error);
});

await client.connect();
client.subscribe(['AAPL', 'TSLA']);

import {
  WioexStreamClient,
  WioexStreamConfig,
  TickerData,
  ConnectionState,
  ClientStats
} from '@wioex/stream-sdk';

// Get token (from backend)
const { token } = await fetch('/api/stream/token', { method: 'POST' })
  .then(r => r.json());

const config: WioexStreamConfig = {
  token,
  maxSymbols: 8
};

const client = new WioexStreamClient(config);

client.on('ticker', (data: TickerData) => {
  // TypeScript knows the exact structure of data
  console.log(data.ticket, data.last, data.changePercent);
});