botfights/server/src/routes/fights.ts

import { Hono } from 'hono'
import { db, schema } from '../db/index.js'
import { eq, desc } from 'drizzle-orm'
import { ARENAS } from '../engine/arenas.js'
import { runMockFight } from '../engine/mock.js'

export const fightsRouter = new Hono()

// List recent fights (with bot names)
fightsRouter.get('/', async (c) => {
  const rows = await db.select()
    .from(schema.fights)
    .orderBy(desc(schema.fights.createdAt))
    .limit(20)

  // Resolve bot names
  const botIds = new Set<string>()
  for (const f of rows) {
    botIds.add(f.botAId)
    botIds.add(f.botBId)
    if (f.winnerId) botIds.add(f.winnerId)
  }

  const botMap = new Map<string, { name: string; avatarSeed: string; eloRating: number; tier: number }>()
  for (const id of botIds) {
    const bot = await db.select({
      name: schema.bots.name,
      avatarSeed: schema.bots.avatarSeed,
      eloRating: schema.bots.eloRating,
      tier: schema.bots.tier,
    }).from(schema.bots).where(eq(schema.bots.id, id)).limit(1)
    if (bot[0]) botMap.set(id, bot[0])
  }

  const enriched = rows.map(f => {
    const arena = ARENAS.find(a => a.id === f.arena)
    return {
      ...f,
      botA: botMap.get(f.botAId) || null,
      botB: botMap.get(f.botBId) || null,
      winner: f.winnerId ? botMap.get(f.winnerId) || null : null,
      arenaInfo: arena ? { name: arena.name, description: arena.description } : null,
    }
  })

  return c.json(enriched)
})

// Get a single fight with rounds and bot details
fightsRouter.get('/:id', async (c) => {
  const id = c.req.param('id')

  const fightRows = await db.select()
    .from(schema.fights)
    .where(eq(schema.fights.id, id))
    .limit(1)

  if (fightRows.length === 0) {
    return c.json({ error: 'Fight not found.' }, 404)
  }

  const fight = fightRows[0]

  const [botARows, botBRows] = await Promise.all([
    db.select({
      id: schema.bots.id,
      name: schema.bots.name,
      avatarSeed: schema.bots.avatarSeed,
      eloRating: schema.bots.eloRating,
      wins: schema.bots.wins,
      losses: schema.bots.losses,
      tier: schema.bots.tier,
    }).from(schema.bots).where(eq(schema.bots.id, fight.botAId)).limit(1),
    db.select({
      id: schema.bots.id,
      name: schema.bots.name,
      avatarSeed: schema.bots.avatarSeed,
      eloRating: schema.bots.eloRating,
      wins: schema.bots.wins,
      losses: schema.bots.losses,
      tier: schema.bots.tier,
    }).from(schema.bots).where(eq(schema.bots.id, fight.botBId)).limit(1),
  ])

  const roundRows = await db.select()
    .from(schema.rounds)
    .where(eq(schema.rounds.fightId, id))
    .orderBy(schema.rounds.roundNumber)

  const arena = ARENAS.find(a => a.id === fight.arena)

  return c.json({
    ...fight,
    botA: botARows[0] || null,
    botB: botBRows[0] || null,
    arenaInfo: arena || null,
    rounds: roundRows,
  })
})

// Trigger a mock fight between two random bots (dev/testing)
fightsRouter.post('/mock', async (c) => {
  const allBots = await db.select({ id: schema.bots.id }).from(schema.bots)

  if (allBots.length < 2) {
    return c.json({ error: 'Need at least 2 registered bots.' }, 400)
  }

  const shuffled = [...allBots].sort(() => Math.random() - 0.5)
  const fightId = await runMockFight(shuffled[0].id, shuffled[1].id)

  return c.json({ fightId, message: 'Mock fight completed.' })
})