import { addBusinessHours, alertSendTime, businessMillisBetween } from '@/lib/domain/business-hours'

/**
 * Late-delivery alerts for Extended routes (owner decisions 033–046, B017,
 * B031–B035; Nash 2026-10-07 item 1; recipient info@synchronpermits.com for now).
 *
 * Each Extended purchase has its own clock, starting at payment (paid_at) and
 * counting business hours only. Checkpoint k falls k business hours after
 * payment, and by then min(k, N) of its N Extended routes should be delivered
 * (1 by hour 1, 2 by hour 2, …). Every missed checkpoint is one alert; a
 * checkpoint that was caught up gets none. Checkpoints keep coming hourly
 * while routes are still pending (reading of "an alert at every missed hourly
 * checkpoint"). Express routes are excluded. An alert due outside business
 * hours is sent at the next opening. English only; internal to Synchron.
 */
export interface ExtendedItem { label: string; deliveredAt: Date | null }

export interface DueAlert {
  checkpoint: number
  dueAt: Date
  sendAt: Date
  expected: number
  delivered: number
  pending: number
  completedItems: string[]
  pendingItems: string[]
  elapsedBusinessMs: number
}

export function dueLateDeliveryAlerts(params: {
  paidAt: Date
  items: ExtendedItem[]
  now: Date
  /** Checkpoints already alerted, so each one is sent once. */
  alreadySent: number[]
  /** Safety cap on checkpoints examined per run. */
  maxCheckpoints?: number
}): DueAlert[] {
  const total = params.items.length
  if (total === 0) return []
  const sent = new Set(params.alreadySent)
  const out: DueAlert[] = []
  const cap = params.maxCheckpoints ?? 200
  for (let k = 1; k <= cap; k++) {
    const dueAt = addBusinessHours(params.paidAt, k)
    if (dueAt.getTime() > params.now.getTime()) break
    const deliveredBy = params.items.filter((i) => i.deliveredAt && i.deliveredAt.getTime() <= dueAt.getTime())
    if (deliveredBy.length === total && k >= total) break // everything delivered: no later checkpoints
    const expected = Math.min(k, total)
    if (deliveredBy.length >= expected || sent.has(k)) continue
    out.push({
      checkpoint: k, dueAt, sendAt: alertSendTime(dueAt), expected,
      delivered: deliveredBy.length, pending: total - deliveredBy.length,
      completedItems: deliveredBy.map((i) => i.label),
      pendingItems: params.items.filter((i) => !deliveredBy.includes(i)).map((i) => i.label),
      elapsedBusinessMs: businessMillisBetween(params.paidAt, dueAt),
    })
  }
  return out
}

/** "3 h 00 min" from business milliseconds. */
export function formatBusinessDuration(ms: number): string {
  const minutes = Math.round(ms / 60_000)
  return `${Math.floor(minutes / 60)} h ${String(minutes % 60).padStart(2, '0')} min`
}

/** Template variables for the late_delivery_alert email. */
export function lateDeliveryEmailVars(params: { tripId: string; orderNumber: string; carrierName: string; total: number; alert: DueAlert }): Record<string, string> {
  return {
    trip_id: params.tripId,
    order_number: params.orderNumber,
    carrier_company: params.carrierName,
    extended_route_total: String(params.total),
    elapsed_business_time: formatBusinessDuration(params.alert.elapsedBusinessMs),
    delivered_count: String(params.alert.delivered),
    pending_count: String(params.alert.pending),
    completed_items: params.alert.completedItems.join('\n') || 'None yet',
    pending_items: params.alert.pendingItems.join('\n'),
  }
}

export const LATE_DELIVERY_ALERT_RECIPIENT = 'info@synchronpermits.com'
