/*
    Предрейсовые осмотры - мобильное приложение
    Главный экран приложения с боковым меню
*/

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

const React = require('react'); //React и хуки
const { View } = require('react-native'); //Базовые компоненты
const { LOAD_STATUS_LOADING } = require('../config/loadStatus'); //Статусы загрузки
const { useAppMessagingContext } = require('../components/layout/AppMessagingProvider'); //Контекст сообщений
const { useAppModeContext } = require('../components/layout/AppModeProvider'); //Контекст режима работы
const { useAppNavigationContext } = require('../components/layout/AppNavigationProvider'); //Контекст навигации
const { useAppLocalDbContext } = require('../components/layout/AppLocalDbProvider'); //Контекст локальной БД
const { useAppPreTripInspectionsContext } = require('../components/layout/AppPreTripInspectionsProvider'); //Контекст осмотров
const { useAppAuthContext } = require('../components/layout/AppAuthProvider'); //Контекст авторизации
const AppHeader = require('../components/layout/AppHeader'); //Заголовок с меню
const SideMenu = require('../components/menu/SideMenu'); //Боковое меню
const InspectionList = require('../components/inspections/InspectionList'); //Список осмотров
const LoadingOverlay = require('../components/common/LoadingOverlay'); //Оверлей загрузки
const OrganizationSelectDialog = require('../components/auth/OrganizationSelectDialog'); //Диалог выбора организации
const { getAppInfo } = require('../utils/appInfo'); //Информация о приложении
const { CONNECTION_LOST_MESSAGE, OFFLINE_MODE_TITLE } = require('../config/messages'); //Сообщения
const { DIALOG_BUTTON_TYPE, DIALOG_CANCEL_BUTTON, getConfirmButtonOptions } = require('../config/dialogButtons'); //Кнопки диалогов
const { APP_COLORS } = require('../config/theme'); //Цветовая схема
const styles = require('../styles/screens/MainScreen.styles'); //Стили экрана

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

//Главный экран приложения
function MainScreen() {
    const { inspections, loadStatus, error, isDbReady, refreshInspections } = useAppPreTripInspectionsContext();
    const { showInfo, showError, showSuccess } = useAppMessagingContext();
    const { mode, setOnline, setOffline, setNotConnected } = useAppModeContext();
    const { navigate, SCREENS, setInitialScreen } = useAppNavigationContext();
    const { getSetting, isDbReady: isLocalDbReady } = useAppLocalDbContext();
    const {
        session,
        isAuthenticated,
        isInitialized,
        logout,
        checkSession,
        selectCompany,
        isLoading: isAuthLoading,
        sessionChecked,
        markSessionChecked,
        getAndClearSessionRestoredFromStorage
    } = useAppAuthContext();

    const [menuVisible, setMenuVisible] = React.useState(false);
    const [serverUrl, setServerUrl] = React.useState('');

    //Состояние для диалога выбора организации при проверке сессии
    const [showOrgDialog, setShowOrgDialog] = React.useState(false);
    const [organizations, setOrganizations] = React.useState([]);
    const [pendingSessionData, setPendingSessionData] = React.useState(null);

    //Предотвращение повторной загрузки при монтировании
    const initialLoadRef = React.useRef(false);

    //Загрузка URL сервера при готовности БД
    React.useEffect(() => {
        if (!isLocalDbReady) {
            return;
        }

        const loadServerUrl = async () => {
            try {
                const savedUrl = await getSetting('app_server_url');
                if (savedUrl) {
                    setServerUrl(savedUrl);
                }
            } catch (loadError) {
                console.error('Ошибка загрузки URL сервера:', loadError);
            }
        };

        loadServerUrl();
    }, [isLocalDbReady, getSetting]);

    //Проверка соединения только при открытии приложения и только если пользователь был авторизован и не выходил
    React.useEffect(() => {
        if (!isInitialized || sessionChecked) {
            return;
        }
        if (!getAndClearSessionRestoredFromStorage()) {
            return;
        }

        markSessionChecked();

        const verifySession = async () => {
            if (!isAuthenticated) {
                return;
            }

            const result = await checkSession();

            if (!result.success) {
                //Сессия недействительна
                showInfo('Сессия истекла. Выполните повторный вход.');
                return;
            }

            //Проверяем необходимость выбора организации
            if (result.needSelectCompany) {
                setOrganizations(result.organizations);
                setPendingSessionData({
                    serverUrl: result.serverUrl,
                    sessionId: result.sessionId,
                    user: result.user,
                    savePassword: result.savePassword
                });
                setShowOrgDialog(true);
                return;
            }

            //Устанавливаем режим работы на основе проверки сервера
            if (result.isOffline) {
                setOffline();
                showInfo(CONNECTION_LOST_MESSAGE, { title: OFFLINE_MODE_TITLE });
            } else {
                setOnline();
            }
        };

        verifySession();
    }, [
        isInitialized,
        isAuthenticated,
        sessionChecked,
        markSessionChecked,
        getAndClearSessionRestoredFromStorage,
        checkSession,
        setOnline,
        setOffline,
        showInfo
    ]);

    //Первичная загрузка данных
    React.useEffect(() => {
        //Выходим, если БД не готова или уже загружали
        if (!isDbReady || initialLoadRef.current) {
            return;
        }
        initialLoadRef.current = true;
        refreshInspections();
    }, [isDbReady, refreshInspections]);

    //Обработчик выбора организации при проверке сессии
    const handleSelectOrganization = React.useCallback(
        async org => {
            setShowOrgDialog(false);

            if (!pendingSessionData) {
                return;
            }

            const result = await selectCompany({
                serverUrl: pendingSessionData.serverUrl,
                sessionId: pendingSessionData.sessionId,
                user: pendingSessionData.user,
                company: org,
                savePassword: pendingSessionData.savePassword
            });

            if (!result.success) {
                showError(result.error || 'Ошибка выбора организации');
                return;
            }

            setOnline();
            setPendingSessionData(null);
            setOrganizations([]);
        },
        [pendingSessionData, selectCompany, showError, setOnline]
    );

    //Обработчик отмены выбора организации
    const handleCancelOrganization = React.useCallback(() => {
        setShowOrgDialog(false);
        setPendingSessionData(null);
        setOrganizations([]);
        //При отмене остаемся в оффлайн режиме
        setOffline();
    }, [setOffline]);

    //Обработчик открытия меню
    const handleMenuOpen = React.useCallback(() => {
        setMenuVisible(true);
    }, []);

    //Обработчик закрытия меню
    const handleMenuClose = React.useCallback(() => {
        setMenuVisible(false);
    }, []);

    //Обработчик показа информации о приложении
    const handleShowAbout = React.useCallback(() => {
        const appInfo = getAppInfo({
            mode,
            serverUrl,
            isDbReady: isLocalDbReady
        });

        showInfo(appInfo, {
            title: 'Информация о приложении'
        });
    }, [showInfo, mode, serverUrl, isLocalDbReady]);

    //Обработчик перехода на экран входа
    const handleLogin = React.useCallback(() => {
        navigate(SCREENS.AUTH, { fromMenu: true, fromMenuKey: Date.now() });
    }, [navigate, SCREENS.AUTH]);

    //Обработчик перехода в настройки
    const handleOpenSettings = React.useCallback(() => {
        navigate(SCREENS.SETTINGS);
    }, [navigate, SCREENS.SETTINGS]);

    //Обработчик подтверждения выхода (для диалога)
    const performLogout = React.useCallback(async () => {
        const result = await logout({ skipServerRequest: mode === 'OFFLINE' });

        if (result.success) {
            showSuccess('Выход выполнен');
            setNotConnected();
            setInitialScreen(SCREENS.AUTH);
        } else {
            showError(result.error || 'Ошибка выхода');
        }
    }, [logout, mode, showSuccess, showError, setNotConnected, setInitialScreen, SCREENS.AUTH]);

    //Обработчик выхода из приложения
    const handleLogout = React.useCallback(() => {
        const confirmButton = getConfirmButtonOptions(DIALOG_BUTTON_TYPE.ERROR, 'Выйти', performLogout);

        showInfo('Вы уверены, что хотите выйти?', {
            title: 'Подтверждение выхода',
            buttons: [DIALOG_CANCEL_BUTTON, confirmButton]
        });
    }, [showInfo, performLogout]);

    //Пункты бокового меню
    const menuItems = React.useMemo(() => {
        const items = [
            {
                id: 'settings',
                title: 'Настройки',
                onPress: handleOpenSettings
            },
            {
                id: 'about',
                title: 'О приложении',
                onPress: handleShowAbout
            }
        ];

        //Добавляем разделитель перед кнопками авторизации
        items.push({
            id: 'divider',
            type: 'divider'
        });

        //Кнопка "Вход" для оффлайн режима
        if (mode === 'OFFLINE') {
            items.push({
                id: 'login',
                title: 'Вход',
                onPress: handleLogin
            });
        }

        //Кнопка "Выход" для онлайн/оффлайн режима (когда есть сессия)
        if ((mode === 'ONLINE' || mode === 'OFFLINE') && isAuthenticated) {
            items.push({
                id: 'logout',
                title: 'Выход',
                onPress: handleLogout,
                textStyle: { color: APP_COLORS.error }
            });
        }

        return items;
    }, [handleOpenSettings, handleShowAbout, handleLogin, handleLogout, mode, isAuthenticated]);

    return (
        <View style={styles.container}>
            <AppHeader onMenuPress={handleMenuOpen} />

            <View style={styles.content}>
                <InspectionList
                    inspections={inspections}
                    isLoading={loadStatus === LOAD_STATUS_LOADING}
                    error={error}
                    onRefresh={refreshInspections}
                />
            </View>

            <SideMenu
                visible={menuVisible}
                onClose={handleMenuClose}
                items={menuItems}
                title="Меню"
                mode={mode}
                username={session?.userName}
                organization={session?.companyName}
            />

            <OrganizationSelectDialog
                visible={showOrgDialog}
                organizations={organizations}
                onSelect={handleSelectOrganization}
                onCancel={handleCancelOrganization}
                title="Выберите организацию"
            />

            <LoadingOverlay visible={isAuthLoading} message="Выполняется операция..." />
        </View>
    );
}

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

module.exports = MainScreen;
