import 'server-only'

import { createAdminClient } from '@/lib/supabase/admin'
import { getRouteTokenUsage, type RouteTokenUsageReference } from '@/lib/adapters/flask'
import { inChunks } from '@/lib/data/chunked'
import { routeIncludedWithPermit } from '@/lib/domain/permit-routes'
import { routeAccess, routeFilesVisible, routePurchaseFor, type RouteAccess, type RouteOffer, type TokenUsesSource } from '@/lib/domain/route-offers'
import type { Permit, ServiceRequest, Trip } from '@/types/db'

/**
 * Route offers — the I/O (2026-10-01). Counts how often a route token appears
 * in the permit history and makes sure a route nobody has taken never leaves
 * the server: its links, files and token are removed from every payload
 * until the trip purchases it. Hiding a button is not the control; this is.
 */

type Admin = ReturnType<typeof createAdminClient>
type TripKey = Pick<Trip, 'id' | 'permit_policy' | 'permit_source'>
type RouteRequestRow = Pick<ServiceRequest, 'trip_id' | 'type' | 'state_code' | 'permit_id' | 'status'>

type GatedFields = Pick<Permit, 'id' | 'trip_id' | 'state_code'> & Partial<Pick<Permit,
  'source_system' | 'extraction_status' | 'route_processing_status' | 'route_links' | 'route_gpx_url' | 'route_hummer_url' | 'route_token' | 'extraction'>>

export type WithRouteAccess<T> = T & {
  /** For sale: which product and why. Null when included, purchased or still being read. */
  route_offer: RouteOffer | null
  route_access: RouteAccess['kind']
}

/**
 * TEMPORARY FALLBACK. Permits in HeavyHaul Agent's own database carrying each
 * route token. This is NOT the route history — MongoDB is (Nash, 2026-10-01)
 * — and it holds only the handful of permits uploaded or imported here. It is
 * used only when the backend cannot answer; see `resolveTokenUses`.
 */
type TokenReference = RouteTokenUsageReference

function tokenKey(reference: TokenReference): string {
  return `${reference.stateCode.trim().toUpperCase()}::${reference.routeToken.trim()}`
}

export async function countRouteTokenUses(references: TokenReference[], admin: Admin = createAdminClient()): Promise<Map<string, number>> {
  const unique = [...new Map(references
    .filter((ref) => Boolean(ref.routeToken) && Boolean(ref.stateCode))
    .map((ref) => [tokenKey(ref), ref])).values()]
  const out = new Map<string, number>()
  await Promise.all(unique.map(async ({ routeToken, stateCode }) => {
    const { count, error } = await admin.from('permits').select('id', { count: 'exact', head: true })
      .eq('route_token', routeToken).eq('state_code', stateCode)
    out.set(tokenKey({ routeToken, stateCode }), error ? 0 : (count ?? 0))
  }))
  return out
}

export interface TokenUses { uses: number; source: TokenUsesSource }

/* A short memory of backend answers, so a page with ten permits or a busy
 * dashboard asks MongoDB once, not on every render. A purchase always asks
 * fresh (`fresh: true`). An unavailable backend is remembered briefly too, so
 * a missing endpoint does not add a timeout to every page load. */
const BACKEND_TTL_MS = 5 * 60_000
const BACKEND_DOWN_TTL_MS = 60_000
const backendCache = new Map<string, { uses: number; at: number }>()
let backendDownUntil = 0

/** Test hook: forget what the backend said. */
export function resetRouteTokenUsageCache() {
  backendCache.clear()
  backendDownUntil = 0
}

/**
 * How many permits have used each route token. MongoDB, through the agent
 * backend, is the source of truth:
 *   1. live lookup in MongoDB (`getRouteTokenUsage`)
 *   2. the count the backend returned when it read the permit (`stored`)
 *   3. permits in HeavyHaul Agent's own database — temporary fallback
 */
export async function resolveTokenUses(
  references: TokenReference[],
  opts: { stored?: Map<string, number>; fresh?: boolean; admin?: Admin } = {},
): Promise<Map<string, TokenUses>> {
  const unique = [...new Map(references
    .filter((ref) => Boolean(ref.routeToken) && Boolean(ref.stateCode))
    .map((ref) => [tokenKey(ref), ref])).values()]
  const out = new Map<string, TokenUses>()
  if (unique.length === 0) return out
  const now = Date.now()

  const need: TokenReference[] = []
  for (const reference of unique) {
    const key = tokenKey(reference)
    const hit = backendCache.get(key)
    if (!opts.fresh && hit && now - hit.at < BACKEND_TTL_MS) out.set(key, { uses: hit.uses, source: 'backend' })
    else need.push(reference)
  }
  if (need.length && (opts.fresh || now >= backendDownUntil)) {
    const live = await getRouteTokenUsage(need)
    if (live.ok && live.data) {
      for (const [key, uses] of Object.entries(live.data)) {
        backendCache.set(key, { uses, at: now })
        out.set(key, { uses, source: 'backend' })
      }
    } else {
      backendDownUntil = now + BACKEND_DOWN_TTL_MS
    }
  }

  const missing = unique.filter((ref) => !out.has(tokenKey(ref)))
  for (const reference of missing) {
    const key = tokenKey(reference)
    const stored = opts.stored?.get(key)
    if (stored !== undefined) out.set(key, { uses: stored, source: 'reader' })
  }
  const stillMissing = unique.filter((ref) => !out.has(tokenKey(ref)))
  if (stillMissing.length) {
    const local = await countRouteTokenUses(stillMissing, opts.admin)
    for (const reference of stillMissing) {
      const key = tokenKey(reference)
      out.set(key, { uses: local.get(key) ?? 0, source: 'workspace_db' })
    }
  }
  return out
}

interface TokenRow { id: string; route_token: string | null; state_code: string | null; route_usage_count?: unknown; extraction?: { route_usage_count?: unknown } | null }

/** The largest count the backend reported for a token when it read the permits that carry it. */
function storedCounts(rows: TokenRow[]): Map<string, number> {
  const out = new Map<string, number>()
  for (const r of rows) {
    const raw = r.route_usage_count ?? r.extraction?.route_usage_count
    const n = typeof raw === 'number' ? raw : typeof raw === 'string' && /^\d+$/.test(raw) ? Number(raw) : NaN
    if (r.route_token && r.state_code && Number.isInteger(n) && n >= 0) {
      const key = tokenKey({ routeToken: r.route_token, stateCode: r.state_code })
      out.set(key, Math.max(out.get(key) ?? 0, n))
    }
  }
  return out
}

/** Route tokens are not selected by every loader; fetch them, with the reader's count, for the permits that need a price. */
async function tokensFor(permitIds: string[], admin: Admin): Promise<{ byPermit: Map<string, string | null>; stored: Map<string, number> }> {
  if (permitIds.length === 0) return { byPermit: new Map(), stored: new Map() }
  const { data, error } = await inChunks<TokenRow>(permitIds, (chunk) =>
    admin.from('permits').select('id, route_token, state_code, route_usage_count:extraction->route_usage_count').in('id', chunk))
  if (error) throw new Error('Could not load route tokens')
  return { byPermit: new Map(data.map((r) => [r.id, r.route_token])), stored: storedCounts(data) }
}

/**
 * Decide each permit's route access and strip what the trip has not paid for.
 * `requests` may be passed when the caller already loaded them; otherwise the
 * chargeable trips' live route purchases are read here in bounded queries.
 */
export async function applyRouteAccess<T extends GatedFields>(
  trips: TripKey[],
  permits: T[],
  opts: { requests?: RouteRequestRow[]; admin?: Admin } = {},
): Promise<Array<WithRouteAccess<T>>> {
  if (permits.length === 0) return []
  const admin = opts.admin ?? createAdminClient()
  const tripById = new Map(trips.map((t) => [t.id, t]))
  // Synchron routes are already included. Only HHA permits can need a
  // purchase or a token-use price; avoid fetching thousands of imported
  // Synchron tokens when an admin opens the full dashboard.
  const chargeable = permits.filter((p) => {
    const trip = tripById.get(p.trip_id)
    return trip && !routeIncludedWithPermit(trip, p)
  })
  let requests = opts.requests
  if (!requests) {
    const { data, error } = await inChunks<RouteRequestRow>(chargeable.map((p) => p.trip_id), (chunk) =>
      admin.from('service_requests').select('trip_id, type, state_code, permit_id, status')
        .in('trip_id', chunk).eq('type', 'route_request').neq('status', 'cancelled'))
    if (error) throw new Error('Could not load route purchases')
    requests = data
  }
  const byTrip = new Map<string, RouteRequestRow[]>()
  for (const r of requests) byTrip.set(r.trip_id, [...(byTrip.get(r.trip_id) ?? []), r])

  const offers = chargeable.filter((p) =>
    p.extraction_status !== 'pending' && !!p.state_code && !routePurchaseFor(byTrip.get(p.trip_id) ?? [], p.state_code, p.id))
  const { byPermit: tokenByPermit, stored } = await tokensFor(offers.map((p) => p.id), admin)
  const references = offers.flatMap((permit) => {
    const routeToken = tokenByPermit.get(permit.id)
    return routeToken && permit.state_code ? [{ routeToken, stateCode: permit.state_code }] : []
  })
  const uses = await resolveTokenUses(references, { stored, admin })

  return permits.map((p) => {
    const trip = tripById.get(p.trip_id)
    const token = tokenByPermit.get(p.id) ?? null
    const access: RouteAccess = trip
      ? routeAccess({
          trip,
          permit: {
            // The permit id is what ties a route purchase to this exact permit (T2, migration 0060).
            id: p.id, source_system: p.source_system ?? null, state_code: p.state_code, extraction_status: p.extraction_status ?? 'processed',
            route_processing_status: p.route_processing_status, route_links: p.route_links ?? null,
            route_gpx_url: p.route_gpx_url ?? null, route_hummer_url: p.route_hummer_url ?? null,
          },
          requests: byTrip.get(p.trip_id) ?? [],
          tokenUses: token && p.state_code ? uses.get(tokenKey({ routeToken: token, stateCode: p.state_code }))?.uses ?? 0 : 0,
          usesSource: token && p.state_code ? uses.get(tokenKey({ routeToken: token, stateCode: p.state_code }))?.source ?? 'none' : 'none',
        })
      // A permit whose trip is unknown to the caller is never unlocked.
      : { kind: 'reading' }
    const base = { ...p, route_access: access.kind, route_offer: access.kind === 'offer' ? { route_type: access.route_type, token_uses: access.token_uses, uses_source: access.uses_source } : null }
    if (routeFilesVisible(access)) return base as WithRouteAccess<T>
    return lockRouteFiles(base) as WithRouteAccess<T>
  })
}

/** Remove every copy of the route from a permit row: columns and the stored extraction. */
export function lockRouteFiles<T extends Partial<Pick<Permit, 'route_links' | 'route_gpx_url' | 'route_hummer_url' | 'route_token' | 'extraction'>>>(p: T): T {
  const out: T = { ...p }
  if ('route_links' in out) out.route_links = []
  if ('route_gpx_url' in out) out.route_gpx_url = null
  if ('route_hummer_url' in out) out.route_hummer_url = null
  if ('route_token' in out) out.route_token = null
  if (out.extraction && typeof out.extraction === 'object') {
    const { route_links: _l, route_gpx_url: _g, route_hummer_url: _h, route_token: _t, raw: _r, ...rest } = out.extraction as Record<string, unknown>
    void _l; void _g; void _h; void _t; void _r
    out.extraction = rest as T['extraction']
  }
  return out
}

/** The server's answer to "what may be done with this permit's route?" — used by the purchase endpoints. */
export async function routeAccessForPermit(params: { trip: Trip; permitId?: string; stateCode?: string | null; admin?: Admin }): Promise<
  { ok: true; permit: Permit; access: RouteAccess } | { ok: false; error: string; status: number }
> {
  const admin = params.admin ?? createAdminClient()
  let query = admin.from('permits').select('*').eq('trip_id', params.trip.id)
  if (params.permitId) query = query.eq('id', params.permitId)
  else if (params.stateCode) query = query.eq('state_code', params.stateCode)
  else return { ok: false, error: 'Choose a permit.', status: 400 }
  const { data } = await query.order('created_at', { ascending: false }).limit(1)
  const permit = ((data ?? []) as Permit[])[0]
  if (!permit) return { ok: false, error: 'That permit is not on this trip.', status: 400 }
  const { data: requests } = await admin.from('service_requests').select('trip_id, type, state_code, permit_id, status')
    .eq('trip_id', params.trip.id).eq('type', 'route_request').neq('status', 'cancelled')
  // A purchase asks MongoDB fresh — the price must be right at the moment it is paid.
  const uses = await resolveTokenUses(
    permit.route_token && permit.state_code ? [{ routeToken: permit.route_token, stateCode: permit.state_code }] : [],
    { stored: storedCounts([permit as unknown as TokenRow]), fresh: true, admin },
  )
  const found = permit.route_token && permit.state_code ? uses.get(tokenKey({ routeToken: permit.route_token, stateCode: permit.state_code })) : undefined
  const access = routeAccess({ trip: params.trip, permit, requests: (requests ?? []) as RouteRequestRow[], tokenUses: found?.uses ?? 0, usesSource: found?.source ?? 'none' })
  return { ok: true, permit, access }
}
