const fetch = require('node-fetch')

const BOT_TOKEN = 'nbot_YOUR_TOKEN_HERE'
const API_URL = 'https://your-domain.com/api/bots'

async function sendMessage(channelId, content) {
  const response = await fetch(`${API_URL}/send-message`, {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${BOT_TOKEN}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      channel_id: channelId,
      content: content,
      type: 'text',
    }),
  })

  if (!response.ok) {
    const error = await response.json()
    throw new Error(`Failed to send message: ${error.message}`)
  }

  return await response.json()
}

// Usage
sendMessage('550e8400-e29b-41d4-a716-446655440000', 'Hello from my bot!')
  .then((data) => console.log('Message sent:', data))
  .catch((err) => console.error('Error:', err))

async function createChannel(name, description, isPrivate = false) {
  const response = await fetch(`${API_URL}/create-channel`, {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${BOT_TOKEN}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      name: name,
      description: description,
      is_private: isPrivate,
    }),
  })

  if (!response.ok) {
    throw new Error(`Failed to create channel: ${await response.text()}`)
  }

  return await response.json()
}

// Usage
createChannel('bot-announcements', 'Automated bot announcements', false)
  .then((channel) => console.log('Channel created:', channel))
  .catch((err) => console.error('Error:', err))

async function getChannelInfo(channelId) {
  const response = await fetch(`${API_URL}/channel-info?channel_id=${channelId}`, {
    method: 'GET',
    headers: {
      Authorization: `Bearer ${BOT_TOKEN}`,
    },
  })

  if (!response.ok) {
    throw new Error(`Failed to get channel info: ${await response.text()}`)
  }

  return await response.json()
}

// Usage
getChannelInfo('550e8400-e29b-41d4-a716-446655440000')
  .then((channel) => console.log('Channel info:', channel))
  .catch((err) => console.error('Error:', err))

async function addReaction(messageId, emoji) {
  const response = await fetch(`${API_URL}/add-reaction`, {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${BOT_TOKEN}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      message_id: messageId,
      emoji: emoji,
    }),
  })

  if (!response.ok) {
    throw new Error(`Failed to add reaction: ${await response.text()}`)
  }

  return await response.json()
}

// Usage
addReaction('660e8400-e29b-41d4-a716-446655440001', '👍')
  .then((reaction) => console.log('Reaction added:', reaction))
  .catch((err) => console.error('Error:', err))

async function getUserInfo(userId) {
  const response = await fetch(`${API_URL}/user-info?user_id=${userId}`, {
    method: 'GET',
    headers: {
      Authorization: `Bearer ${BOT_TOKEN}`,
    },
  })

  if (!response.ok) {
    throw new Error(`Failed to get user info: ${await response.text()}`)
  }

  return await response.json()
}

// Usage
getUserInfo('770e8400-e29b-41d4-a716-446655440002')
  .then((user) => console.log('User info:', user))
  .catch((err) => console.error('Error:', err))

const crypto = require('crypto')
const express = require('express')

const WEBHOOK_SECRET = 'your_webhook_secret_here'

function verifyWebhookSignature(payload, signature) {
  const expectedSignature = crypto
    .createHmac('sha256', WEBHOOK_SECRET)
    .update(JSON.stringify(payload))
    .digest('hex')

  return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expectedSignature))
}

const app = express()
app.use(express.json())

app.post('/webhook', (req, res) => {
  const signature = req.headers['x-webhook-signature']

  if (!signature || !verifyWebhookSignature(req.body, signature)) {
    return res.status(401).json({ error: 'Invalid signature' })
  }

  // Process webhook event
  const event = req.body
  console.log('Received webhook event:', event)

  switch (event.type) {
    case 'message.created':
      handleMessageCreated(event.data)
      break
    case 'channel.created':
      handleChannelCreated(event.data)
      break
    // ... handle other events
  }

  res.status(200).json({ received: true })
})

function handleMessageCreated(message) {
  console.log('New message:', message)
  // Your logic here
}

function handleChannelCreated(channel) {
  console.log('New channel:', channel)
  // Your logic here
}

app.listen(3000, () => {
  console.log('Webhook server listening on port 3000')
})

async function sendMessageWithRetry(channelId, content, maxRetries = 3) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await sendMessage(channelId, content)
    } catch (error) {
      if (error.response?.status === 429) {
        // Rate limited - wait and retry
        const retryAfter = error.response.headers['retry-after'] || 60
        console.log(`Rate limited. Retrying after ${retryAfter}s...`)
        await new Promise((resolve) => setTimeout(resolve, retryAfter * 1000))
        continue
      }

      if (error.response?.status >= 500 && attempt < maxRetries) {
        // Server error - retry with exponential backoff
        const delay = Math.pow(2, attempt) * 1000
        console.log(`Server error. Retrying in ${delay}ms...`)
        await new Promise((resolve) => setTimeout(resolve, delay))
        continue
      }

      // Non-retryable error or max retries reached
      throw error
    }
  }
}

class RateLimitedBotClient {
  constructor(token) {
    this.token = token
    this.requestQueue = []
    this.processing = false
  }

  async request(endpoint, options) {
    return new Promise((resolve, reject) => {
      this.requestQueue.push({ endpoint, options, resolve, reject })
      this.processQueue()
    })
  }

  async processQueue() {
    if (this.processing || this.requestQueue.length === 0) return

    this.processing = true

    while (this.requestQueue.length > 0) {
      const { endpoint, options, resolve, reject } = this.requestQueue.shift()

      try {
        const response = await fetch(`${API_URL}${endpoint}`, {
          ...options,
          headers: {
            Authorization: `Bearer ${this.token}`,
            ...options.headers,
          },
        })

        const remaining = parseInt(response.headers.get('X-RateLimit-Remaining') || '0')
        const resetTime = parseInt(response.headers.get('X-RateLimit-Reset') || '0')

        if (response.status === 429) {
          // Rate limited - requeue and wait
          this.requestQueue.unshift({ endpoint, options, resolve, reject })
          const waitTime = resetTime - Date.now() || 60000
          await new Promise((r) => setTimeout(r, waitTime))
          continue
        }

        const data = await response.json()
        resolve(data)

        // Proactive rate limiting
        if (remaining <= 10) {
          const waitTime = (resetTime - Date.now()) / (remaining + 1)
          await new Promise((r) => setTimeout(r, waitTime))
        }
      } catch (error) {
        reject(error)
      }
    }

    this.processing = false
  }
}

// Usage
const bot = new RateLimitedBotClient('nbot_YOUR_TOKEN_HERE')

// ✅ Good
const BOT_TOKEN = process.env.BOT_TOKEN

// ❌ Bad
const BOT_TOKEN = 'nbot_hardcoded_token'

async function withRetry(fn, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn()
    } catch (error) {
      if (i === maxRetries - 1) throw error
      await new Promise((r) => setTimeout(r, Math.pow(2, i) * 1000))
    }
  }
}

function sendMessage(channelId, content) {
  if (!channelId || typeof channelId !== 'string') {
    throw new Error('Invalid channel ID')
  }

  if (!content || content.length > 4000) {
    throw new Error('Content must be between 1 and 4000 characters')
  }

  // ... make API call
}

try {
  await sendMessage(channelId, content)
} catch (error) {
  console.error('Failed to send message:', {
    channelId,
    error: error.message,
    stack: error.stack,
  })
  // Report to error tracking service
}

const cache = new Map()

async function getChannelInfoCached(channelId) {
  if (cache.has(channelId)) {
    return cache.get(channelId)
  }

  const channel = await getChannelInfo(channelId)
  cache.set(channelId, channel)

  // Expire after 5 minutes
  setTimeout(() => cache.delete(channelId), 5 * 60 * 1000)

  return channel
}

const fetch = require('node-fetch')
const express = require('express')
const crypto = require('crypto')

class NchatBot {
  constructor(token, webhookSecret) {
    this.token = token
    this.webhookSecret = webhookSecret
    this.apiUrl = 'https://your-domain.com/api/bots'
  }

  async sendMessage(channelId, content) {
    const response = await fetch(`${this.apiUrl}/send-message`, {
      method: 'POST',
      headers: {
        Authorization: `Bearer ${this.token}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ channel_id: channelId, content, type: 'text' }),
    })

    if (!response.ok) throw new Error(await response.text())
    return await response.json()
  }

  verifyWebhookSignature(payload, signature) {
    const expectedSignature = crypto
      .createHmac('sha256', this.webhookSecret)
      .update(JSON.stringify(payload))
      .digest('hex')

    return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expectedSignature))
  }

  createWebhookServer(port = 3000) {
    const app = express()
    app.use(express.json())

    app.post('/webhook', async (req, res) => {
      const signature = req.headers['x-webhook-signature']

      if (!signature || !this.verifyWebhookSignature(req.body, signature)) {
        return res.status(401).json({ error: 'Invalid signature' })
      }

      try {
        await this.handleWebhook(req.body)
        res.status(200).json({ received: true })
      } catch (error) {
        console.error('Webhook error:', error)
        res.status(500).json({ error: 'Internal error' })
      }
    })

    app.listen(port, () => {
      console.log(`Webhook server listening on port ${port}`)
    })

    return app
  }

  async handleWebhook(event) {
    console.log('Received event:', event.type)

    switch (event.type) {
      case 'message.created':
        await this.onMessageCreated(event.data)
        break
      // ... handle other events
    }
  }

  async onMessageCreated(message) {
    // Bot logic: respond to mentions
    if (message.content.includes('@bot')) {
      await this.sendMessage(message.channel_id, `Hello! You mentioned me. How can I help?`)
    }
  }
}

// Usage
const bot = new NchatBot(process.env.BOT_TOKEN, process.env.WEBHOOK_SECRET)

// Start webhook server
bot.createWebhookServer(3000)

// Send a message
bot
  .sendMessage('550e8400-e29b-41d4-a716-446655440000', 'Bot is online!')
  .then(() => console.log('Message sent'))
  .catch((err) => console.error('Error:', err))