// Server-only account and payment helpers shared by server functions and the
// Moolre webhook.
import { and, eq, ne, sql } from 'drizzle-orm'
import { db } from '../../db/index.js'
import { accounts, payments } from '../../db/schema.js'
import { sendAutoSms } from './auto-sms.server'
import { sendReceiptEmail } from './email.server'
import { checkPaymentStatus } from './moolre.server'
import { notify } from './notifications.server'
import { formatCedis, getPackage } from './pricing'

export async function ensureAccount(user: { id: string; email?: string | null; name?: string | null }) {
  const [existing] = await db.select().from(accounts).where(eq(accounts.userId, user.id))
  if (existing) {
    // Keeps the stored email and name in step after a customer changes them in Settings.
    const changes = {
      ...(user.email && existing.email !== user.email ? { email: user.email } : {}),
      ...(user.name && existing.name !== user.name ? { name: user.name } : {}),
    }
    if (Object.keys(changes).length > 0) {
      const [synced] = await db
        .update(accounts)
        .set(changes)
        .where(eq(accounts.userId, user.id))
        .returning()
      return synced ?? existing
    }
    return existing
  }
  const [created] = await db
    .insert(accounts)
    .values({ userId: user.id, email: user.email ?? '', name: user.name ?? null })
    .onConflictDoNothing()
    .returning()
  if (created) return created
  const [row] = await db.select().from(accounts).where(eq(accounts.userId, user.id))
  return row
}

// Asks Moolre for the real status of a payment and, if it succeeded for the
// expected amount, credits the account exactly once. Never trusts the caller.
export async function settlePayment(reference: string) {
  const [payment] = await db.select().from(payments).where(eq(payments.reference, reference))
  if (!payment) return null
  if (payment.status !== 'pending') return payment

  const result = await checkPaymentStatus(reference)

  if (result.status === 'failed') {
    const [updated] = await db
      .update(payments)
      .set({ status: 'failed', completedAt: new Date() })
      .where(and(eq(payments.id, payment.id), eq(payments.status, 'pending')))
      .returning()
    return updated ?? payment
  }

  if (result.status !== 'success') return payment

  if (result.amount != null && result.amount + 0.001 < Number(payment.amount)) {
    console.error('Moolre payment amount mismatch', reference)
    const [updated] = await db
      .update(payments)
      .set({ status: 'failed', completedAt: new Date() })
      .where(and(eq(payments.id, payment.id), eq(payments.status, 'pending')))
      .returning()
    return updated ?? payment
  }

  // The conditional update makes crediting idempotent across concurrent
  // webhook deliveries and redirect checks.
  const [claimed] = await db
    .update(payments)
    .set({
      status: 'success',
      completedAt: new Date(),
      providerReference: result.transactionId ?? payment.providerReference,
      payerPhone: result.payer ?? payment.payerPhone,
    })
    .where(and(eq(payments.id, payment.id), ne(payments.status, 'success')))
    .returning()

  if (claimed) {
    const [account] = await db
      .update(accounts)
      .set({ credits: sql`${accounts.credits} + ${payment.credits}` })
      .where(eq(accounts.userId, payment.userId))
      .returning({ credits: accounts.credits })
    const bundle = getPackage(payment.packageId)?.name
    await notify(payment.userId, {
      type: 'purchase',
      title: `${payment.credits.toLocaleString()} SMS credits added`,
      body: `Your payment of ${formatCedis(Number(payment.amount))}${bundle ? ` for the ${bundle} bundle` : ''} was successful. New balance: ${(account?.credits ?? 0).toLocaleString()} credits. Reference ${payment.reference}.`,
    })
    await sendAutoSms(
      payment.userId,
      'purchase',
      {
        credits: payment.credits.toLocaleString('en-GH'),
        amount: formatCedis(Number(payment.amount)),
        bundle: bundle ?? 'credit',
        reference: payment.reference,
      },
      claimed.payerPhone,
    )
    await sendReceiptEmail(claimed.id)
    return claimed
  }
  const [current] = await db.select().from(payments).where(eq(payments.id, payment.id))
  return current
}

// Atomically spends credits; returns false when the balance is too low.
export async function spendCredits(userId: string, amount: number) {
  const [row] = await db
    .update(accounts)
    .set({ credits: sql`${accounts.credits} - ${amount}` })
    .where(and(eq(accounts.userId, userId), sql`${accounts.credits} >= ${amount}`))
    .returning({ credits: accounts.credits })
  return Boolean(row)
}

export async function refundCredits(userId: string, amount: number) {
  if (amount <= 0) return
  await db
    .update(accounts)
    .set({ credits: sql`${accounts.credits} + ${amount}` })
    .where(eq(accounts.userId, userId))
}
