/**
 * Route discovery from a Fastify instance.
 * Pure functions, no side effects.
 *
 * Fastify 5 removed the public `routes` array. We capture routes via the `onRoute`
 * hook during plugin registration and store them in a WeakMap keyed by the instance.
 */
import { extractContract } from './contract.js'
import type { RouteContract } from '../types.js'

interface CapturedRoute {
  method: string
  url: string
  schema?: Record<string, unknown>
  prefix?: string
}
// WeakMap to store captured routes per Fastify instance (no memory leaks)
const capturedRoutes = new WeakMap<object, CapturedRoute[]>()
/**
 * Capture a route for discovery.
 * Called from the plugin's `onRoute` hook.
 */
export const captureRoute = (
  instance: object,
  route: CapturedRoute
): void => {
  const existing = capturedRoutes.get(instance) ?? []
  existing.push(route)
  capturedRoutes.set(instance, existing)
}

/**
 * Fallback route discovery for Fastify 5 when routes were registered before
 * the APOPHIS plugin (e.g., external apps loaded by CLI).
 * Uses hasRoute to test known route patterns.
 */
function discoverRoutesFallback(
  instance: { hasRoute?: (opts: { method: string; url: string }) => boolean }
): RouteContract[] {
  if (typeof instance.hasRoute !== 'function') {
    return []
  }

  // Common HTTP methods to test
  const methods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS']

  // We can't enumerate all possible routes, but we can check if the instance
  // has any routes at all by testing a few common patterns
  // This is a best-effort fallback
  const routes: RouteContract[] = []

  // Try to extract routes from the instance's internal state
  // Fastify stores routes in find-my-way router, but it's not directly accessible
  // We'll use a heuristic: check if the instance responds to common route methods

  // Check if instance has any routes by looking at prototype methods
  const hasRouting = typeof (instance as any).routing === 'function'
  if (!hasRouting) {
    return []
  }

  // Since we can't enumerate routes in Fastify 5 without the onRoute hook,
  // we return empty and let the caller handle the "no routes" case
  return []
}

/**
 * Discover routes from a Fastify instance.
 *
 * First checks captured routes (from onRoute hook), then falls back to
 * the legacy `routes` array for Fastify 4 compatibility.
 */
export const discoverRoutes = (instance: { routes?: Array<{ method: string; url: string; schema?: Record<string, unknown> }>; hasRoute?: (opts: { method: string; url: string }) => boolean }): RouteContract[] => {
  // Fastify 5: routes captured via onRoute hook
  const captured = capturedRoutes.get(instance)
  if (captured && captured.length > 0) {
    return captured.map((route) =>
      extractContract(route.url, route.method, route.schema)
    )
  }
  // Fastify 4 fallback
  if (Array.isArray(instance.routes) && instance.routes.length > 0) {
    return instance.routes.map((route) =>
      extractContract(route.url, route.method, route.schema)
    )
  }
  // Fastify 5 fallback: routes registered before plugin
  return discoverRoutesFallback(instance)
}
/**
 * Clear captured routes for an instance (useful for testing).
 */
export const clearCapturedRoutes = (instance: object): void => {
  capturedRoutes.delete(instance)
}