import 'server-only'

import { createAdminClient } from '@/lib/supabase/admin'
import { isRouteProductCode, routeTypeForProduct, type RouteType } from '@/lib/domain/routing-products'
import type { RoutingProduct } from '@/types/db'

/**
 * Backend-authoritative routing prices (task §5). The only place a price is
 * read for a purchase. Until migration 0045 is applied the catalog is empty
 * and every purchase attempt is refused — the app never falls back to a
 * client-supplied or hardcoded price.
 */

export interface ResolvedProduct {
  product_code: string
  product_name: string
  description: string | null
  route_type: RouteType
  unit_price_cents: number
  currency: string
  product_version: number
}

function toResolved(row: RoutingProduct): ResolvedProduct | null {
  if (!isRouteProductCode(row.product_code)) return null
  return {
    product_code: row.product_code,
    product_name: row.product_name,
    description: row.description,
    route_type: routeTypeForProduct(row.product_code),
    unit_price_cents: row.selling_price_cents,
    currency: row.currency,
    product_version: row.product_version,
  }
}

export async function listActiveRoutingProducts(): Promise<ResolvedProduct[]> {
  const { data, error } = await createAdminClient()
    .from('routing_products')
    .select('*')
    .eq('active', true)
    .order('selling_price_cents')
  if (error) return []
  return ((data ?? []) as RoutingProduct[]).map(toResolved).filter((p): p is ResolvedProduct => !!p)
}

export type ProductResolution =
  | { ok: true; product: ResolvedProduct }
  | { ok: false; reason: 'unknown_product' | 'inactive_product' | 'catalog_unavailable' }

export async function resolveRoutingProduct(productCode: string): Promise<ProductResolution> {
  if (!isRouteProductCode(productCode)) return { ok: false, reason: 'unknown_product' }
  const { data, error } = await createAdminClient()
    .from('routing_products')
    .select('*')
    .eq('product_code', productCode)
    .maybeSingle()
  if (error) return { ok: false, reason: 'catalog_unavailable' }
  if (!data) return { ok: false, reason: 'unknown_product' }
  const row = data as RoutingProduct
  if (!row.active) return { ok: false, reason: 'inactive_product' }
  const product = toResolved(row)
  return product ? { ok: true, product } : { ok: false, reason: 'unknown_product' }
}

/** Resolve many codes at once (cart pricing). Unknown codes are omitted. */
export async function resolveRoutingProducts(codes: string[]): Promise<Map<string, ResolvedProduct>> {
  const unique = [...new Set(codes.filter(isRouteProductCode))]
  const map = new Map<string, ResolvedProduct>()
  if (unique.length === 0) return map
  const { data } = await createAdminClient().from('routing_products').select('*').in('product_code', unique).eq('active', true)
  for (const row of (data ?? []) as RoutingProduct[]) {
    const product = toResolved(row)
    if (product) map.set(product.product_code, product)
  }
  return map
}