import { useCallback } from 'react';
import { useNavigate } from 'react-router-dom';
import {
    meAPI,
    loadBoardDataAPI, updateBoardsAPI, deleteBoardsAPI,
    createTaskAPI, updateTaskAPI, deleteTaskAPI,
    createCategoryAPI, updateCategoryAPI, deleteCategoryAPI,
    addMemberAPI, assignMemberAPI, unassignMemberAPI, deleteMemberAPI, quitMemberAPI
} from './BoardAPI';

export const useBoardLogic = (id, setError, setInfo, setCategories, setLoading, setItems) => {
    const navigate = useNavigate();

    const loadBoardData = useCallback(async () => {
        setLoading(true);
        try {
            setError('');
            const response = await loadBoardDataAPI(id);
            setInfo(response.data);
            setItems(response.data.members)
            setCategories(response.data.categories || []);
        } catch (err) {
            if (err.response?.data?.message === 'Token Error' ||
                err.response?.data?.message === 'Invalid Token') {
                setError('Вы не авторизованы');
                setTimeout(() => navigate('/login'), 1000);
            } else if (err.response?.data?.detail === "Доска не найдена.") {
                setError("Доска не существует");
                setTimeout(() => navigate('/kanban-boards-list'), 1000);
            } else {
                setError('Ошибка загрузки доски');
            }
        } finally {
            setLoading(false);
        }
    }, [id, setError, setInfo, setCategories, setLoading, setItems, navigate]);

    const checkOwner = useCallback(async (ownerId, setIsOwner) => {
        setLoading(true);
        const result = await meAPI(ownerId);
        const res = (result?.data?.id === ownerId);
        setLoading(false);
        setIsOwner(res);
    }, [setLoading]);



    const createCategory = useCallback(async (categoryTitle, modalCrCateg) => {
        setLoading(true);
        try {
            await createCategoryAPI(id, categoryTitle);
            await loadBoardData();
        } catch (err) {
            setError(err.response?.data?.message || 'Ошибка создания категории');
        } finally {
            modalCrCateg();
            setLoading(false);
        }
    }, [id, loadBoardData, setLoading, setError]);

    const createTask = useCallback(async (taskCategori, taskTitle, taskDescription, modalCrTask) => {
        setLoading(true);
        try {
            await createTaskAPI(taskCategori, taskTitle, taskDescription);
            await loadBoardData();
            modalCrTask(null)();
        } catch (err) {
            console.error('Ошибка создания задачи:', err);
            setError('Ошибка создания задачи');
        } finally {
            setLoading(false);
        }
    }, [loadBoardData, setLoading, setError]);



    const editBoard = useCallback(async (editedBoardId, boardTitle, boardDescription, modalEditBoard) => {
        setLoading(true);
        try {
            await updateBoardsAPI( editedBoardId, 'title', boardTitle );
            await updateBoardsAPI( editedBoardId, 'description', boardDescription );
            await modalEditBoard();
            await loadBoardData();
        } catch (err) {
            setError(err.response?.data?.message || 'Ошибка редактирования доски');
        } finally {
            modalEditBoard();
            setLoading(false);
        }
    }, [loadBoardData, setLoading, setError]);

    const editCategory = useCallback(async (editedCategId, categoryTitle, modalEditCateg) => {
        setLoading(true);
        try {
            await updateCategoryAPI( editedCategId, 'title', categoryTitle );
            await loadBoardData();
        } catch (err) {
            console.error('Ошибка редактирования категории:', err);
            setError(err.response?.data?.message || 'Ошибка редактирования категории');
        } finally {
            modalEditCateg({})();
            setLoading(false);
        }
    }, [loadBoardData, setLoading, setError]);

    const editTask = useCallback(async (editedTaskId, taskTitle, taskDescription, taskCategory, modalEditTask) => {
        setLoading(true);
        try {
            await updateTaskAPI( editedTaskId, 'title', taskTitle );
            await updateTaskAPI( editedTaskId, 'description', taskDescription );
            await updateTaskAPI( editedTaskId, 'category', Number(taskCategory) );
            await loadBoardData();
            modalEditTask({}, null)();
        } catch (err) {
            console.error('Ошибка редактирования задачи:', err);
            setError('Ошибка редактирования задачи');
        } finally {
            setLoading(false);
        }
    }, [loadBoardData, setLoading, setError]);



    const deleteBoards = useCallback(async (boardId, modalDelBoard) => {
        setLoading(true);
        try {
            await deleteBoardsAPI(boardId);
            modalDelBoard();
            navigate('/kanban-boards-list');
        } catch (err) {
            setError('Ошибка удаления доски: '+ (err.response?.data?.message || err.response?.data?.detail));
        } finally {
            setLoading(false);
        }
    }, [setLoading, setError, navigate]);

    const deleteCategory = useCallback(async (categoryId, modalDelCateg, modalEditCateg) => {
        setLoading(true);
        try {
            await deleteCategoryAPI(categoryId);
            await loadBoardData();
            modalDelCateg();
            modalEditCateg({})();
        } catch (err) {
            console.error('Ошибка удаления категории:', err);
            setError('Ошибка удаления категории');
        } finally {
            setLoading(false);
        }
    }, [loadBoardData, setLoading, setError]);

    const deleteTask = useCallback(async (taskId, modalDelTask, modalEditTask) => {
        setLoading(true);
        try {
            await deleteTaskAPI(taskId);
            await loadBoardData();
            modalDelTask();
            modalEditTask({}, null)();
        } catch (err) {
            setError('Ошибка удаления задачи');
        } finally {
            setLoading(false);
        }
    }, [loadBoardData, setLoading, setError]);



    const addMember = useCallback(async (username, boardId, modalAddMember) => {
        setLoading(true);
        try {
            await addMemberAPI( boardId, username );
            await loadBoardData();
            modalAddMember();
        } catch {
            setError('Ошибка');
        } finally {
            setLoading(false);
        }
    }, [loadBoardData, setLoading, setError]);

    const assignMember = useCallback(async (editedTaskId, memberId, act, modalAssignMember) => {
        setLoading(true);
        try {
            if (act) {
                await assignMemberAPI( editedTaskId, memberId );
            } else if (!act) {
                await unassignMemberAPI( editedTaskId, memberId );
            }
            await loadBoardData();
            modalAssignMember(false)();
        } catch {
            setError('Ошибка');
        } finally{
            setLoading(false);
        }
    }, [loadBoardData, setLoading, setError]);


    const quitMember = useCallback(async (boardId, modalQuitMember ) => {
        setLoading(true);
        try {
            setLoading(true);
            await quitMemberAPI( boardId );
            await loadBoardData();
            modalQuitMember();
            navigate('/kanban-boards-list');
        } catch {
            setError('Ошибка');
        } finally{
            setLoading(false);
        }
    }, [loadBoardData, setLoading, setError, navigate]);

    const deleteMember = useCallback(async (boardId, memberId, modalDelitMember ) => {
        setLoading(true);
        try {
            setLoading(true);
            await deleteMemberAPI( boardId, memberId );
            await loadBoardData();
            modalDelitMember();
        } catch {
            setError('Ошибка');
        } finally {
            setLoading(false);
        }
    }, [loadBoardData, setLoading, setError]);


    

    return {
        loadBoardData, checkOwner, editBoard, deleteBoards,
        createTask, editTask, deleteTask,
        createCategory, editCategory, deleteCategory,
        addMember, assignMember, quitMember, deleteMember
    };
};