/**
 * Prisma Adapter for lazy-render-server
 * Provides pagination support for Prisma ORM
 */

import { calculatePagination, PaginationParams } from '../index';

export interface PrismaPaginationResult<T> {
  data: T[];
  pagination: {
    page: number;
    limit: number;
    total: number;
    totalPages: number;
    hasMore: boolean;
    nextCursor?: string;
    prevCursor?: string;
  };
  meta?: {
    sortBy?: string;
    sortOrder?: 'asc' | 'desc';
    timestamp: string;
  };
}

/**
 * Paginate Prisma query results
 * 
 * @param prisma - Prisma client
 * @param model - Model name
 * @param params - Pagination parameters
 * @param where - Where filter
 * @param orderBy - Order by options
 * @returns Paginated results
 */
export async function paginatePrisma<T>(
  prisma: any, // Prisma client
  model: string,
  params: PaginationParams,
  where: any = {},
  orderBy: any = { createdAt: 'desc' }
): Promise<PrismaPaginationResult<T>> {
  const { page, limit, sortBy, sortOrder } = params;
  const skip = (page - 1) * limit;
  
  // Build order by
  const orderByOptions: any = {};
  if (sortBy) {
    orderByOptions[sortBy] = sortOrder === 'asc' ? 'asc' : 'desc';
  } else {
    Object.assign(orderByOptions, orderBy);
  }
  
  // Execute queries in parallel
  const [items, total] = await Promise.all([
    (prisma as any)[model].findMany({
      where,
      skip,
      take: limit,
      orderBy: orderByOptions
    }),
    (prisma as any)[model].count({ where })
  ]);
  
  return calculatePagination(items, page, limit, total, {
    sortBy,
    sortOrder
  }) as PrismaPaginationResult<T>;
}

/**
 * Paginate with custom Prisma query
 * 
 * @param prisma - Prisma client
 * @param params - Pagination parameters
 * @param findManyArgs - Prisma findMany arguments
 * @param countArgs - Prisma count arguments
 * @returns Paginated results
 */
export async function paginatePrismaCustom<T>(
  prisma: any,
  params: PaginationParams,
  findManyArgs: any,
  countArgs: any = {}
): Promise<PrismaPaginationResult<T>> {
  const { page, limit } = params;
  const skip = (page - 1) * limit;
  
  // Add pagination to findMany args
  const paginatedArgs = {
    ...findManyArgs,
    skip,
    take: limit
  };
  
  // Execute queries in parallel
  const [items, total] = await Promise.all([
    prisma.findMany(paginatedArgs),
    prisma.count(countArgs)
  ]);
  
  return calculatePagination(items, page, limit, total) as PrismaPaginationResult<T>;
}

export default {
  paginatePrisma,
  paginatePrismaCustom
};