import { redirect } from 'next/navigation'
import { calcPagination, parseListParams } from './admin-helpers'
import { canAccess, getAdminContext, type PermissionSet } from './permissions'
import { prisma } from './prisma'

// biome-ignore lint/suspicious/noExplicitAny: explicitly chosen here, see surrounding code
type PrismaModel = any

interface AdminListConfig<TRow> {
  /** Permission slug required to view this page */
  permission: string
  /** Prisma model name (e.g. 'user', 'ban', 'room') */
  model: string
  /** Search field paths for OR filter. Use dot notation for nested relations (e.g. 'owner.username') */
  searchFields: string[]
  /** Default sort when no sort param provided. Default: { id: 'desc' } */
  defaultSort?: Record<string, 'asc' | 'desc'>
  /** Default items per page. Default: 20 */
  defaultPerPage?: number
  /** Prisma include clause for relations */
  include?: Record<string, unknown>
  /** Prisma select clause (mutually exclusive with include) */
  select?: Record<string, unknown>
  /** Fixed WHERE conditions merged with search (e.g. { online: '1' }) */
  baseWhere?: Record<string, unknown>
  /**
   * Map URL ?filter_* params to Prisma WHERE conditions. Each entry receives
   * the raw string value from the URL and returns the WHERE fragment to merge.
   * Returning null/undefined drops the filter.
   *
   * @example
   * filterMap: {
   *   filter_rank: (v) => ({ rank: { gte: Number(v) } }),
   *   filter_online: (v) => ({ online: v }),
   * }
   */
  filterMap?: Record<string, (value: string) => Record<string, unknown> | null | undefined>
  /** Transform raw Prisma row to the shape needed by the table component */
  mapRow?: (row: PrismaModel) => TRow
}

interface AdminListResult<TRow> {
  rows: TRow[]
  total: number
  page: number
  perPage: number
  lastPage: number
  locale: string
  permissions: PermissionSet
  rank: number
}

/**
 * Build a nested Prisma WHERE condition from a dot-notation field path.
 * e.g. 'owner.username' => { owner: { username: { contains: search } } }
 * e.g. 'username' => { username: { contains: search } }
 */
function buildFieldCondition(fieldPath: string, search: string): Record<string, unknown> {
  const parts = fieldPath.split('.')
  if (parts.length === 1) {
    return { [parts[0]]: { contains: search } }
  }
  // Build nested object from right to left
  let result: Record<string, unknown> = { [parts[parts.length - 1]]: { contains: search } }
  for (let i = parts.length - 2; i >= 0; i--) {
    result = { [parts[i]]: result }
  }
  return result
}

/**
 * Generic admin list data fetcher.
 * Centralizes the common pattern: auth check, param parsing, WHERE/orderBy construction,
 * Prisma query with pagination, and row mapping.
 */
export async function fetchAdminList<TRow = PrismaModel>(
  config: AdminListConfig<TRow>,
  paramsPromise: Promise<{ locale: string }>,
  searchParamsPromise: Promise<Record<string, string>>,
): Promise<AdminListResult<TRow>> {
  const { locale } = await paramsPromise
  const { session, permissions } = await getAdminContext()

  if (!canAccess(permissions, config.permission, session.user.rank)) {
    redirect('/admin')
  }

  const rawParams = await searchParamsPromise
  const sp = new URLSearchParams(rawParams)
  const parsed = parseListParams(sp)
  const perPage = config.defaultPerPage
    ? Number(rawParams.perPage) || config.defaultPerPage
    : parsed.perPage
  const { search, page, sort, order } = parsed

  // Build WHERE clause
  const searchWhere =
    search && config.searchFields.length > 0
      ? { OR: config.searchFields.map((field) => buildFieldCondition(field, search)) }
      : {}

  // Apply URL filter_* params via filterMap
  const filterWhere: Record<string, unknown> = {}
  if (config.filterMap) {
    for (const [paramKey, build] of Object.entries(config.filterMap)) {
      const value = rawParams[paramKey]
      if (!value) continue
      const fragment = build(value)
      if (fragment) Object.assign(filterWhere, fragment)
    }
  }

  const where = {
    ...(config.baseWhere ?? {}),
    ...filterWhere,
    ...searchWhere,
  }

  // Build orderBy
  const orderBy = sort ? { [sort]: order } : (config.defaultSort ?? { id: 'desc' as const })

  // Access Prisma model dynamically
  const delegate = (prisma as PrismaModel)[config.model]

  const queryArgs: PrismaModel = {
    where,
    orderBy,
    skip: (page - 1) * perPage,
    take: perPage,
  }

  if (config.include) queryArgs.include = config.include
  if (config.select) queryArgs.select = config.select

  const [rawRows, total] = await Promise.all([
    delegate.findMany(queryArgs),
    delegate.count({ where }),
  ])

  const pagination = calcPagination(total, page, perPage)
  const rows = config.mapRow ? rawRows.map(config.mapRow) : rawRows

  return {
    rows,
    ...pagination,
    locale,
    permissions,
    rank: session.user.rank,
  }
}