cally/hooks/firebase/useUpdateTodo.ts

import { useMutation, useQueryClient } from "react-query";
import firestore from "@react-native-firebase/firestore";
import {IToDo} from "@/hooks/firebase/types/todoData";
import {addDays, addWeeks, compareAsc, format, subDays} from "date-fns";
import {daysOfWeek} from "@/hooks/firebase/useCreateTodo";

export const useUpdateTodo = () => {
    const queryClients = useQueryClient()

    return useMutation({
        mutationKey: ["updateTodo"],
        mutationFn: async (todoData: Partial<IToDo>) => {
            try {
                if (todoData.connectedTodoId) {
                    console.log("CONNECTED TODO");
                    const snapshot = await firestore()
                        .collection("Todos")
                        .where("connectedTodoId", "==", todoData.connectedTodoId)
                        .get();


                    const connectedTodos = snapshot.docs.map((doc) => {
                        const data = doc.data();

                        return {
                            ...data,
                            id: doc.id,
                            date: data.date ? new Date(data.date.seconds * 1000) : null,
                            ref: doc.ref
                        };
                    }) as IToDo[];

                    let filteredTodos = connectedTodos?.filter((item) => item.date >= todoData.date).sort((a,b) =>{
                        return b.date?.getSeconds() - a.date?.getSeconds();
                    });
                    console.log(filteredTodos);

                    let firstTodo = filteredTodos?.[0];
                    // resolve the repeating
                    const batch = firestore().batch();
                        const todosToAddCycles = filteredTodos?.length / firstTodo?.repeatDays?.length;
                        console.log(todosToAddCycles);
                        if (firstTodo?.repeatDays !== todoData.repeatDays) {
                            let newRepeatDays = todoData.repeatDays?.filter((element) => firstTodo?.repeatDays?.indexOf(element) === -1);
                            const dates = [];

                            let date = firstTodo?.date;
                            const originalDateDay = format(date, 'EEEE');
                            const originalNumber = daysOfWeek.indexOf(originalDateDay);
                            newRepeatDays?.forEach((day) => {
                                let number = daysOfWeek.indexOf(day);
                                let newDate;
                                if (originalNumber > number) {
                                    let diff = originalNumber - number;
                                    newDate = subDays(date, diff);
                                } else {
                                    let diff = number - originalNumber;
                                    newDate = addDays(date, diff);
                                }
                                dates.push(newDate);
                            });

                            console.log("REPEAT")
                            console.log(newRepeatDays);
                            console.log(dates);

                            filteredTodos?.forEach((item) => {

                                batch.update(item.ref, {...todoData, date: item.date});
                            })
                            // TODO: for the next connected -> filtered todos - number of weeks
                            for (let i = 0; i < todosToAddCycles; i++) {
                                dates?.forEach((dateToAdd) => {
                                    let newTodoDate = addWeeks(dateToAdd, i);
                                    if (compareAsc(newTodoDate, firstTodo?.date) !== 0) {
                                        const newTodo = { ...todoData, date: newTodoDate };

                                        let docRef = firestore().collection("Todos").doc();
                                        batch.set(docRef, newTodo);
                                        console.log("ADD")
                                        console.log(newTodo);
                                    }
                                })
                            }
                        } else {
                            filteredTodos?.forEach((item) => {

                                console.log("UPDATE");
                                batch.update(item.ref, {...todoData, date: item.date});
                            })
                        }

                    await batch.commit();
                } else {
                    console.log("Update");
                    console.log(todoData);
                    await firestore()
                        .collection("Todos")
                        .doc(todoData.id)
                        .update(todoData);
                }
            } catch (e) {
                console.error(e)
            }
        },
        onSuccess: () => {
            queryClients.invalidateQueries("todos")
        }
    })
}