import {
  TransportManager,
  createWebSocketConfig,
  createHTTPPollingConfig,
  TransportPriority
} from '@/lib/network'

// Create transport manager
const manager = new TransportManager()

// Register primary transport
manager.registerTransport(createWebSocketConfig('wss://api.example.com', {
  priority: TransportPriority.PRIMARY,
  options: {
    connectionTimeout: 30000,
    keepAliveInterval: 30000,
  },
}))

// Register fallback transport
manager.registerTransport(createHTTPPollingConfig('https://api.example.com/poll', {
  priority: TransportPriority.SECONDARY,
}))

// Negotiate best connection
const result = await manager.negotiate()
console.log(`Connected via: ${result.transport.type}`)

import {
  DomainFrontingClient,
  createCloudflareEndpoint,
  createCloudFrontEndpoint,
} from '@/lib/network'

// Create client
const client = new DomainFrontingClient({
  enabled: true,
  strategy: 'sni-host-split',
  obfuscation: {
    randomPath: true,
    randomQuery: true,
    timingJitter: true,
    maxJitterMs: 500,
  },
})

// Add endpoints
client.addEndpoint(createCloudflareEndpoint(
  'cdnjs.cloudflare.com',  // Front domain (visible in SNI)
  'api.realserver.com'     // Host header (actual destination)
))

client.addEndpoint(createCloudFrontEndpoint(
  'd1234567890abc',        // CloudFront distribution ID
  'api.realserver.com'
))

// Make fronted request
const response = await client.request({
  method: 'POST',
  path: '/api/messages',
  body: JSON.stringify({ content: 'Hello' }),
})

// Manual health check
await client.performHealthChecks()

// Get healthy endpoints
const healthy = client.getHealthyEndpoints()
console.log(`${healthy.length} healthy endpoints available`)

// Test specific endpoint
const result = await client.testEndpoint(endpoint)
console.log(`Latency: ${result.latency}ms, Success: ${result.success}`)

import { ProxyManager, createSocks5Proxy } from '@/lib/network'

const manager = new ProxyManager({ enabled: true })

manager.addProxy(createSocks5Proxy('proxy.example.com', 1080, {
  auth: {
    type: 'basic',
    username: 'user',
    password: 'password',
  },
  priority: 1,
  region: 'us-east',
}))

import { createHttpProxy } from '@/lib/network'

manager.addProxy(createHttpProxy('proxy.example.com', 8080, {
  priority: 2,
}))

import { createShadowsocksProxy } from '@/lib/network'

manager.addProxy(createShadowsocksProxy({
  host: 'ss.example.com',
  port: 8388,
  password: 'your-password',
  cipher: 'aes-256-gcm',
}))

import { createObfs4Bridge } from '@/lib/network'

manager.addBridge(createObfs4Bridge({
  address: 'bridge.example.com',
  port: 443,
  fingerprint: 'ABCD1234...',
  cert: 'base64-encoded-cert',
  iatMode: 0,  // 0=disabled, 1=enabled, 2=paranoid
}))

import { createMeekBridge } from '@/lib/network'

manager.addBridge(createMeekBridge({
  cdnUrl: 'https://d2cly7j4zqgua7.cloudfront.net/',
  frontDomain: 'ajax.aspnetcdn.com',
}))

import { createSnowflakeBridge } from '@/lib/network'

manager.addBridge(createSnowflakeBridge({
  brokerUrl: 'https://snowflake-broker.torproject.net/',
  stunServers: [
    'stun:stun.l.google.com:19302',
    'stun:stun.voip.blackberry.com:3478',
  ],
}))

import { createProxyChain } from '@/lib/network'

// Create proxies
const proxy1 = createSocks5Proxy('first.proxy.com', 1080)
const proxy2 = createSocks5Proxy('second.proxy.com', 1080)

manager.addProxy(proxy1)
manager.addProxy(proxy2)

// Create chain
manager.addChain(createProxyChain({
  name: 'Double Hop',
  proxyIds: [proxy1.id, proxy2.id],
  strategy: 'strict',  // Must use all proxies in order
}))

const manager = new ProxyManager({
  enabled: true,
  selectionMode: 'least-latency',
  geoPreference: ['us-east', 'eu-west'],
  excludedRegions: ['cn', 'ru'],
})

import {
  CensorshipDetector,
  createComprehensiveDetector,
  NetworkStatus
} from '@/lib/network'

// Create detector
const detector = createComprehensiveDetector(
  'https://api.example.com',
  ['https://alt1.example.com', 'https://alt2.example.com']
)

// Run detection
const result = await detector.detect()

console.log(`Status: ${result.status}`)
console.log(`Censored: ${result.censored}`)
console.log(`Confidence: ${result.confidence}`)

if (result.censored) {
  console.log('Censorship types:', result.censorshipTypes)
  console.log('Recommendations:')
  for (const rec of result.recommendations) {
    console.log(`  - ${rec.method}: ${rec.description}`)
  }
}

const detector = new CensorshipDetector({
  primaryEndpoint: 'https://api.example.com',
  detectionInterval: 300000,  // Check every 5 minutes
})

detector.on('censorship-detected', (event) => {
  console.log('Censorship detected:', event.data)
  // Trigger fallback
})

detector.on('network-status-changed', (event) => {
  console.log(`Status: ${event.data.previousStatus} -> ${event.data.currentStatus}`)
})

import {
  UnifiedNetworkClient,
  createUnifiedNetworkClient,
} from '@/lib/network'

const client = createUnifiedNetworkClient('wss://api.example.com', {
  fallbackEndpoint: 'https://api.example.com/poll',
  autoDetect: true,
  autoCircumvent: true,
  domainFronting: {
    enabled: true,
    endpoints: [
      createCloudflareEndpoint('cdn.example.com', 'api.example.com'),
    ],
  },
  proxyManager: {
    enabled: true,
    selectionMode: 'priority',
  },
})

// Connect with automatic fallback
await client.connect()

// Send data (routed through best available transport)
await client.send(JSON.stringify({ action: 'ping' }))

// Check status
console.log('Network status:', client.getNetworkStatus())

const detector = new CensorshipDetector({...})
const result = await detector.detect()

if (result.status === NetworkStatus.CENSORED) {
  const recommendation = result.recommendations[0]

  switch (recommendation.method) {
    case 'domain-fronting':
      // Enable domain fronting
      break
    case 'obfs4':
      // Enable obfs4 bridge
      break
    case 'dns-over-https':
      // Switch to DoH
      break
  }
}

// Log metrics periodically
setInterval(() => {
  const metrics = manager.getMetrics()
  const health = manager.getHealthStatus()

  logger.info('Network metrics', {
    totalRequests: metrics.totalRequests,
    failedRequests: metrics.failedRequests,
    averageLatency: metrics.averageLatency,
    healthyTransports: [...health.values()].filter(h => h.healthy).length,
  })
}, 60000)

const result = await detector.detect()
if (result.censorshipTypes.includes('tcp-blocking')) {
  console.log('TCP blocking detected')
}

const result = await detector.isDomainBlocked('example.com')
if (result.indicators.some(i => i.type === 'dns-poisoning')) {
  console.log('DNS is being poisoned')
}

const result = await detector.detect()
if (result.censorshipTypes.includes('sni-filtering')) {
  console.log('SNI filtering detected')
}

const metrics = manager.getMetrics()
if (metrics.averageLatency > 3000) {
  console.log('Possible throttling')
}

import { logger } from '@/lib/logger'

// Enable debug logging
logger.setLevel('debug')

// Log all transport events
manager.on('*', (event) => {
  logger.debug('Transport event', event)
})

// Log censorship detection details
detector.on('probe-completed', (event) => {
  logger.debug('Probe result', event.data)
})