//
// Created by xemon on 19.09.22.
//
//+79419776358
// +79418100029
#include "MainModesArbiter_Private.h"
#include "BootJump.h"
#include "DeviceTesting_TestsWithUser.h"
#include "AtGsmOpenAudioLoop.h"
#include "egts.h"
#include "AsciiStringAssmeblingUtils.h"
#include "AtGsmSms_DeleteAll.h"
#include "EgtsProcessing.h"
#include "AtGsmTelitLe910_DefinePdpContext.h"
//#include "testCan.h"

#define LOG_SIGN "Главн."
#define LOGGER &env->slog.logger

#ifdef UVEOS_ADD_TELEMATICA

void TELEMATICA_START(tMma *env) {

    if (env->storage.nvm.deviceTeledataStorageData.telematica.telematicaIsActive) {
        env->storage.runtime.EGTS_FLEET_ON = true;
    }
}

void TELEMATICA_STOP(tMma *env) {

    if (env->storage.runtime.EGTS_FLEET_ON) {

        env->storage.runtime.EGTS_FLEET_ON = false;

        for (uint8_t i = 0; i < 30; ++i) {
            if (env->storage.runtime.telematicaCloseConnect)
                break;

            SystemDelayMs(100);
        }

        Gsm_SetProfileERA(&env->egtsProcessing);
    }

}

#endif


size_t str_len = 0;
char step[5];

void Mma_Init(
        tMma *env,
        tGpios *gpios,
        tSerialPorts *serialPorts,
        tI2cPorts *i2cPorts,
        tSpiPorts *spiPorts,
        tAdcs *adcs,
        tStorageOnFlash *flash,
        tRtc *rtc
) {
    env->gpios = gpios;
    env->serialPorts = serialPorts;
    env->i2cPorts = i2cPorts;
    env->spiPorts = spiPorts;
    env->adcs = adcs;
    env->flash = flash;
    env->rtc = rtc;
    InitThreadAtrStatic(&env->thread.attr, "Mma", env->thread.controlBlock, env->thread.stack, osPriorityNormal);
    env->thread.id = 0;
    env->lastSmsCheckTime = 0;
    env->flIgn = false;
    env->kzModeBloc = false;
}


void Mma_Shutdown(tMma *env) {
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Завершение работы")
    VarsTabDumpObserver_Flush(&env->storage.dumpObserver);

    LoggerInfoStatic(LOGGER, LOG_SIGN, "Отключение питания через 4с")
    SystemDelayMs(4000);
    Pwm_Blackout(&env->power);

    LoggerInfoStatic(LOGGER, LOG_SIGN, "Питание осталось, обратите внимание!!")
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Возможно произошло повторное включение пользователем")
    SystemDelayMs(5000);
    BootJumpToAddress(0x8000000);
    LoggerErrorStatic(LOGGER, LOG_SIGN, "Этой строчки не должно быть! Критическая ошибка!")
}

void Mma_EcallPrepare(tMma *env) {
    AtGsm_OperatorSelectionDeregister(&env->gsmWithGnss.gsmAt);
    SystemDelayMs(1000);
    GsmWithGnss_SelectStandartNetwork(&env->gsmWithGnss.gsmAt, 12);
    SystemDelayMs(3000);
    GsmWithGnss_SelectStandartNetwork(&env->gsmWithGnss.gsmAt, 22);
    SystemDelayMs(3000);
    GsmWithGnss_SelectStandartNetwork(&env->gsmWithGnss.gsmAt, 25);
    SystemDelayMs(3000);
    AtGsm_OperatorSelectionDeregister(&env->gsmWithGnss.gsmAt);
    AtGsmTelitLe910_GnssEcallOnlyMode(&env->gsmWithGnss.gsmAt, 0);
}


void Mma_CheckShutdownIsBattary(tMma *env) {
    bool statShutdown = Pwm_IsShutdownRequired(&env->power);
    if ((env->indication.mode != DEVICE_MODE_TESTING) && (env->indication.mode != DEVICE_MODE_UVEOS_GARAG)) {
        if (statShutdown) {
            uint16_t single;
            float volt;
            single = AdcGet(&env->adcs->batteryIo, 10);
            volt = (float) single / 1000;
            if (volt < 2.8) {
                Mma_Shutdown(env);
            }
        }
    }
}

void Mma_CheckShutdown(tMma *env, bool fastBlackOut) {
    bool statShutdown = Pwm_IsShutdownRequired(&env->power);
    bool statStandUp = EraGlonassUveos_IsStandby(&env->uveos);

    if (statShutdown && (!statStandUp)) {
        Mma_Shutdown(env);
    } else {

#ifdef UVEOS_ADD_TELEMATICA
        if ((!statStandUp)) {
            if (env->storage.runtime.EGTS_FLEET_ON == false)
                TELEMATICA_START(env);
        }
#endif

    }

    Mma_CheckShutdownIsBattary(env);
}

static void Mma_SetNetworkRegistration(tMma *env, bool value) {
#ifdef USE_GSM_AND_GNSS_TELIT
    GsmWithGnss_SetNetworkRegistration(&env->gsmWithGnss, value);
#endif
#ifdef USE_GSM_AND_GNSS_SIMCOM
    Gsm_SetNetworkRegistration(&env->gsm, value);
#endif
}

static bool Mma_WaitNetworkRegistration(tMma *env) {
#ifdef USE_GSM_AND_GNSS_TELIT
    return GsmWithGnss_WaitNetworkRegistration(&env->gsmWithGnss, 35000);
#endif
#ifdef USE_GSM_AND_GNSS_SIMCOM
    return Gsm_WaitNetworkRegistration(&env->gsm);
#endif
}

void Mma_AudioSignal(tMma *env, uint8_t count, uint16_t timeout) {
#ifdef USE_GSM_AND_GNSS_TELIT
    for (uint8_t i = 0; i < count; i++) {
        if (AtGsmSetOpenAudioLoop(&env->gsmWithGnss.gsmAt, 1)) {
            SystemDelayMs(timeout);
            AtGsmSetOpenAudioLoop(&env->gsmWithGnss.gsmAt, 0);
        }
        SystemDelayMs(timeout);
    }
#endif
#ifdef USE_GSM_AND_GNSS_SIMCOM
    for (uint8_t i = 0; i < count; i++) {
        if (AtGsmSetOpenAudioLoop(&env->gsm.gsmAt, 1)) {
            SystemDelayMs(timeout);
            AtGsmSetOpenAudioLoop(&env->gsm.gsmAt, 0);
        }
        SystemDelayMs(timeout);
    }
#endif

}

void Mma_GarageMode(tMma *env) {
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Переход в режим Гараж")
    GpioPinEnable(&env->power.pins->main.garage);

    env->storage.nvm.device.garageMode = true;
    DeviceStorage_ForceDump(&env->storage);

    EraGlonassUveos_GarageStarted(&env->uveos);
    tUserInputButtonEvent buttonEvent;
    while (1) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Режим Гараж")

        if (env->storage.runtime.enableGnssUpdate) {
//            GsmWithGnss_GetNevData(&env->gsmWithGnss, 600);
            AtGsm_Gsnss_GetNMEA_Pack(&env->gsmWithGnss, 400);
            EraGlonassUveos_DoNothingModeDistance(&env->uveos, false);
        }

        if (env->uveos.doNothing.mode == UVEOS_DO_NOTHING_DISABLED) {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Автоматический выход из режима Гараж")
            GpioPinDisable(&env->power.pins->main.garage);
            env->storage.nvm.device.garageMode = false;
            DeviceStorage_ForceDump(&env->storage);
            EraGlonassUveos_DoNotingReset(&env->uveos);
            return;
        }

        if (UserButtons_GetNext(&env->userInput.buttonsInterface, &buttonEvent, 10)) {
            if (UserInputButtonEventIsBetween(buttonEvent, UI_BUTTON_ADDITIONAL, RAISE, 10000, 0xFFFF)) {
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Пользовательский выход из режима Гараж")
                GpioPinDisable(&env->power.pins->main.garage);
                env->storage.nvm.device.garageMode = false;
                DeviceStorage_ForceDump(&env->storage);
                EraGlonassUveos_DoNotingReset(&env->uveos);
                return;
            }
        }
        if (DeviceTesting_Always(&env->testing)) {
            Mma_SetMode(env, DEVICE_MODE_FAILURE);
        } else {
            Mma_SetMode(env, DEVICE_MODE_UVEOS_GARAG);
        }

        Mma_CheckShutdown(env, true);
        SystemDelayMs(1000);
    }
}

void Mma_NetworkAndAudioRequireKz(tMma *env) {
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Включаем звук");
    Pwm_AudioEnable(&env->power);
    //todo пока что включен всегда

    LoggerInfoStatic(LOGGER, LOG_SIGN, "Поднимаем сигнал MUTE");
    Pwm_SetMute(&env->power, true);
}

void Mma_NetworkAndAudioRequire(tMma *env) {
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Включаем звук");
    Pwm_AudioEnable(&env->power);
    //todo пока что включен всегда

    LoggerInfoStatic(LOGGER, LOG_SIGN, "Поднимаем сигнал MUTE");
    Pwm_SetMute(&env->power, true);
    Gsm_SetProfileERA_mode(env);
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Включаем регистрацию в сети");
//    Mma_EcallPrepare(env);
    GsmWithGnss_NetworkEnableInnaterups(&env->gsmWithGnss, 5, 120000);
}

static void Mma_NetworkAndAudioRelease(tMma *env) {
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Выключаем сигнал MUTE");
    Pwm_SetMute(&env->power, false);
    uint32_t t = SystemGetMs() + 200;
    while (t > SystemGetMs()) {}
}


void Mma_EcallManual(tMma *env) {
    EraGlonassUveos_SetTimings(&env->uveos);

    Mma_SetMode(env, DEVICE_MODE_UVEOS_CALL_INITIATE);
    Mma_NetworkAndAudioRequire(env);
    GpioPinEnable(&env->power.pins->main.ecall);
    env->uveos.currentMsd->msd.MSD_Data.msgId = 1;
    EraGlonassUveos_ManualEmergencyCall(&env->uveos, false);
    GpioPinDisable(&env->power.pins->main.ecall);

    AtGsmTelitLe910_Gnss_ReStartReceiver(&env->gsmWithGnss.gsmAt, 0);
    SystemDelayMs(500);
    AtGsmTelitLe910_Gnss_ReStartReceiver(&env->gsmWithGnss.gsmAt, 1);

    Mma_NetworkAndAudioRelease(env);
}

void Mma_EcallManualKZ(tMma *env) {
    EraGlonassUveos_SetTimings(&env->uveos);
    Mma_SetMode(env, DEVICE_MODE_UVEOS_CALL_INITIATE);
    Mma_NetworkAndAudioRequireKz(env);
    Mma_EcallPrepare(env);
    GsmWithGnss_NetworkEnableInnaterups(&env->gsmWithGnss, 5, 250000);
    GpioPinEnable(&env->power.pins->main.ecall);
    env->uveos.currentMsd->msd.MSD_Data.msgId = 1;
    EraGlonassUveos_ManualEmergencyCall(&env->uveos, true);

    GpioPinDisable(&env->power.pins->main.ecall);

    AtGsmTelitLe910_Gnss_ReStartReceiver(&env->gsmWithGnss.gsmAt, 0);
    SystemDelayMs(500);
    AtGsmTelitLe910_Gnss_ReStartReceiver(&env->gsmWithGnss.gsmAt, 1);

    Mma_NetworkAndAudioRelease(env);
}

void Mma_gnssUpdate(tMma *env, eDeviceModes *deviceModes) {
    LoggerTraceStatic(LOGGER, LOG_SIGN, "Обновление ГНСС")

    if (env->storage.runtime.enableGnssUpdate == true) {
        EraGlonassUveosNavData location;

        if ((*deviceModes != DEVICE_MODE_TESTING) && (*deviceModes != DEVICE_MODE_UVEOS_GARAG)) {
            GsmWithGnss_GetNevData(&env->gsmWithGnss, 600);
            AtGsm_Gsnss_GetLastActualNavData(&env->gsmWithGnss, &location, 1);

            if (env->gsmWithGnss.gnss.currentRmc.status == 'A') {
                EraGlonassUveos_DoNothingModeDistance(&env->uveos, true);
                Mma_SetMode(env, DEVICE_MODE_UVEOS_ERA_GNSS_READY);
            } else {
                Mma_SetMode(env, DEVICE_MODE_UVEOS_ERA_WAIT_GNSS);
                env->uveos.doNothing.mode = UVEOS_DO_NOTHING_DISABLED;
            }

            *deviceModes = GsmWithGnss_IsGnssReady(&env->gsmWithGnss) ?
                           DEVICE_MODE_UVEOS_ERA_GNSS_READY :
                           DEVICE_MODE_UVEOS_ERA_WAIT_GNSS;
        } else {
            AtGsm_Gsnss_GetLastActualNavData(&env->gsmWithGnss, &location, 0);
        }

    } else {
        *deviceModes = DEVICE_MODE_UVEOS_ERA_WAIT_GNSS;
    }
}

void Mma_EcallAutomatic(tMma *env, tUveosEmergencyEvent emergencyEvent) {

    EraGlonassUveos_SetTimings(&env->uveos);

    Pwm_AudioEnable(&env->power);
    Mma_SetMode(env, DEVICE_MODE_UVEOS_CALL_INITIATE);
    Mma_NetworkAndAudioRequire(env);
    Mma_EcallPrepare(env);

    GsmWithGnss_NetworkEnableInnaterups(&env->gsmWithGnss, 5, 250000);
    Mma_NetworkAndAudioRequire(env);

    GpioPinEnable(&env->power.pins->main.ecall);
    Mma_AudioSignal(env, 1, 500);
    GsmWithGnss_GetNevData(&env->gsmWithGnss, 600);

    eEraGlonassUveos_EcallProcessingResult res = EraGlonassUveos_ProcessingEmergencyEvent(&env->uveos, &emergencyEvent);

    AtGsmTelitLe910_Gnss_ReStartReceiver(&env->gsmWithGnss.gsmAt, 0);
    SystemDelayMs(1000);
    AtGsmTelitLe910_Gnss_ReStartReceiver(&env->gsmWithGnss.gsmAt, 1);

    GpioPinDisable(&env->power.pins->main.ecall);
    Mma_NetworkAndAudioRelease(env);
}

static void Mma_UserTestMode(tMma *env) {
    Mma_NetworkAndAudioRequire(env);
    Mma_SetNetworkRegistration(env, true);
    AtGsm_Gsnss_GetNMEA_Pack(&env->gsmWithGnss, 500);
    EraGlonassUveos_TestingStarted(&env->uveos);

    if (DeviceTesting_RunUserTests(&env->testing) == true) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Пользовательское тестирование завершено");
        DeviceTesting_ExitTestPlay(&env->testing);
    }
    env->gsmWithGnss.isBusy = false;
    Mma_NetworkAndAudioRelease(env);
}

static void Mma_ProcessCallAnswer(tMma *env) {

    LoggerInfoStatic(LOGGER, LOG_SIGN, "Включаем звук");
    Pwm_AudioEnable(&env->power);
    GpioPinEnable(&env->power.pins->main.ecall);

    LoggerInfoStatic(LOGGER, LOG_SIGN, "Поднимаем сигнал MUTE");
    Pwm_SetMute(&env->power, true);

    LoggerInfoStatic(LOGGER, LOG_SIGN, "Получен вызов от оператора");
    AudioPlayer_PlayStatic(&env->gsmWithGnss.audioPlayer, "audio_on", 8 * 1000);
    SystemDelayMs(500);
    AtGsmAnswer(&env->gsmWithGnss.gsmAt);
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Вызов от оператора принят");
    Mma_SetMode(env, DEVICE_MODE_UVEOS_CALL_ACTIVE);
    bool wasNewSetMsd = false;
    bool wasResent = false;
    bool mndSendFlag = true;

//    tMsdEncoded msdEncoded;
//    env->uveos.currentMsd->msd.MSD_Data.msgId = 1;
//    setMsdToPull(&env->uveos, &mndSendFlag, &wasNewSetMsd, &wasResent, &msdEncoded);
    while (GsmWithGnss_isInpCallActive(&env->gsmWithGnss)) {
        SystemDelayMs(500);
    }

    LoggerInfoStatic(LOGGER, LOG_SIGN, "Вызов от оператора завершён");
    while (AtGsmHangUpCall(&env->gsmWithGnss.gsmAt) == AT_OK) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "поднят HangUp");
        GsmWithGnss_ResetRing(&env->gsmWithGnss);
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Выполнен сброс Ринга");
        Pwm_AudioDisable(&env->power);
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Питание УНЧ отключено");
        Mma_NetworkAndAudioRelease(env);
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Сигнал MUTE бортовой сети отключен");
        Pwm_SetMute(&env->power, false);
        GpioPinDisable(&env->power.pins->main.ecall);
        SystemDelayMs(500);
        break;
    }
}


void Mma_TestingThread(tMma *env) {
    eDeviceModes indicationState;
    while (1) {
//        Mma_gnssUpdate(env, &indicationState);

        if (DeviceTesting_Always(&env->testing)) {
            indicationState = DEVICE_MODE_FAILURE;
        };

        if (DeviceTesting_Periodical(&env->testing)) {
            indicationState = DEVICE_MODE_FAILURE;
        };

        Mma_SetMode(env, indicationState);
        SystemDelayMs(10);
    }
}

static void checkLastInMemTransmit(tMma *env) {

    if (env->uveos.timings.lastInMemTransmit < SystemGetMs()) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Периодическая проверка необходимости повторной отправки МНД");

        volatile uint32_t noSendMsdCount = EraGlonassMsdTable_GetNoSendDataCount(env->uveos.msdTable);
        if (noSendMsdCount > 0) {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Проверка регистрации в сети");
            if (GsmWithGnss_WaitNetworkRegistration(&env->gsmWithGnss, 2000)) {
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть присутствует");
                EraGlonassUveos_ProcessingCheckNoSendMSD(&env->uveos);
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Удаление всех СМС...");
                AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt);
                SystemDelayMs(500);
                AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt);
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Удаление СМС выполнено");
            } else {
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть или сим-чип отсутствует, попытка регистрации...");
                if (GsmWithGnss_NetworkEnableInnaterups(&env->gsmWithGnss, 5, 40000) == AT_OK) {
                    LoggerTraceStatic(LOGGER, LOG_SIGN, "Сеть присутствует")
                    EraGlonassUveos_ProcessingCheckNoSendMSD(&env->uveos);
                    LoggerInfoStatic(LOGGER, LOG_SIGN, "Удаление всех СМС...");
                    AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt);
                    SystemDelayMs(500);
                    AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt);
                    LoggerInfoStatic(LOGGER, LOG_SIGN, "Удаление СМС выполнено");
                } else {
                    LoggerInfoStatic(LOGGER, LOG_SIGN,
                                     "Периодическая проверка необходимости повторной отправки МНД не выполнена");
                    LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть или сим-чип отсутствует");
                }
            }
            LoggerTraceStatic(LOGGER, LOG_SIGN, "Обработка не отправленных МНД выполнена")
        }

        env->uveos.timings.lastInMemTransmit =
                SystemGetMs() + (env->uveos.settings->INT_MEM_TRANSMIT_INTERVAL * 60 * 1000);
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Время периодическая проверки повторной отправки МНД обновлено");
    }
}

bool Gsm_SetProfileERA_mode(tMma *env) {
    AtCommandResult res = AT_ERROR;
    if (osMutexAcquire(env->gsmWithGnss.gsmAt.access, 5000) == osOK) {

#ifdef UVEOS_ADD_TELEMATICA
        AtGsmTelitLe910_SimProfileSelect(&env->gsmWithGnss.gsmAt,
                                         &env->storage.nvm.deviceTeledataStorageData.telematica.EGTS_PROFILE_SIM_ERA);
#endif

        AtGsmTelitLe910_SIMCardNoDetect(&env->gsmWithGnss.gsmAt);
        AtGsmTelitLe910_SIMCardDetect(&env->gsmWithGnss.gsmAt);
        SystemDelayMs(1000);

        osMutexRelease(env->gsmWithGnss.gsmAt.access);
    }

    return res == AT_OK;
}

static _Noreturn void Mma_Thread(tMma *env) {
    RCC_EnableAPB1PeriphClk(RCC_APB1_PERIPH_PWR, ENABLE);
    PWR_BackupAccessEnable(ENABLE);
    RCC_EnableBackupReset(DISABLE);

    //Запуск устройства
    Mma_InitStage(env);

#ifdef UVEOS_ADD_TELEMATICA
    EgtsProcessing_Init(
            &env->egtsProcessing,
            &env->storage,
            &env->power.pins->main.ignition,
            &env->gsmWithGnss,
            &env->rtc->rtcIo,
            &env->slog
    );

    EgtsProcessing_Start(&env->egtsProcessing);
#endif

    volatile size_t size = xPortGetMinimumEverFreeHeapSize();
    uint32_t sizeStorage = sizeof(tDeviceDataNonVolatile);
    LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Свободно %u байт в куче. Размер хранилища %u", size, sizeStorage);

    eDeviceModes indicationState;
    tUserInputButtonEvent buttonEvent;
    tUveosEmergencyEvent emergencyEvent;

    if (env->storage.nvm.device.garageMode) {
        Mma_GarageMode(env);
    }

    while (!EraGlonassUveos_IsEraAllowed(&env->uveos)) {
        Mma_SetMode(env, DEVICE_MODE_UVEOS_PASSIVE);
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Пассивный режим, сконфигурируйте устройство!")

        if (DeviceTesting_Always(&env->testing)) {
            Mma_SetMode(env, DEVICE_MODE_FAILURE);
        } else {
            Mma_SetMode(env, DEVICE_MODE_UVEOS_PASSIVE);
        }

        LoggerTraceStatic(LOGGER, LOG_SIGN, "Проверяем нажатия кнопок")
        if (UserButtons_GetNext(&env->userInput.buttonsInterface, &buttonEvent, 10)) {
            if (UserInputButtonEventIsBetween(buttonEvent, UI_BUTTON_ADDITIONAL, RAISE, 3000, 10000)) {
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Переход в режим пользовательского тестирования")
                Mma_SetMode(env, DEVICE_MODE_TESTING);
                Mma_UserTestMode(env);
            }
        }

        if (!GpioPinGet(&env->power.pins->main.ignition) && (env->indication.mode == DEVICE_MODE_UVEOS_PASSIVE)) {
            env->power.shutdownDelay = 2000;
            Mma_Shutdown(env);
        }

        Mma_CheckShutdown(env, true);
        SystemDelayMs(1000);
    }

    LoggerInfoStatic(LOGGER, LOG_SIGN, "Запуск главного цикла")

    LoggerTraceStatic(LOGGER, LOG_SIGN, "Обработка режима ЭРА внутри УВЭОС")

    volatile uint32_t noSendMsdCount = EraGlonassMsdTable_GetNoSendDataCount(env->uveos.msdTable);
    if (noSendMsdCount > 0) {
#ifdef UVEOS_ADD_TELEMATICA
        TELEMATICA_STOP(env);
#endif
        Mma_NetworkAndAudioRequire(env);
        Mma_EcallPrepare(env);
        if (GsmWithGnss_NetworkEnableInnaterups(&env->gsmWithGnss, 4, 10000) == AT_OK) {
            LoggerTraceStatic(LOGGER, LOG_SIGN, "Сеть включена")
            EraGlonassUveos_ProcessingEra(&env->uveos);
            AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt);
            SystemDelayMs(5000);
            AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt);
            AtGsm_OperatorSelectionDeregister(&env->gsmWithGnss.gsmAt);
        } else {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть или сим-чип отсутствует");
        }
    }

    Pwm_AudioDisable(&env->power);
    LoggerTraceStatic(LOGGER, LOG_SIGN, "Звуковой усилитель отключён")
    AtGsm_OperatorSelectionDeregister(&env->gsmWithGnss.gsmAt);
    SystemDelayMs(2000);
    AtGsmTelitLe910_GnssEcallOnlyMode(&env->gsmWithGnss.gsmAt, 0);
    SystemDelayMs(2000);
    GsmWithGnss_SelectStandartNetwork(&env->gsmWithGnss.gsmAt, 25);

#ifdef UVEOS_ADD_TELEMATICA
    if (noSendMsdCount == 0) {
        TELEMATICA_START(env);
    }
#endif


    for (;;) {

        Mma_ColorBip(env);

#ifdef UVEOS_ADD_TELEMATICA
        if (env->storage.runtime.EGTS_FLEET_ON == false) {
            Mma_gnssUpdate(env, &indicationState);
        } else {

            indicationState = GsmWithGnss_IsGnssReady(&env->gsmWithGnss) ?
                              DEVICE_MODE_UVEOS_ERA_GNSS_READY :
                              DEVICE_MODE_UVEOS_ERA_WAIT_GNSS;

        }
#endif

#ifndef UVEOS_ADD_TELEMATICA
        Mma_gnssUpdate(env, &indicationState);
#endif


#ifdef UVEOS_ADD_TELEMATICA
        if (env->storage.runtime.EGTS_FLEET_ON == false) {
            LoggerTraceStatic(LOGGER, LOG_SIGN, "Начало итерации главного цикла")
            LoggerTraceStatic(LOGGER, LOG_SIGN, "Проверяем нужна ли сеть...")

            if (EraGlonassUveos_IsRequireNetwork(&env->uveos)) {
                LoggerTraceStatic(LOGGER, LOG_SIGN, "Нужна, подключаемся")
                Mma_SetNetworkRegistration(env, true);
            } else {
                LoggerTraceStatic(LOGGER, LOG_SIGN, "Ненужна, отключаемся")
                Mma_SetNetworkRegistration(env, false);
            }
        }
#endif

#ifndef UVEOS_ADD_TELEMATICA
            LoggerTraceStatic(LOGGER, LOG_SIGN, "Начало итерации главного цикла")
            LoggerTraceStatic(LOGGER, LOG_SIGN, "Проверяем нужна ли сеть...")

            if (EraGlonassUveos_IsRequireNetwork(&env->uveos)) {
                LoggerTraceStatic(LOGGER, LOG_SIGN, "Нужна, подключаемся")
                Mma_SetNetworkRegistration(env, true);
            } else {
                LoggerTraceStatic(LOGGER, LOG_SIGN, "Ненужна, отключаемся")
                Mma_SetNetworkRegistration(env, false);
            }
#endif

        LoggerTraceStatic(LOGGER, LOG_SIGN, "Выполняем постоянный тест")
        if (DeviceTesting_Always(&env->testing)) {
            indicationState = DEVICE_MODE_FAILURE;
        };

        LoggerTraceStatic(LOGGER, LOG_SIGN, "Выполняем периодическое тестирование")
        if (DeviceTesting_Periodical(&env->testing)) {
            indicationState = DEVICE_MODE_FAILURE;
            LoggerTraceStatic(LOGGER, LOG_SIGN, "Обновляем статус индикации")
        };


        Mma_SetMode(env, indicationState);

        if(env->uveos.timings.lastInMemTransmit < SystemGetMs()){
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Периодическая проверка необходимости повторной отправки МНД");

            noSendMsdCount = EraGlonassMsdTable_GetNoSendDataCount(env->uveos.msdTable);
            if (noSendMsdCount > 0) {
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Проверка регистрации в сети");
                if (GsmWithGnss_WaitNetworkRegistration(&env->gsmWithGnss, 2000)) {
                    LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть присутствует");
                    EraGlonassUveos_ProcessingCheckNoSendMSD(&env->uveos);
                    LoggerInfoStatic(LOGGER, LOG_SIGN, "Удаление всех СМС...");
                    AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt);
                    SystemDelayMs(500);
                    AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt);
                    LoggerInfoStatic(LOGGER, LOG_SIGN, "Удаление СМС выполнено");
                } else {
                    LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть или сим-чип отсутствует, попытка регистрации...");
                    if (GsmWithGnss_NetworkEnableInnaterups(&env->gsmWithGnss, 5,40000) == AT_OK) {
                        LoggerTraceStatic(LOGGER, LOG_SIGN, "Сеть присутствует")
                        EraGlonassUveos_ProcessingCheckNoSendMSD(&env->uveos);
                        LoggerInfoStatic(LOGGER, LOG_SIGN, "Удаление всех СМС...");
                        AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt);
                        SystemDelayMs(500);
                        AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt);
                        LoggerInfoStatic(LOGGER, LOG_SIGN, "Удаление СМС выполнено");
                    } else {
                        LoggerInfoStatic(LOGGER, LOG_SIGN,
                                         "Периодическая проверка необходимости повторной отправки МНД не выполнена");
                        LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть или сим-чип отсутствует");
                    }
                }
                LoggerTraceStatic(LOGGER, LOG_SIGN, "Обработка не отправленных МНД выполнена")
            }

            env->uveos.timings.lastInMemTransmit =
                    SystemGetMs() + (env->uveos.settings->INT_MEM_TRANSMIT_INTERVAL * 60 * 1000);
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Время периодическая проверки повторной отправки МНД обновлено");
        }


#ifdef UVEOS_ADD_TELEMATICA
        if (env->storage.runtime.EGTS_FLEET_ON == false) {
            checkLastInMemTransmit(env);
        }
#endif

#ifndef UVEOS_ADD_TELEMATICA
            checkLastInMemTransmit(env);
#endif

        LoggerTraceStatic(LOGGER, LOG_SIGN, "Проверяем экстренное событие")
        if (UveosEmergencyEvent_GetNext(&env->crashDetect.emergencyEvents, &emergencyEvent, 0)) {
            if (env->storage.nvm.gost.CRASH_SIGNAL_INTERNAL == 1) {
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Экстренное событие получено");
#ifdef UVEOS_ADD_TELEMATICA
                TELEMATICA_STOP(env);
#endif
                Mma_EcallAutomatic(env, emergencyEvent);
            }
        }


        LoggerTraceStatic(LOGGER, LOG_SIGN, "Проверяем нажатия кнопок")
        if (UserButtons_GetNext(&env->userInput.buttonsInterface, &buttonEvent, 10)) {

            if (UserInputButtonEventIsBetween(
                    buttonEvent, UI_BUTTON_EMERGENCY, RAISE, env->storage.nvm.gost.SOS_BUTTON_TIME, 0xFFFF
            )) {
                LoggerTraceStatic(LOGGER, LOG_SIGN, "Нажата кнопка экстренного вызова")
#ifdef UVEOS_ADD_TELEMATICA
                TELEMATICA_STOP(env);
#endif
                Mma_EcallManual(env);
            } else if (UserInputButtonEventIsBetween(buttonEvent, UI_BUTTON_ADDITIONAL, RAISE, 3000, 10000)) {

#ifdef UVEOS_ADD_TELEMATICA
                TELEMATICA_STOP(env);
#endif

                vAsciiStringInit(step, &str_len, 5);
                vAsciiStringAddDecimalInt64(step, &str_len, env->uveos.doNothing.movDist, 5);

                if (env->uveos.doNothing.mode == UVEOS_DO_NOTHING_DISABLED) {
                    Mma_SetMode(env, DEVICE_MODE_TESTING);
                    LoggerInfoStatic(LOGGER, LOG_SIGN,
                                     "Переход в режим пользовательского тестирования, отклонение дистанции = ");
                    LoggerInfo(LOGGER, LOG_SIGN, step, str_len);
                    Mma_UserTestMode(env);
                } else if (env->uveos.doNothing.mode == UVEOS_DO_NOTHING_MOVE_TO) {
                    LoggerInfoStatic(LOGGER, LOG_SIGN,
                                     "Переход в режим тестирования не возможен, Т.С. находится в движении, отклонение дистанции = ");
                    LoggerInfo(LOGGER, LOG_SIGN, step, str_len);
                } else if (env->uveos.doNothing.movePosition.valid == 0) {
                    LoggerInfoStatic(LOGGER, LOG_SIGN, "Данные GNSS не достоверны!");
                }

            } else if (UserInputButtonEventIsBetween(buttonEvent, UI_BUTTON_ADDITIONAL, RAISE, 10000, 30000)) {
                vAsciiStringInit(step, &str_len, 5);
                vAsciiStringAddDecimalInt64(step, &str_len, env->uveos.doNothing.movDist, 5);
                if (env->uveos.doNothing.mode == UVEOS_DO_NOTHING_DISABLED) {
                    Mma_SetMode(env, DEVICE_MODE_UVEOS_GARAG);
                    LoggerInfoStatic(LOGGER, LOG_SIGN, "Переход в режим Гараж, отклонение дистанции = ");
                    LoggerInfo(LOGGER, LOG_SIGN, step, str_len);
                    Mma_GarageMode(env);
                } else if (env->uveos.doNothing.mode == UVEOS_DO_NOTHING_MOVE_TO) {
                    LoggerInfoStatic(LOGGER, LOG_SIGN,
                                     "Переход в режим Гараж не возможен, Т.С. находится в движении, отклонение дистанции = ");
                    LoggerInfo(LOGGER, LOG_SIGN, step, str_len);
                } else if (env->uveos.doNothing.movePosition.valid == 0) {
                    LoggerInfoStatic(LOGGER, LOG_SIGN, "Данные GNSS не достоверны!");
                }
            }

        }


#ifdef UVEOS_ADD_TELEMATICA
        if (env->storage.runtime.EGTS_FLEET_ON == false) {
            if (EraGlonassUveos_IsAllowInCall(&env->uveos) && GsmWithGnss_IsRing(&env->gsmWithGnss)) {
                Mma_ProcessCallAnswer(env);
            }
            Mma_CheckIncomingSms(env);
        }
#endif

#ifndef UVEOS_ADD_TELEMATICA
        if (EraGlonassUveos_IsAllowInCall(&env->uveos) && GsmWithGnss_IsRing(&env->gsmWithGnss)) {
            Mma_ProcessCallAnswer(env);
        }
        Mma_CheckIncomingSms(env);
#endif

        Mma_CheckShutdown(env, false);

        SystemDelayMs(10);
    }
}


void Mma_StartTestThreadStart(tMma *env) {
    if (!env->threadTesting.id) {
        env->threadTesting.id = osThreadNew(
                (osThreadFunc_t) (Mma_TestingThread),
                (void *) (env),
                &env->threadTesting.attr
        );
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Сопроводительный поток запущен")
    }
}

void Mma_StopTestThreadStart(tMma *env) {
    if (env->threadTesting.id != NULL) {
        if (osThreadTerminate(env->threadTesting.id) == osOK) {
            SystemDelayMs(100);
            env->threadTesting.id = NULL;
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Сопроводительный поток остановлен")
            SystemDelayMs(500);
        }
    }
}

void Mma_StartThread(tMma *env) {
    if (!env->thread.id) {
        env->thread.id = osThreadNew((osThreadFunc_t) (Mma_Thread), (void *) (env), &env->thread.attr);
    } else {
        osThreadResume(env->thread.id);
    }
}