/**
 * MongoDB Adapter for lazy-render-server
 * Provides pagination support for MongoDB/Mongoose
 */

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

export interface MongoPaginationResult<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 MongoDB query results
 * 
 * @param model - Mongoose model
 * @param params - Pagination parameters
 * @param query - MongoDB query filter
 * @param sort - Sort options
 * @returns Paginated results
 */
export async function paginateMongo<T>(
  model: any, // Mongoose Model
  params: PaginationParams,
  query: any = {},
  sort: any = { createdAt: -1 }
): Promise<MongoPaginationResult<T>> {
  const { page, limit, sortBy, sortOrder } = params;
  const skip = (page - 1) * limit;
  
  // Build sort object
  const sortOptions: any = {};
  if (sortBy) {
    sortOptions[sortBy] = sortOrder === 'asc' ? 1 : -1;
  } else {
    Object.assign(sortOptions, sort);
  }
  
  // Execute queries in parallel
  const [items, total] = await Promise.all([
    model.find(query)
      .skip(skip)
      .limit(limit)
      .sort(sortOptions)
      .lean(),
    model.countDocuments(query)
  ]);
  
  return calculatePagination(items, page, limit, total, {
    sortBy,
    sortOrder
  }) as MongoPaginationResult<T>;
}

/**
 * Paginate with aggregation pipeline
 * 
 * @param model - Mongoose model
 * @param params - Pagination parameters
 * @param pipeline - Aggregation pipeline
 * @returns Paginated results
 */
export async function paginateMongoAggregation<T>(
  model: any,
  params: PaginationParams,
  pipeline: any[] = []
): Promise<MongoPaginationResult<T>> {
  const { page, limit } = params;
  const skip = (page - 1) * limit;
  
  // Add pagination stages to pipeline
  const paginationPipeline = [
    ...pipeline,
    {
      $facet: {
        data: [
          { $skip: skip },
          { $limit: limit }
        ],
        totalCount: [
          { $count: 'count' }
        ]
      }
    }
  ];
  
  const result = await model.aggregate(paginationPipeline);
  const items = result[0].data;
  const total = result[0].totalCount[0]?.count || 0;
  
  return calculatePagination(items, page, limit, total) as MongoPaginationResult<T>;
}

export default {
  paginateMongo,
  paginateMongoAggregation
};