/*
    Предрейсовые осмотры - мобильное приложение
    Хук для работы с локальной базой данных SQLite
*/

//---------------------
//Подключение библиотек
//---------------------

const React = require('react');
const SQLiteDatabase = require('../database/SQLiteDatabase');

//-----------
//Тело модуля
//-----------

function useLocalDb() {
    //Состояние хука
    const [isDbReady, setIsDbReady] = React.useState(false);
    const [inspections, setInspections] = React.useState([]);
    const [dbError, setDbError] = React.useState(null);

    //Отслеживания статуса инициализации
    const initializingRef = React.useRef(false);

    //Инициализация базы данных при монтировании
    React.useEffect(() => {
        let mounted = true;

        //Функция инициализации БД
        const initDb = async () => {
            //Предотвращаем повторную инициализацию
            if (initializingRef.current || SQLiteDatabase.isInitialized) {
                if (mounted && SQLiteDatabase.isInitialized) {
                    setIsDbReady(true);
                    try {
                        const loadedInspections = await SQLiteDatabase.getInspections();
                        setInspections(loadedInspections);
                    } catch (loadError) {
                        console.error('Ошибка загрузки осмотров при переинициализации:', loadError);
                    }
                }
                return;
            }

            initializingRef.current = true;

            try {
                await SQLiteDatabase.initialize();
                if (mounted) {
                    setIsDbReady(true);
                    const loadedInspections = await SQLiteDatabase.getInspections();
                    setInspections(loadedInspections);
                    setDbError(null);
                }
            } catch (initError) {
                console.error('Ошибка инициализации базы данных:', initError);
                if (mounted) {
                    setIsDbReady(false);
                    setDbError('Не удалось инициализировать базу данных');
                }
            } finally {
                initializingRef.current = false;
            }
        };

        initDb();

        return () => {
            mounted = false;
        };
    }, []);

    //Загрузка списка осмотров
    const loadInspections = React.useCallback(async () => {
        if (!isDbReady) {
            console.warn('База данных не готова');
            return [];
        }

        try {
            const loadedInspections = await SQLiteDatabase.getInspections();
            setInspections(loadedInspections);
            setDbError(null);
            return loadedInspections;
        } catch (loadError) {
            console.error('Ошибка загрузки осмотров:', loadError);
            setDbError('Не удалось загрузить осмотры');
            return [];
        }
    }, [isDbReady]);

    //Сохранение осмотра
    const saveInspection = React.useCallback(
        async inspection => {
            if (!isDbReady) {
                console.warn('База данных не готова');
                return inspection;
            }

            try {
                await SQLiteDatabase.saveInspection(inspection);
                const updatedInspections = await SQLiteDatabase.getInspections();
                setInspections(updatedInspections);
                setDbError(null);
                return inspection;
            } catch (saveError) {
                console.error('Ошибка сохранения осмотра:', saveError);
                setDbError('Не удалось сохранить осмотр');
                return inspection;
            }
        },
        [isDbReady]
    );

    //Получение настройки
    const getSetting = React.useCallback(
        async key => {
            if (!isDbReady) {
                return null;
            }

            try {
                return await SQLiteDatabase.getSetting(key);
            } catch (getSettingError) {
                console.error('Ошибка получения настройки:', getSettingError);
                return null;
            }
        },
        [isDbReady]
    );

    //Сохранение настройки
    const setSetting = React.useCallback(
        async (key, value) => {
            if (!isDbReady) {
                console.warn('База данных не готова');
                return false;
            }

            try {
                return await SQLiteDatabase.setSetting(key, value);
            } catch (setSettingError) {
                console.error('Ошибка сохранения настройки:', setSettingError);
                return false;
            }
        },
        [isDbReady]
    );

    //Удаление настройки
    const deleteSetting = React.useCallback(
        async key => {
            if (!isDbReady) {
                console.warn('База данных не готова');
                return false;
            }

            try {
                return await SQLiteDatabase.deleteSetting(key);
            } catch (deleteSettingError) {
                console.error('Ошибка удаления настройки:', deleteSettingError);
                return false;
            }
        },
        [isDbReady]
    );

    //Получение всех настроек
    const getAllSettings = React.useCallback(async () => {
        if (!isDbReady) {
            console.warn('База данных не готова');
            return {};
        }

        try {
            return await SQLiteDatabase.getAllSettings();
        } catch (getAllSettingsError) {
            console.error('Ошибка получения всех настроек:', getAllSettingsError);
            return {};
        }
    }, [isDbReady]);

    //Очистка всех настроек
    const clearSettings = React.useCallback(async () => {
        if (!isDbReady) {
            console.warn('База данных не готова');
            return false;
        }

        try {
            return await SQLiteDatabase.clearSettings();
        } catch (clearSettingsError) {
            console.error('Ошибка очистки настроек:', clearSettingsError);
            return false;
        }
    }, [isDbReady]);

    //Очистка всех осмотров
    const clearInspections = React.useCallback(async () => {
        if (!isDbReady) {
            console.warn('База данных не готова');
            return false;
        }

        try {
            const result = await SQLiteDatabase.clearInspections();
            if (result) {
                setInspections([]);
                setDbError(null);
            }
            return result;
        } catch (clearInspectionsError) {
            console.error('Ошибка очистки осмотров:', clearInspectionsError);
            setDbError('Не удалось очистить осмотры');
            return false;
        }
    }, [isDbReady]);

    //Оптимизация базы данных
    const vacuum = React.useCallback(async () => {
        if (!isDbReady) {
            console.warn('База данных не готова');
            return false;
        }

        try {
            return await SQLiteDatabase.vacuum();
        } catch (vacuumError) {
            console.error('Ошибка оптимизации базы данных:', vacuumError);
            return false;
        }
    }, [isDbReady]);

    //Проверка существования таблицы
    const checkTableExists = React.useCallback(
        async tableName => {
            if (!isDbReady) {
                console.warn('База данных не готова');
                return false;
            }

            try {
                return await SQLiteDatabase.checkTableExists(tableName);
            } catch (checkTableError) {
                console.error('Ошибка проверки существования таблицы:', checkTableError);
                return false;
            }
        },
        [isDbReady]
    );

    //Сохранение сессии авторизации
    const setAuthSession = React.useCallback(
        async session => {
            if (!isDbReady) {
                console.warn('База данных не готова');
                return false;
            }

            try {
                return await SQLiteDatabase.setAuthSession(session);
            } catch (setAuthSessionError) {
                console.error('Ошибка сохранения сессии авторизации:', setAuthSessionError);
                return false;
            }
        },
        [isDbReady]
    );

    //Получение сессии авторизации
    const getAuthSession = React.useCallback(async () => {
        if (!isDbReady) {
            console.warn('База данных не готова');
            return null;
        }

        try {
            return await SQLiteDatabase.getAuthSession();
        } catch (getAuthSessionError) {
            console.error('Ошибка получения сессии авторизации:', getAuthSessionError);
            return null;
        }
    }, [isDbReady]);

    //Очистка сессии авторизации
    const clearAuthSession = React.useCallback(async () => {
        if (!isDbReady) {
            console.warn('База данных не готова');
            return false;
        }

        try {
            return await SQLiteDatabase.clearAuthSession();
        } catch (clearAuthSessionError) {
            console.error('Ошибка очистки сессии авторизации:', clearAuthSessionError);
            return false;
        }
    }, [isDbReady]);

    return {
        isDbReady,
        inspections,
        error: dbError,
        loadInspections,
        saveInspection,
        getSetting,
        setSetting,
        deleteSetting,
        getAllSettings,
        clearSettings,
        clearInspections,
        vacuum,
        checkTableExists,
        setAuthSession,
        getAuthSession,
        clearAuthSession
    };
}

//----------------
//Интерфейс модуля
//----------------

module.exports = useLocalDb;
