import { inArray } from 'drizzle-orm';
import { buildQuery } from '../queries/buildQuery.js';
import { selectDistinct } from '../queries/selectDistinct.js';
import { transform } from '../transform/read/index.js';
import { getNameFromDrizzleTable } from '../utilities/getNameFromDrizzleTable.js';
import { getTransaction } from '../utilities/getTransaction.js';
import { buildFindManyArgs } from './buildFindManyArgs.js';
export const findMany = async function find({ adapter, collectionSlug, draftsEnabled, fields, joins: joinQuery, limit: limitArg, locale, page = 1, pagination, req, select, sort, tableName, versions, where: whereArg }) {
    let limit = limitArg;
    let totalDocs;
    let totalPages;
    let hasPrevPage;
    let hasNextPage;
    let pagingCounter;
    const offset = (page - 1) * limit;
    if (limit === 0) {
        pagination = false;
        limit = undefined;
    }
    const { joins, orderBy, selectFields, where } = buildQuery({
        adapter,
        fields,
        locale,
        sort,
        tableName,
        where: whereArg
    });
    const orderedIDMap = {};
    let orderedIDs;
    const findManyArgs = buildFindManyArgs({
        adapter,
        collectionSlug,
        depth: 0,
        draftsEnabled,
        fields,
        joinQuery,
        joins,
        locale,
        select,
        tableName,
        versions
    });
    if (orderBy) {
        for(const key in selectFields){
            const column = selectFields[key];
            if (!column || column.primary) {
                continue;
            }
            if (!orderBy.some((col)=>col.column.name === column.name && getNameFromDrizzleTable(col.column.table) === getNameFromDrizzleTable(column.table))) {
                delete selectFields[key];
            }
        }
    }
    const db = await getTransaction(adapter, req);
    const selectDistinctResult = await selectDistinct({
        adapter,
        db,
        joins,
        query: ({ query })=>{
            if (orderBy) {
                query = query.orderBy(()=>orderBy.map(({ column, order })=>order(column)));
            }
            return query.offset(offset).limit(limit);
        },
        selectFields,
        tableName,
        where
    });
    if (selectDistinctResult) {
        if (selectDistinctResult.length === 0) {
            return {
                docs: [],
                hasNextPage: false,
                hasPrevPage: false,
                limit,
                nextPage: null,
                page: 1,
                pagingCounter: 0,
                prevPage: null,
                totalDocs: 0,
                totalPages: 0
            };
        } else {
            // set the id in an object for sorting later
            selectDistinctResult.forEach(({ id }, i)=>{
                orderedIDMap[id] = i;
            });
            orderedIDs = Object.keys(orderedIDMap);
            findManyArgs.where = inArray(adapter.tables[tableName].id, orderedIDs);
        }
    } else {
        findManyArgs.limit = limit;
        findManyArgs.offset = offset;
        findManyArgs.orderBy = ()=>orderBy.map(({ column, order })=>order(column));
        if (where) {
            findManyArgs.where = where;
        }
    }
    const findPromise = db.query[tableName].findMany(findManyArgs);
    if (pagination !== false && (orderedIDs ? orderedIDs?.length <= limit : true)) {
        totalDocs = await adapter.countDistinct({
            db,
            joins,
            tableName,
            where
        });
        totalPages = typeof limit === 'number' && limit !== 0 ? Math.ceil(totalDocs / limit) : 1;
        hasPrevPage = page > 1;
        hasNextPage = totalPages > page;
        pagingCounter = (page - 1) * limit + 1;
    }
    const rawDocs = await findPromise;
    // sort rawDocs from selectQuery
    if (Object.keys(orderedIDMap).length > 0) {
        rawDocs.sort((a, b)=>orderedIDMap[a.id] - orderedIDMap[b.id]);
    }
    if (pagination === false || !totalDocs) {
        totalDocs = rawDocs.length;
        totalPages = 1;
        pagingCounter = 1;
        hasPrevPage = false;
        hasNextPage = false;
    }
    const docs = rawDocs.map((data)=>{
        return transform({
            adapter,
            config: adapter.payload.config,
            data,
            fields,
            joinQuery,
            tableName
        });
    });
    return {
        docs,
        hasNextPage,
        hasPrevPage,
        limit: limitArg,
        nextPage: hasNextPage ? page + 1 : null,
        page,
        pagingCounter,
        prevPage: hasPrevPage ? page - 1 : null,
        totalDocs,
        totalPages
    };
};

//# sourceMappingURL=findMany.js.map