const where = whereOrdersQuery(filters);

const [genericOrders, count] = await this.prisma.$transaction([
    this.prisma.genericOrder.findMany({
        where,
        take,
        skip: (page - 1) * (take ?? constants.PAGE_COUNT)
    }),
    this.prisma.genericOrder.count({ where })
]);

const whereOrdersQuery = (data: Partial<FiltersDto>): Prisma.GenericOrderWhereInput => {
    const { customerName, reference, corlidoReference, draft, dateFrom, dateTo } = data;

    let newDateTo: Date | undefined;
    if (dateTo) {
        // Add 1 day and subtract 1 ms so that the dateTo filter will be applied correctly.
        newDateTo = addUnitToDate({ value: 1, unit: 'd', date: new Date(dateTo) });
        newDateTo = subtractUnitFromDate({ value: 1, unit: 'ms', date: newDateTo });
    }

    return {
        AND: hasObjectValues(data)
            ? [
                    {
                        buyer:
                            typeof customerName !== 'undefined'
                                ? {
                                        OR: [
                                            {
                                                firstName: {
                                                    contains: customerName,
                                                    mode: 'insensitive'
                                                }
                                            },
                                            {
                                                lastName: {
                                                    contains: customerName,
                                                    mode: 'insensitive'
                                                }
                                            }
                                        ]
                                  }
                                : undefined
                    },
                    {
                        order:
                            typeof corlidoReference !== 'undefined'
                                ? {
                                        corlidoReference: {
                                            contains: corlidoReference,
                                            mode: 'insensitive'
                                        }
                                  }
                                : undefined
                    },
                    {
                        draft: {
                            equals: boolOrUndef(draft)
                        }
                    },
                    {
                        reference:
                            typeof reference !== 'undefined'
                                ? {
                                        contains: reference,
                                        mode: 'insensitive'
                                  }
                                : undefined
                    },
                    {
                        createdAt:
                            typeof dateFrom !== 'undefined'
                                ? {
                                        gte: new Date(dateFrom)
                                  }
                                : undefined
                    },
                    {
                        createdAt:
                            typeof newDateTo !== 'undefined'
                                ? {
                                        lte: newDateTo
                                  }
                                : undefined
                    }
              ]
            : undefined
    };
};

function boolOrUndef(value: boolean | undefined) {
    if (typeof value === 'boolean') {
        return value;
    }
}