// src/index.ts
import { Hono } from 'hono'
import { cors } from 'hono/cors'
import { jwt } from 'hono/jwt'
import { logger } from 'hono/logger'

type Bindings = {
  DB: D1Database
  STORAGE: R2Bucket
  CACHE: KVNamespace
  JWT_SECRET: string
}

const app = new Hono<{ Bindings: Bindings }>()

// Middleware
app.use('*', cors())
app.use('*', logger())

// Health check
app.get('/health', (c) => {
  return c.json({ status: 'healthy', timestamp: Date.now() })
})

// Protected routes
app.use('/api/*', jwt({ secret: 'your-secret-key' }))

// User management
app.get('/api/users', async (c) => {
  const { results } = await c.env.DB.prepare(
    'SELECT id, email, created_at FROM users'
  ).all()
  return c.json(results)
})

app.post('/api/users', async (c) => {
  const { email, password } = await c.req.json()

  const result = await c.env.DB.prepare(
    'INSERT INTO users (email, password_hash) VALUES (?, ?)'
  ).bind(email, await hashPassword(password)).run()

  return c.json({ id: result.meta.last_row_id }, 201)
})

export default app

// src/routes/upload.ts
import { Hono } from 'hono'

const upload = new Hono<{ Bindings: Bindings }>()

upload.post('/upload', async (c) => {
  const formData = await c.req.formData()
  const file = formData.get('file') as File

  if (!file) {
    return c.json({ error: 'No file provided' }, 400)
  }

  // Generate unique key
  const fileKey = `${crypto.randomUUID()}-${file.name}`

  // Upload to R2
  await c.env.STORAGE.put(fileKey, file.stream(), {
    httpMetadata: {
      contentType: file.type,
    },
  })

  // Save metadata to D1
  await c.env.DB.prepare(
    'INSERT INTO uploads (user_id, file_key, file_size) VALUES (?, ?, ?)'
  ).bind(userId, fileKey, file.size).run()

  return c.json({
    fileKey,
    url: `https://your-domain.com/files/${fileKey}`,
  })
})

upload.get('/files/:key', async (c) => {
  const key = c.req.param('key')
  const object = await c.env.STORAGE.get(key)

  if (!object) {
    return c.notFound()
  }

  return new Response(object.body, {
    headers: {
      'Content-Type': object.httpMetadata?.contentType || 'application/octet-stream',
      'Cache-Control': 'public, max-age=31536000',
    },
  })
})

export default upload

// src/middleware/cache.ts
export async function cacheMiddleware(c: Context, next: Next) {
  const cacheKey = `cache:${c.req.url}`

  // Check cache
  const cached = await c.env.CACHE.get(cacheKey)
  if (cached) {
    return c.json(JSON.parse(cached))
  }

  await next()

  // Cache successful responses
  if (c.res.status === 200) {
    const body = await c.res.clone().text()
    await c.env.CACHE.put(cacheKey, body, {
      expirationTtl: 3600, // 1 hour
    })
  }
}

// app/api/client.ts
export class APIClient {
  private baseURL = 'https://api.your-domain.com'
  private token: string | null = null

  setToken(token: string) {
    this.token = token
  }

  async fetch(endpoint: string, options: RequestInit = {}) {
    const headers = {
      'Content-Type': 'application/json',
      ...(this.token && { Authorization: `Bearer ${this.token}` }),
      ...options.headers,
    }

    const response = await fetch(`${this.baseURL}${endpoint}`, {
      ...options,
      headers,
    })

    if (!response.ok) {
      throw new Error(`API Error: ${response.statusText}`)
    }

    return response.json()
  }
}

// src/auth/jwt.ts
import { sign, verify } from 'hono/jwt'

export async function generateToken(userId: number, secret: string) {
  const payload = {
    sub: userId,
    exp: Math.floor(Date.now() / 1000) + 60 * 60 * 24 * 7, // 7 days
  }
  return await sign(payload, secret)
}

export async function verifyToken(token: string, secret: string) {
  try {
    return await verify(token, secret)
  } catch {
    return null
  }
}

// Login endpoint
app.post('/auth/login', async (c) => {
  const { email, password } = await c.req.json()

  const user = await c.env.DB.prepare(
    'SELECT id, password_hash FROM users WHERE email = ?'
  ).bind(email).first()

  if (!user || !await verifyPassword(password, user.password_hash)) {
    return c.json({ error: 'Invalid credentials' }, 401)
  }

  const token = await generateToken(user.id, c.env.JWT_SECRET)
  return c.json({ token })
})

// wrangler.toml - add queue configuration
[[queues.producers]]
binding = "EMAIL_QUEUE"
queue = "email-notifications"

[[queues.consumers]]
queue = "email-notifications"
max_batch_size = 10
max_batch_timeout = 30

// src/queue-consumer.ts
export default {
  async queue(batch: MessageBatch, env: Bindings): Promise<void> {
    for (const message of batch.messages) {
      const { to, subject, body } = message.body

      // Send email via Cloudflare Email Routing or third-party service
      await sendEmail({ to, subject, body })

      message.ack()
    }
  }
}

// Enqueue message
app.post('/api/send-email', async (c) => {
  await c.env.EMAIL_QUEUE.send({
    to: 'user@example.com',
    subject: 'Welcome!',
    body: 'Thanks for joining!',
  })
  return c.json({ queued: true })
})

// src/middleware/analytics.ts
app.use('*', async (c, next) => {
  const start = Date.now()
  await next()
  const duration = Date.now() - start

  // Log to Cloudflare Analytics
  c.executionCtx.waitUntil(
    fetch('https://cloudflare-analytics-api.com/log', {
      method: 'POST',
      body: JSON.stringify({
        path: c.req.path,
        method: c.req.method,
        status: c.res.status,
        duration,
        timestamp: new Date().toISOString(),
      }),
    })
  )
})