import { performance } from 'node:perf_hooks'
import { createRequire } from 'node:module'

import { PGlite } from '@electric-sql/pglite'
import { vector } from '@electric-sql/pglite/vector'
import { sql } from 'drizzle-orm'
import { drizzle } from 'drizzle-orm/pglite'
import { safeParse } from 'valibot'

import { ChatSyncSchema } from '../api/chats.schema'
import * as chatSchema from '../schemas/chats'
import { createChatService } from '../services/chats'

function formatBytes(bytes: number) {
  const units = ['B', 'KB', 'MB', 'GB'] as const
  let value = bytes
  let unit = 0
  while (value >= 1024 && unit < units.length - 1) {
    value /= 1024
    unit += 1
  }
  return `${value.toFixed(2)} ${units[unit]}`
}

function makePayload(messageCount: number, contentBytes: number) {
  const content = 'A'.repeat(contentBytes)
  const createdAt = Date.now()

  return {
    chat: {
      id: 'poc-chat',
      type: 'group' as const,
      title: 'poc',
      createdAt,
      updatedAt: createdAt,
    },
    members: [
      { type: 'character' as const, characterId: 'default' },
    ],
    messages: Array.from({ length: messageCount }, (_, i) => ({
      id: `m-${i}`,
      role: 'user' as const,
      content,
      createdAt,
    })),
  }
}

async function createInMemoryDB(schema: Record<string, any>) {
  const require = createRequire(import.meta.url)
  // drizzle-kit is CJS; require() avoids ESM interop issues
  const { pushSchema } = require('drizzle-kit/api') as typeof import('drizzle-kit/api')

  const client = new PGlite({
    extensions: { vector },
  })

  const db = drizzle(client, { schema }) as any
  await db.execute(sql`CREATE EXTENSION IF NOT EXISTS vector;`)

  const { apply } = await pushSchema(schema, db)
  await apply()

  return db
}

async function main() {
  const messageCount = Number(process.env.MESSAGE_COUNT ?? '5000')
  const contentBytes = Number(process.env.CONTENT_BYTES ?? '2048')
  const userId = process.env.USER_ID ?? 'poc-user'

  console.log(JSON.stringify({ messageCount, contentBytes, totalContentApprox: formatBytes(messageCount * contentBytes) }))

  const payload = makePayload(messageCount, contentBytes)

  const mem0 = process.memoryUsage().heapUsed
  const t0 = performance.now()
  const parsed = safeParse(ChatSyncSchema, payload)
  const t1 = performance.now()
  const mem1 = process.memoryUsage().heapUsed

  if (!parsed.success) {
    console.error('Schema rejected payload:', parsed.issues)
    process.exitCode = 2
    return
  }

  console.log(`safeParse(ChatSyncSchema): ${(t1 - t0).toFixed(1)} ms, heap +${formatBytes(mem1 - mem0)}`)

  const db = await createInMemoryDB(chatSchema)
  const chatService = createChatService(db)

  const t2 = performance.now()
  const res = await chatService.syncChat(userId, parsed.output)
  const t3 = performance.now()

  console.log(`chatService.syncChat: ${(t3 - t2).toFixed(1)} ms, result: ${JSON.stringify(res)}`)
}

// eslint-disable-next-line antfu/no-top-level-await
await main()