import { Bun } from 'bun'
import { GhostSpeakClient } from '@ghostspeak/sdk'

const client = new GhostSpeakClient({
  cluster: 'mainnet-beta',
  rpcUrl: process.env.HELIUS_RPC_URL,
})

Bun.serve({
  port: 443,
  tls: {
    cert: Bun.file('/etc/letsencrypt/live/webhooks.yourplatform.com/fullchain.pem'),
    key: Bun.file('/etc/letsencrypt/live/webhooks.yourplatform.com/privkey.pem'),
  },

  routes: {
    '/webhooks/ghostspeak': {
      POST: async (req) => {
        // 1. Verify signature (CRITICAL for security)
        const signature = req.headers.get('X-GhostSpeak-Signature')
        const payload = await req.text()

        const isValid = await client.webhooks.verifySignature(
          payload,
          signature,
          process.env.WEBHOOK_SECRET!
        )

        if (!isValid) {
          console.error('Invalid webhook signature')
          return new Response('Unauthorized', { status: 401 })
        }

        // 2. Parse payload
        const event = JSON.parse(payload)

        // 3. Handle event (idempotent!)
        try {
          await handleWebhookEvent(event)
          return new Response('OK', { status: 200 })
        } catch (error) {
          console.error('Webhook handler error:', error)
          return new Response('Internal Server Error', { status: 500 })
        }
      },
    },
  },
})

async function handleWebhookEvent(event: any) {
  // Ensure idempotency (process each event only once)
  const processed = await db.query(
    'SELECT 1 FROM webhook_events WHERE event_id = $1',
    [event.id]
  )

  if (processed.rows.length > 0) {
    console.log('Event already processed:', event.id)
    return
  }

  // Process event
  switch (event.type) {
    case 'ghost-score.updated':
      await handleGhostScoreUpdate(event.data)
      break

    case 'credential.issued':
      await handleCredentialIssued(event.data)
      break

    case 'marketplace.transaction.completed':
      await handleMarketplaceTransaction(event.data)
      break

    default:
      console.log('Unknown event type:', event.type)
  }

  // Mark as processed
  await db.query(
    'INSERT INTO webhook_events (event_id, type, processed_at) VALUES ($1, $2, NOW())',
    [event.id, event.type]
  )
}

console.log('Webhook server running on https://webhooks.yourplatform.com')

import { GhostSpeakClient, GhostSpeakError } from '@ghostspeak/sdk'

class ProductionGhostSpeakClient {
  private client: GhostSpeakClient
  private maxRetries = 3
  private retryDelay = 1000 // ms

  constructor() {
    this.client = new GhostSpeakClient({
      cluster: 'mainnet-beta',
      rpcUrl: process.env.HELIUS_RPC_URL,
    })
  }

  async registerAgentWithRetry(agentSigner: any, data: any) {
    let lastError

    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
      try {
        const agent = await this.client.agents.register(agentSigner, data)

        // Success - log metrics
        metrics.increment('agent.registration.success')

        return agent
      } catch (error) {
        lastError = error

        if (error instanceof GhostSpeakError) {
          // Handle specific errors
          switch (error.code) {
            case 'INSUFFICIENT_FUNDS':
              // Critical - alert immediately
              await alertOncall('Insufficient SOL in production wallet')
              throw error // Don't retry

            case 'RPC_TIMEOUT':
              // Transient - retry
              console.log(`RPC timeout (attempt ${attempt + 1}/${this.maxRetries})`)
              await this.sleep(this.retryDelay * (attempt + 1)) // Exponential backoff
              continue

            case 'AGENT_ALREADY_EXISTS':
              // Not an error - agent already registered
              console.log('Agent already exists:', agentSigner.address)
              return await this.client.agents.getAgent(agentSigner.address)

            default:
              // Unknown error - retry
              console.error('Unknown error:', error)
              await this.sleep(this.retryDelay * (attempt + 1))
              continue
          }
        }

        // Generic error - retry
        await this.sleep(this.retryDelay * (attempt + 1))
      }
    }

    // All retries failed
    metrics.increment('agent.registration.failure')
    throw lastError
  }

  private sleep(ms: number): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, ms))
  }
}

import { GhostSpeakClient } from '@ghostspeak/sdk'

export async function healthCheck() {
  const checks = {
    rpc: false,
    database: false,
    wallet: false,
    ghostspeak: false,
  }

  try {
    // 1. Check RPC connectivity
    const client = new GhostSpeakClient({
      cluster: 'mainnet-beta',
      rpcUrl: process.env.HELIUS_RPC_URL,
    })

    const blockHeight = await client.connection.getBlockHeight()
    checks.rpc = blockHeight > 0

    // 2. Check database
    const dbResult = await db.query('SELECT 1')
    checks.database = dbResult.rows.length > 0

    // 3. Check wallet balance
    const balance = await client.connection.getBalance(wallet.publicKey)
    checks.wallet = balance > 1_000_000_000 // > 1 SOL

    if (balance < 5_000_000_000) {
      // < 5 SOL
      await alertOncall('Low wallet balance: ' + balance / 1e9 + ' SOL')
    }

    // 4. Check GhostSpeak SDK
    const testReputation = await client.reputation.getTierInfo('Bronze')
    checks.ghostspeak = testReputation !== null

  } catch (error) {
    console.error('Health check failed:', error)
  }

  return {
    healthy: Object.values(checks).every(c => c),
    checks,
    timestamp: new Date().toISOString(),
  }
}

// Run health check every 60 seconds
setInterval(async () => {
  const health = await healthCheck()

  if (!health.healthy) {
    console.error('System unhealthy:', health)
    await alertOncall('Health check failed', health)
  }

  // Send metrics to monitoring system
  metrics.gauge('health.rpc', health.checks.rpc ? 1 : 0)
  metrics.gauge('health.database', health.checks.database ? 1 : 0)
  metrics.gauge('health.wallet', health.checks.wallet ? 1 : 0)
  metrics.gauge('health.ghostspeak', health.checks.ghostspeak ? 1 : 0)
}, 60000)

// Track critical production metrics

interface Metrics {
  agentsRegistered: number
  credentialsIssued: number
  averageGhostScore: number
  transactionSuccessRate: number
  rpcUptime: number
  webhookLatency: number
}

async function getDashboardMetrics(): Promise<Metrics> {
  const last24h = Date.now() - 24 * 60 * 60 * 1000

  return {
    agentsRegistered: await db.query(
      'SELECT COUNT(*) FROM agents WHERE created_at > $1',
      [new Date(last24h)]
    ).then(r => r.rows[0].count),

    credentialsIssued: await db.query(
      'SELECT COUNT(*) FROM credentials WHERE issued_at > $1',
      [new Date(last24h)]
    ).then(r => r.rows[0].count),

    averageGhostScore: await db.query(
      'SELECT AVG(score) FROM reputation'
    ).then(r => r.rows[0].avg),

    transactionSuccessRate: await getSuccessRate(last24h),

    rpcUptime: await getRPCUptime(last24h),

    webhookLatency: await getWebhookLatency(last24h),
  }
}