import { questionApi } from "@api/question";
import { devlog } from "@frontend/kitui";
import { Question } from "@model/question/question";
import { produce } from "immer";
import { enqueueSnackbar } from "notistack";
import { isAxiosCanceledError } from "../../utils/isAxiosCanceledError";
import { QuestionsStore, useQuestionsStore } from "./store";


export const setQuestions = (quizes: Question[] | null) => setProducedState(state => {
    state.questionsById = {};
    if (quizes === null) return;

    quizes.forEach(question => state.questionsById[question.id] = question);
}, {
    type: "setQuizes",
    quizes,
});

export const setQuestion = (question: Question) => setProducedState(state => {
    state.questionsById[question.id] = question;
}, {
    type: "setQuestion",
    question,
});

export const setQuestionField = <T extends keyof Question>(
    questionId: number,
    field: T,
    value: Question[T],
) => setProducedState(state => {
    const question = state.questionsById[questionId];
    if (!question) return;

    question[field] = value;
}, {
    type: "setQuestionField",
    questionId,
    field,
    value,
});

let savedOriginalQuestion: Question | null = null;
let controller: AbortController | null = null;

export const setQuestionFieldOptimistic = async <T extends keyof Question>(
    questionId: number,
    field: T,
    value: Question[T],
) => {
    const question = useQuestionsStore.getState().questionsById[questionId] ?? null;
    if (!question) return;

    const currentUpdatedQuestion = produce(question, draft => {
        draft[field] = value;
    });
    controller?.abort();
    controller = new AbortController();
    savedOriginalQuestion ??= question;

    setQuestion(currentUpdatedQuestion);
    try {
        const { updated } = await questionApi.edit(currentUpdatedQuestion, controller.signal);

        setQuestionField(question.id, "version", updated);
        controller = null;
        savedOriginalQuestion = null;
    } catch (error) {
        if (isAxiosCanceledError(error)) return;

        devlog("Error editing question", { error, question, currentUpdatedQuestion });
        enqueueSnackbar("Не удалось сохранить вопрос");
        if (!savedOriginalQuestion) {
            devlog("Cannot rollback question");
            throw new Error("Cannot rollback question");
        }

        setQuestion(savedOriginalQuestion);
        controller = null;
        savedOriginalQuestion = null;
    }
};

export const updateQuestionWithFn = (
    questionId: number,
    updateFn: (question: Question) => void,
) => setProducedState(state => {
    const question = state.questionsById[questionId];
    if (!question) return;

    updateFn(question);
}, {
    type: "updateQuestion",
    questionId,
    updateFn: updateFn.toString(),
});

export const createQuestion = async (quizId: number) => {
    try {
        const question = await questionApi.create({
            quiz_id: quizId,
        });

        setQuestion(question);
    } catch (error) {
        devlog("Error creating question", error);
        enqueueSnackbar("Не удалось создать вопрос");
    }
};

export const deleteQuestion = async (questionId: number) => {
    try {
        await questionApi.delete(questionId);

        removeQuestion(questionId);
    } catch (error) {
        devlog("Error deleting question", error);
        enqueueSnackbar("Не удалось удалить вопрос");
    }
};

export const removeQuestion = (questionId: number) => setProducedState(state => {
    delete state.questionsById[questionId];
}, {
    type: "removeQuestion",
    questionId,
});

function setProducedState<A extends string | { type: unknown; }>(
    recipe: (state: QuestionsStore) => void,
    action?: A,
) {
    useQuestionsStore.setState(state => produce(state, recipe), false, action);
}