async function computeProjects() {
    const descansoThis = (x, inicio, final) =>
        x.inicio >= inicio && ((final && x.final && x.final <= final) || (!x.final && !final));
    const hoy = new Date();
    await db.delete(computoFichadosProyectos).where(lte(computoFichadosProyectos.createdAt, hoy));
    const select = await db.select().from(proyectos);
    function gad(p, x) {
        try {
            const start0 = x.inicio as Date;
            const end0 = x.final;
            const len = end0.getTime() - start0.getTime();
            return p + len;
        } catch {
            return p;
        }
    }
    async function computeFichs(item: Record<string, unknown>, idp: number) {
        const descansos = await db
            .select()
            .from(fichajesDescansos)
            .where(
                and(eq(fichajesDescansos.fichajeId, item.id as number), isNotNull(fichajesDescansos.final))
            );
        const start = item.inicio as Date;
        const cambio = await db
            .select()
            .from(fichajesCambiosProyecto)
            .where(eq(fichajesCambiosProyecto.fichajeId, item.id as number))
            .orderBy(desc(fichajesCambiosProyecto.id));
        const end = cambio[0] ? cambio[0].inicio : item.final;

        const durcambios = cambio.reduce((p, x) => {
            if (x.id_proyecto === item.id_proyecto) {
                try {
                    const start = x.inicio as Date;
                    const end = x.final;
                    const len = end.getTime() - start.getTime();
                    return p + len;
                } catch {
                    return p;
                }
            } else {
                return p;
            }
        }, 0);
        const len = end ? end.getTime() - start.getTime() : 'pending';
        let result;
        if (item.id_proyecto === idp) {
            result =
                len === 'pending'
                    ? 0
                    : len -
                        descansos
                            .filter((x) => {
                                return (
                                    (item.id_proyecto === idp && descansoThis(x, start, end)) ||
                                    cambio
                                        .filter((y) => y.id_proyecto === idp)
                                        .some((y) => descansoThis(x, y.inicio, y.final))
                                );
                            })
                            .reduce(gad, 0) +
                        durcambios;
        } else {
            result = -descansos.reduce(gad, 0) + durcambios;
        }

        try {
            await db.insert(computoFichadosProyectos).values({
                id_proyecto: item.id_proyecto as number,
                id_capitulo: item.id_capitulo as number,
                idUsuario: item.idUsuario as string,
                idFichaje: item.id as number,
                inicio: item.inicio as Date,
                final: end as Date,
                createdAt: hoy as Date,
                computoNeto: result
            });
        } catch (e) {
            await db.update(computoFichadosProyectos).set({
                computoNeto:
                    BigInt(result) +
                    (
                        await db
                            .select()
                            .from(computoFichadosProyectos)
                            .where(
                                and(
                                    eq(computoFichadosProyectos.id_proyecto, item.id_proyecto as number),
                                    eq(computoFichadosProyectos.id_capitulo, item.id_capitulo as number),
                                    eq(computoFichadosProyectos.idUsuario, item.idUsuario as string),
                                    eq(computoFichadosProyectos.idFichaje, item.id as number)
                                )
                            )
                    )[0].computoNeto
            });
        }
    }
    const promises = [];
    for (const project of select) {
        promises.push(
            (async function () {
                console.log('yeah');
                const fichs = await db.select().from(fichajes).where(eq(fichajes.id_proyecto, project.id));
                const fichs2 = [];
                const cambios = await db
                    .select()
                    .from(fichajesCambiosProyecto)
                    .where(eq(fichajesCambiosProyecto.id_proyecto, project.id));
                for (const cc of cambios) {
                    if (cc.id_proyecto === project.id && !fichs.some((x) => x.id === cc.fichajeId)) {
                        fichs2.push(cc);
                    }
                }
                for (const item of fichs) {
                    await computeFichs(item, project.id);
                }
                for (const item of fichs2) {
                    const descansos = (
                        await db
                            .select()
                            .from(fichajesDescansos)
                            .where(eq(fichajesDescansos.fichajeId, item.fichajeId))
                    )
                        .filter((x) => {
                            return descansoThis(x, item.inicio, item.final);
                        })
                        .reduce(gad, 0);

                    const start = item.inicio as Date;
                    const end = item.final;
                    const len = end ? end.getTime() - start.getTime() : 'pending';

                    const fichajeId = (
                        await db.select().from(fichajes).where(eq(fichajes.id, item.fichajeId))
                    )[0];
                    const result = len === 'pending' ? 0 : len - descansos;
                    try {
                        await db.insert(computoFichadosProyectos).values({
                            id_proyecto: fichajeId.id_proyecto as number,
                            id_capitulo: fichajeId.id_capitulo as number,
                            idUsuario: fichajeId.idUsuario as string,
                            idFichaje: fichajeId.id as number,
                            inicio: fichajeId.inicio as Date,
                            final: end as Date,
                            createdAt: hoy as Date,
                            computoNeto: result
                        });
                    } catch (e) {
                        await db.update(computoFichadosProyectos).set({
                            computoNeto:
                                BigInt(result) +
                                (
                                    await db
                                        .select()
                                        .from(computoFichadosProyectos)
                                        .where(
                                            and(
                                                eq(computoFichadosProyectos.id_proyecto, fichajeId.id_proyecto as number),
                                                eq(computoFichadosProyectos.id_capitulo, fichajeId.id_capitulo as number),
                                                eq(computoFichadosProyectos.idUsuario, fichajeId.idUsuario as string),
                                                eq(computoFichadosProyectos.idFichaje, fichajeId.id as number)
                                            )
                                        )
                                )[0].computoNeto
                        });
                    }
                }
            })()
        );
    }
    await Promise.all(promises);
}