import { eq, inArray } from 'drizzle-orm'
import { useDb } from '../database/client'
import { expenseParticipants, expenses, participants, pots } from '../database/schema'

export interface ExpenseWithDetails {
  id: number
  type: string
  description: string
  amountCents: number
  payerId: number
  participantIds: number[]
  createdAt: number
}

export async function getPotOrThrow(slug: string) {
  const db = useDb()
  const [pot] = await db.select().from(pots).where(eq(pots.slug, slug))
  if (!pot) {
    throw createError({ statusCode: 404, statusMessage: 'Pot not found' })
  }
  return pot
}

export async function getParticipants(slug: string) {
  const db = useDb()
  return db.select().from(participants).where(eq(participants.potSlug, slug))
}

export async function getExpensesWithParticipants(slug: string): Promise<ExpenseWithDetails[]> {
  const db = useDb()
  const expenseRows = await db.select().from(expenses).where(eq(expenses.potSlug, slug)).orderBy(expenses.createdAt)
  if (expenseRows.length === 0) return []

  const expenseIds = expenseRows.map(row => row.id)
  const links = await db.select().from(expenseParticipants).where(inArray(expenseParticipants.expenseId, expenseIds))

  const participantIdsByExpense = new Map<number, number[]>()
  for (const link of links) {
    const list = participantIdsByExpense.get(link.expenseId) ?? []
    list.push(link.participantId)
    participantIdsByExpense.set(link.expenseId, list)
  }

  return expenseRows.map(row => ({
    id: row.id,
    type: row.type,
    description: row.description,
    amountCents: row.amountCents,
    payerId: row.payerId,
    participantIds: participantIdsByExpense.get(row.id) ?? [],
    createdAt: row.createdAt,
  }))
}