routerResolver.ts

import { existsSync } from "node:fs"
import { isAbsolute, join } from "node:path"
import { log } from "../utils/logger"
import { analyzeFile } from "./analyzer"
import { resolveNamedImport, resolveRouterFromInit } from "./importResolver"
import type { FileAnalysis, RouterInfo, RouterNode } from "./internal"
import type { Parser } from "./parser"

export type { RouterNode }

/**
 * Finds the main FastAPI app or APIRouter in the list of routers.
 * If targetVariable is specified, only returns the router with that variable name.
 * Otherwise, prioritizes FastAPI apps over APIRouters.
 */
function findAppRouter(
  routers: RouterInfo[],
  targetVariable?: string,
): RouterInfo | undefined {
  if (targetVariable) {
    return routers.find((r) => r.variableName === targetVariable)
  }
  return (
    routers.find((r) => r.type === "FastAPI") ??
    routers.find((r) => r.type === "APIRouter")
  )
}

/**
 * Builds a router graph starting from the given entry file.
 * If targetVariable is specified, only that specific app/router will be used.
 */
export function buildRouterGraph(
  entryFile: string,
  parser: Parser,
  projectRoot: string,
  targetVariable?: string,
): RouterNode | null {
  return buildRouterGraphInternal(
    entryFile,
    parser,
    projectRoot,
    new Set(),
    targetVariable,
  )
}

/**
 * Internal recursive function to build the router graph.
 */
function buildRouterGraphInternal(
  entryFile: string,
  parser: Parser,
  projectRoot: string,
  visited: Set<string>,
  targetVariable?: string,
): RouterNode | null {
  // Resolve the full path of the entry file if necessary
  let resolvedEntryFile = entryFile

  if (!existsSync(resolvedEntryFile) && !isAbsolute(entryFile)) {
    resolvedEntryFile = join(projectRoot, entryFile)
  }

  if (!existsSync(resolvedEntryFile)) {
    log(`File not found: "${entryFile}"`)
    return null
  }
  // Prevent infinite recursion on circular imports
  if (visited.has(resolvedEntryFile)) {
    log(`Skipping already visited file: "${resolvedEntryFile}"`)
    return null
  }

  visited.add(resolvedEntryFile)

  // Analyze the entry file
  let analysis = analyzeFile(resolvedEntryFile, parser)
  if (!analysis) {
    log(`Failed to analyze file: "${resolvedEntryFile}"`)
    return null
  }

  log(
    `Analyzed "${resolvedEntryFile}": ${analysis.routes.length} routes, ${analysis.routers.length} routers, ${analysis.includeRouters.length} include_router calls`,
  )

  // Find FastAPI instantiation (filter by targetVariable if specified)
  let appRouter = findAppRouter(analysis.routers, targetVariable)

  // If no FastAPI/APIRouter found and this is an __init__.py, check for re-exports
  if (!appRouter && resolvedEntryFile.endsWith("__init__.py")) {
    const actualRouterFile = resolveRouterFromInit(
      resolvedEntryFile,
      projectRoot,
      parser,
    )
    if (actualRouterFile && !visited.has(actualRouterFile)) {
      visited.add(actualRouterFile)
      const actualAnalysis = analyzeFile(actualRouterFile, parser)
      if (actualAnalysis) {
        const actualRouter = findAppRouter(actualAnalysis.routers)
        if (actualRouter) {
          analysis = actualAnalysis
          appRouter = actualRouter
          resolvedEntryFile = actualRouterFile
        }
      }
    }
  }

  if (!appRouter || !analysis) {
    return null
  }

  // Find all routers included in the app
  // Only include routes that belong directly to the app (not to local APIRouters)
  const appRoutes = analysis.routes.filter(
    (r) => r.owner === appRouter.variableName,
  )
  const rootRouter: RouterNode = {
    filePath: resolvedEntryFile,
    variableName: appRouter.variableName,
    type: appRouter.type,
    prefix: appRouter.prefix,
    tags: appRouter.tags,
    line: appRouter.line,
    column: appRouter.column,
    routes: appRoutes.map((r) => ({
      method: r.method,
      path: r.path,
      function: r.function,
      line: r.line,
      column: r.column,
    })),
    children: [],
  }

  // Process include_router calls to find child routers
  for (const include of analysis.includeRouters) {
    log(
      `Resolving include_router: ${include.router} (prefix: ${include.prefix || "none"})`,
    )
    const childRouter = resolveRouterReference(
      include.router,
      analysis,
      resolvedEntryFile,
      projectRoot,
      parser,
      visited,
    )
    if (childRouter) {
      // Merge tags from include_router call with the router's own tags
      if (include.tags.length > 0) {
        childRouter.tags = [...new Set([...childRouter.tags, ...include.tags])]
      }
      rootRouter.children.push({
        router: childRouter,
        prefix: include.prefix,
        tags: include.tags,
      })
    }
  }

  // Process mount() calls for subapps
  for (const mount of analysis.mounts) {
    const childRouter = resolveRouterReference(
      mount.app,
      analysis,
      resolvedEntryFile,
      projectRoot,
      parser,
      visited,
    )
    if (childRouter) {
      rootRouter.children.push({
        router: childRouter,
        prefix: mount.path,
        tags: [],
      })
    }
  }

  return rootRouter
}

/**
 * Resolves a router/app reference to its RouterNode.
 * Used for include_router and mount calls.
 */
function resolveRouterReference(
  reference: string,
  analysis: FileAnalysis,
  currentFile: string,
  projectRoot: string,
  parser: Parser,
  visited: Set<string>,
): RouterNode | null {
  const parts = reference.split(".")
  const moduleName = parts[0]

  // First, check if this is a local router defined in the same file
  const localRouter = analysis.routers.find(
    (r) => r.variableName === moduleName && r.type === "APIRouter",
  )
  if (localRouter) {
    // Filter routes that belong to this router (decorated with @router.method)
    const routerRoutes = analysis.routes.filter((r) => r.owner === moduleName)
    return {
      filePath: currentFile,
      variableName: localRouter.variableName,
      type: localRouter.type,
      prefix: localRouter.prefix,
      tags: localRouter.tags,
      line: localRouter.line,
      column: localRouter.column,
      routes: routerRoutes.map((r) => ({
        method: r.method,
        path: r.path,
        function: r.function,
        line: r.line,
        column: r.column,
      })),
      children: [],
    }
  }

  // Otherwise, look for an imported router
  const matchingImport = analysis.imports.find((imp) =>
    imp.names.includes(moduleName),
  )

  if (!matchingImport) {
    log(`No import found for router reference: ${reference}`)
    return null
  }

  // Find the original import name (in case moduleName is an alias)
  // e.g., "from .api_tokens import router as api_tokens_router"
  // moduleName = "api_tokens_router", originalName = "router"
  const namedImport = matchingImport.namedImports.find(
    (ni) => (ni.alias ?? ni.name) === moduleName,
  )
  const originalName = namedImport?.name ?? moduleName

  const importedFilePath = resolveNamedImport(
    {
      modulePath: matchingImport.modulePath,
      names: [originalName],
      isRelative: matchingImport.isRelative,
      relativeDots: matchingImport.relativeDots,
    },
    currentFile,
    projectRoot,
    parser,
  )

  if (!importedFilePath) {
    log(`Could not resolve import: ${matchingImport.modulePath}`)
    return null
  }

  return buildRouterGraphInternal(
    importedFilePath,
    parser,
    projectRoot,
    visited,
  )
}