import 'server-only'

import { createAdminClient } from '@/lib/supabase/admin'
import { isTripNumberInRange, numberEnvironment, randomTripNumber, tripNumberDigits } from '@/lib/domain/refcode'

/**
 * Permanent register of HHA trip and order numbers (migration 0053).
 * Until the migration is applied, trip creation falls back to a random number
 * in the right range, checked only by the trips table's unique index.
 */
type DbError = { code?: string; message?: string } | null

function isMissingTable(error: DbError): boolean {
  if (!error) return false
  return error.code === '42P01' || error.code === 'PGRST205' || /does not exist|could not find the table/i.test(error.message ?? '')
}

const isDuplicate = (error: DbError) => error?.code === '23505'

async function reserve(kind: 'trip' | 'order', tripId: string | null): Promise<string | null> {
  const admin = createAdminClient()
  const environment = numberEnvironment()
  for (let attempt = 0; attempt < 10; attempt++) {
    const number = randomTripNumber(environment)
    const { error } = await admin.from('issued_trip_numbers').insert({ number, kind, environment, trip_id: tripId })
    if (!error) return number
    if (isMissingTable(error)) return null
    if (!isDuplicate(error)) throw new Error(`issue ${kind} number: ${error.message}`)
  }
  throw new Error(`issue ${kind} number: no free number after 10 attempts`)
}

/** A new, never-used trip reference (HH- + 9 digits) for a trip about to be created. */
export async function issueTripRefCode(): Promise<string> {
  const number = await reserve('trip', null)
  if (number) return `HH-${number}`
  console.warn('[trip-numbers] register missing (migration 0053); using an unregistered number')
  return `HH-${randomTripNumber()}`
}

/** Record which trip a reserved number went to. Safe to call before migration 0053. */
export async function linkTripNumber(refCode: string, tripId: string): Promise<void> {
  const number = tripNumberDigits(refCode)
  if (!number) return
  const { error } = await createAdminClient().from('issued_trip_numbers').update({ trip_id: tripId }).eq('number', number)
  if (error && !isMissingTable(error)) console.warn('[trip-numbers] link failed:', error.message)
}

/**
 * The one Synchron order number for a Workspace trip. A new binding uses the
 * trip number; an existing binding is preserved. It belongs to the trip's
 * assigned carrier for the life of the trip.
 * Synchron-imported (8-digit) trips never get an HHA order number.
 */
export async function orderNumberFor(trip: { id: string; ref_code: string }, carrierCompanyId: string): Promise<string> {
  const admin = createAdminClient()
  const tripNumber = tripNumberDigits(trip.ref_code)
  if (!tripNumber || !isTripNumberInRange(tripNumber)) {
    throw new Error('order_not_purchasable: imported, older, or out-of-range trip reference')
  }
  const { data: currentTrip, error: tripError } = await admin.from('trips')
    .select('carrier_company_id').eq('id', trip.id).maybeSingle()
  if (tripError) throw new Error(`order trip: ${tripError.message}`)
  if (!currentTrip || currentTrip.carrier_company_id !== carrierCompanyId) {
    throw new Error('order_carrier_mismatch: the trip must have this carrier assigned')
  }
  const { data: existing, error } = await admin.from('trip_order_numbers')
    .select('order_number, carrier_company_id').eq('trip_id', trip.id)
  if (error) throw new Error(`order numbers: ${error.message}`)
  if ((existing ?? []).length > 1) throw new Error('order numbers: trip has multiple orders')
  if (existing?.length) {
    if (existing[0].carrier_company_id !== carrierCompanyId) throw new Error('order_carrier_mismatch: trip already has an order for another carrier')
    return existing[0].order_number as string
  }
  const { error: insertError } = await admin.from('trip_order_numbers')
    .insert({ order_number: tripNumber, trip_id: trip.id, carrier_company_id: carrierCompanyId })
  if (insertError) {
    // A concurrent request may have inserted the same binding. Never mint a
    // second number or loop on a different unique-key conflict.
    if (isDuplicate(insertError)) {
      const { data: current, error: readError } = await admin.from('trip_order_numbers')
        .select('order_number, carrier_company_id').eq('trip_id', trip.id)
      if (readError) throw new Error(`order numbers: ${readError.message}`)
      if (current?.length === 1 && current[0].carrier_company_id === carrierCompanyId) return current[0].order_number as string
      throw new Error('order numbers: trip already has an order or number is taken')
    }
    throw new Error(`order numbers: ${insertError.message}`)
  }
  return tripNumber
}

/**
 * Reserve the one Synchron order number for an HHA-created trip immediately
 * before Workspace sends work to Synchron. Imported Synchron trips retain
 * their existing eight-digit order path and therefore return null here.
 */
export async function synchronOrderNumberForTrip(trip: {
  id: string
  ref_code: string
  carrier_company_id?: string | null
}): Promise<string | null> {
  const tripNumber = tripNumberDigits(trip.ref_code)
  if (!tripNumber || !isTripNumberInRange(tripNumber)) return null
  if (!trip.carrier_company_id) {
    throw new Error('carrier_required: Choose the carrier for this trip first.')
  }
  return orderNumberFor(trip, trip.carrier_company_id)
}
