//
// Created by xemon on 30.11.22.
//

#include "EraGlonassUveos_Private.h"
//#include "UserInput.h"
#include "AsciiStringParsingUtils.h"
#include "egtsWorker.h"
#include "Rtc.h"

#define LOGGER env->logger
#define LOG_SIGN "УВЭОС,ЭВ"
#define DEVTST_PLAY_SAMPLE(SAMPLE) \
    SystemDelayMs(150); \
    AudioPlayer_PlayStatic(env->audioPlayerIO, SAMPLE, 25*1000);

#define DEVTST_PLAY_TONE(COUNT) \
    AudioPlayer_PlayStaticTone(env->audioPlayerIO,COUNT);

eEraGlonassUveos_EcallProcessingResult smsTransmitFl = ERA_GLONASS_UVEOS_SEND_FAIL;

void EraGlonassUveos_UpdateMsd(tEraGlonassUveos *env, eEcallTimeSourse timeSourse) {
    EraGlonassUveosNavData nav;
    time_t time;

    if (timeSourse == GNSS_TIME_SOURSE) {
        NavDataProvider_GetTime(env->navDataProvider, (uint32_t*) &time);
    }
    if (timeSourse == RTC_TIME_SOURSE) {
        RtcGet(env->timings.rtcIo, &time);
    }
    if (timeSourse == NOT_CHANGE_TIME) {
        time = env->currentMsd->msd.MSD_Data.timestamp;
    }

    NavDataProvider_GetNavData(env->navDataProvider, &nav, true);
    EraGlonassMsdSetTimeStamp(&env->currentMsd->msd, time);

    if (nav.valid != 0) {
        EraGlonassMsdSetPositionValue(&env->currentMsd->msd, nav.longitude, nav.latitude, nav.direction, nav.valid);
    } else {
        EraGlonassMsdNoGnssSetDefaults(&env->currentMsd->msd);
    }
}

static void EraGlonassUveos_SignMsd(tEraGlonassUveos *env, eEcallActivationType type, bool test) {
    EraGlonassMsdSetDataEmergencySituationFlags(
            &env->currentMsd->msd,
            env->currentMsd->msd.MSD_Data.msgId,
            type,
            test ? TEST_CALL : EMERGENCY_CALL
    );
}

void EraGlonassUveos_CompileMsd(tEraGlonassUveos *env, tEraGlonassMsd *msd, tMsdEncoded *msdEncoded) {
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Собираем бинарный пакет МНД")
    msdEncoded->len = EraGlonassMsdEncode(msd, MSD_V_2, msdEncoded->data);

    char asciiMsd[msdEncoded->len * 2];
    size_t asciiMsdLen = 0;
    vAsciiStringAddBytesAsHex(asciiMsd, &asciiMsdLen, msdEncoded->data, msdEncoded->len);
    LoggerCnInfoStatic(LOGGER, LOG_SIGN, "Бинарный пакет МНД сформирован: ")
    LoggerInfo(LOGGER, LOG_SIGN, asciiMsd, asciiMsdLen)
}


eEraGlonassUveos_EcallProcessingResult EraGlonassUveos_ProcessingSms(
        tEraGlonassUveos *env,
        tMsdEncoded *msdEncoded
) {
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Отправка смс...")
    if (EraGlonassUveos_EmergencySendMsdSmsTry(env, msdEncoded)) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "МНД отправленно по средствам СМС")
        env->currentMsd->attemptsLeft = 0;
        EraGlonassUveosDumper_ForceDump(env->dumper);
        EraGlonassUveos_Indicate(env, UVEOS_STATUS_SMS_TRANSMIT);
        return ERA_GLONASS_UVEOS_SMS_SENT;
    } else {
        LoggerErrorStatic(LOGGER, LOG_SIGN, "Неудалось отпаравить МНД по средствам СМС")
        return ERA_GLONASS_UVEOS_SEND_FAIL;
    }
}

void reSetMsdToPull(tEraGlonassUveos *env, const bool *wasNewSetMsd, const bool *wasResent, tMsdEncoded *msdEncoded) {
    if (
            (*wasNewSetMsd == true) &&
            (*wasResent == false) &&
            (env->currentMsd->msd.MSD_Data.msgId > 1)
            ) {
        env->currentMsd->msd.MSD_Data.msgId--;

        EraGlonassUveos_UpdateMsd(env, RTC_TIME_SOURSE);
        EraGlonassUveos_CompileMsd(env, &env->currentMsd->msd, msdEncoded);
        EraGlonassEcallProvider_SettingNewMsd(env->ecallProvider, msdEncoded->data, msdEncoded->len);
        LoggerInfoStatic(LOGGER, LOG_SIGN,
                         "Переотправка МНД по PULL запросу от оператора НЕ была выполнена, не получен URC об отправке")
    }
}

void setMsdToPull(tEraGlonassUveos *env, const bool *mndSendFlag, bool *wasNewSetMsd, bool *wasResent,
                  tMsdEncoded *msdEncoded) {
    if (
            (*mndSendFlag == true) &&
            (*wasNewSetMsd == false)
            ) {

        env->currentMsd->msd.MSD_Data.msgId++;

        EraGlonassUveos_UpdateMsd(env, RTC_TIME_SOURSE);
        EraGlonassUveos_CompileMsd(env, &env->currentMsd->msd, msdEncoded);
        EraGlonassEcallProvider_SettingNewMsd(env->ecallProvider, msdEncoded->data, msdEncoded->len);
        *wasNewSetMsd = true;
    } else if (EraGlonassEcallProvider_IsMsdReSent(env->ecallProvider)) {
        *wasNewSetMsd = false;
        *wasResent = true;
        LoggerInfoStatic(LOGGER, LOG_SIGN,
                         "Была выполнена переотправка МНД по PULL запросу от оператора, будет установлен новый МНД")
    }
}

static eEraGlonassUveos_EcallProcessingResult EraGlonassUveos_EmergencyCallTry(
        tEraGlonassUveos *env,
        tMsdEncoded *msdEncoded,
        eEcallActivationType activationType,
        eEcallTestMode testMode,
        uint32_t dialTimeoutEnd,
        bool *mndSendFlag,
        bool debugMode
) {

    eEraGlonassUveos_EcallProcessingResult callResult = ERA_GLONASS_UVEOS_CALL_FAIL;
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Пробуем совершить экстренный вызов")

//    if(testMode != TEST_CALL) {
//        EraGlonassUveos_Indicate(env, UVEOS_STATUS_CALL_INITIATE);
//    }

    EraGlonassUveos_CompileMsd(env, &env->currentMsd->msd, msdEncoded);

    if (!EraGlonassEcallProvider_Ecall(
            env->ecallProvider,
            msdEncoded->data,
            msdEncoded->len,
            env->settings->ECALL_TEST_NUMBER.data,
            env->settings->ECALL_TEST_NUMBER.length,
            activationType,
            testMode
    )) {
        LoggerErrorStatic(LOGGER, LOG_SIGN, "Неудалось инициировать экстренный вызов")
        if(testMode != TEST_CALL) {
            EraGlonassUveos_Indicate(env, UVEOS_STATUS_CALL_FAILURE);
        }
        env->currentMsd->attemptsLeft--;
        return ERA_GLONASS_UVEOS_CALL_FAIL;
    }
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Экстренный вызов успешно инициирован")
    tUserInputButtonEvent buttonEvent = {0};
    LoggerCnInfoStatic(LOGGER, LOG_SIGN, "Дозвон")
    while (EraGlonassEcallProvider_IsDialing(env->ecallProvider)) {
        EraGlonassUveos_Indicate(env, UVEOS_STATUS_CALL_INITIATE);
        LoggerCnInfoStatic(LOGGER, LOG_SIGN, ".")
        if (env->settings->ECALL_MANUAL_CAN_CANCEL) {
            while (UserButtons_GetNext(env->buttons, &buttonEvent, 0)) {
                if (UserInputButtonEventIsBetween(buttonEvent, env->buttonsIds.emergensy, RAISE, 500, 4000)) {
                    EraGlonassEcallProvider_HangupEcl(env->ecallProvider);
                    LoggerInfoStatic(LOGGER, LOG_SIGN, ".")
                    LoggerInfoStatic(LOGGER, LOG_SIGN, "Звонок прерван пользователем")
                    return ERA_GLONASS_UVEOS_CALL_USER_BREAK;
                }
            }
        }
        SystemDelayMs(500);
        if (SystemGetMs() > dialTimeoutEnd) {
            EraGlonassEcallProvider_HangupEcl(env->ecallProvider);
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Звонок прерван, превышена общая продолжительность дозвона")
            if(testMode != TEST_CALL) {
                EraGlonassUveos_Indicate(env, UVEOS_STATUS_CALL_FAILURE);
            }
            return ERA_GLONASS_UVEOS_CALL_FAIL;
        }
    }

    LoggerInfoStatic(LOGGER, LOG_SIGN, ".")
    if(testMode != TEST_CALL) {
        EraGlonassUveos_Indicate(env, UVEOS_STATUS_MSD_TRANSMIT);
    }
    uint32_t msdSendTimeout = SystemGetMs() + (env->settings->MSD_MAX_TRANSMISSION_TIME * 1000);

    if (EraGlonassEcallProvider_IsActiveOut(env->ecallProvider)) {
        #if (AURUS_CAR_UI == 0)
            DEVTST_PLAY_SAMPLE("audio_on.mp3")
        #endif
    }

    bool fl = false;
    LoggerCnInfoStatic(LOGGER, LOG_SIGN, "Попытка отправки МНД...")


#if (AURUS_CAR_UI == 1)
    DEVTST_PLAY_TONE(1)
#endif
#if (AURUS_CAR_UI == 0)
    DEVTST_PLAY_SAMPLE("msd_send.mp3")
#endif

    EraGlonassUveos_Indicate(env, UVEOS_STATUS_MSD_TRANSMIT);
    while (!EraGlonassEcallProvider_IsMsdSent(env->ecallProvider) &&
           EraGlonassEcallProvider_IsActiveOut(env->ecallProvider) &&
           (msdSendTimeout > SystemGetMs())) {
        LoggerCnInfoStatic(LOGGER, LOG_SIGN, ".")
        SystemDelayMs(500);
        if(fl == false){
            SystemDelayMs(4500);
            fl = true;
        }
    }
    if(!debugMode) {
        if (EraGlonassEcallProvider_IsMsdSent(env->ecallProvider)) {
            env->currentMsd->attemptsLeft = 0;
            *mndSendFlag = true;
            callResult = ERA_GLONASS_UVEOS_CALL_SUCCESS;
            LoggerInfoStatic(LOGGER, LOG_SIGN, "МНД передан по средствам тонального модема")
        } else {
            if (!EraGlonassEcallProvider_IsActiveOut(env->ecallProvider)) {
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Вызов завершен принимающей стороной")
            } else {
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Превышено время передачи МНД тональным модемом")
                callResult = ERA_GLONASS_UVEOS_SEND_FAIL;
            }
            if (testMode != TEST_CALL) {
                EraGlonassUveos_Indicate(env, UVEOS_STATUS_CALL_FAILURE);
            }
        }

        if ((callResult == ERA_GLONASS_UVEOS_CALL_FAIL) && (*mndSendFlag == false)) {
            LoggerErrorStatic(LOGGER, LOG_SIGN, "Не удалось отправить МНД (цикл вызовов) ошибка установки соединения")
            LoggerErrorStatic(LOGGER, LOG_SIGN,
                              "Производиться проверка сети для передачи МНД по альтернативному каналу связи")
            if (EraGlonassEcallProvider_CheckNetState(env->ecallProvider, 20000) == true) {
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть присутствует, попытка отправки МНД по средствам СМС")
                EraGlonassUveos_CompileMsd(env, &env->currentMsd->msd, msdEncoded);

                if (EraGlonassUveos_ProcessingSms(env, msdEncoded) == ERA_GLONASS_UVEOS_SMS_SENT) {
                    *mndSendFlag = true;
                    callResult = ERA_GLONASS_UVEOS_CALL_SUCCESS;
                    LoggerInfoStatic(LOGGER, LOG_SIGN, "МНД отправлен по средствам СМС")
                } else {
                    LoggerInfoStatic(LOGGER, LOG_SIGN, "Не удалось выполнить отправку СМС")
                    *mndSendFlag = false;
                    callResult = ERA_GLONASS_UVEOS_CALL_FAIL;
                }

                EraGlonassEcallProvider_DelSms(env->ecallProvider);
            } else {
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть отсутствует")
            }
        }

        if ((callResult == ERA_GLONASS_UVEOS_SEND_FAIL) && (*mndSendFlag == false)) {
            LoggerErrorStatic(LOGGER, LOG_SIGN,
                              "Не удалось отправить МНД (цикл вызовов) ошибка передачи МНД по средствам тональной связи")
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть присутствует, попытка отправки МНД по средсвам СМС")
            EraGlonassUveos_CompileMsd(env, &env->currentMsd->msd, msdEncoded);
            if (EraGlonassUveos_ProcessingSms(env, msdEncoded) == ERA_GLONASS_UVEOS_SMS_SENT) {
                EraGlonassEcallProvider_DelSms(env->ecallProvider);
                *mndSendFlag = true;
                callResult = ERA_GLONASS_UVEOS_CALL_SUCCESS;
                LoggerInfoStatic(LOGGER, LOG_SIGN, "МНД отправлен по средствам СМС")
            } else {
                EraGlonassEcallProvider_DelSms(env->ecallProvider);
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Не удалось выполнить отправку СМС")
                *mndSendFlag = false;
                callResult = ERA_GLONASS_UVEOS_SEND_FAIL;
            }
        }
    }

    bool wasNewSetMsd = false;
    bool wasResent = false;
    LoggerCnInfoStatic(LOGGER, LOG_SIGN, "Звонок")
    uint64_t times = SystemGetMs();


if(EraGlonassEcallProvider_IsActiveOut(env->ecallProvider)){
    #if (AURUS_CAR_UI == 1)
        DEVTST_PLAY_TONE(2)
        if(testMode == TEST_CALL) {
            EraGlonassUveos_Indicate(env, UVEOS_STATUS_TESTING_BEGIN);
        } else {
            EraGlonassUveos_Indicate(env, UVEOS_STATUS_CALL_ACTIVE);
        }
    #endif
    #if (AURUS_CAR_UI == 0)
        EraGlonassUveos_Indicate(env, UVEOS_STATUS_CALL_ACTIVE);
    #endif
}


    while (EraGlonassEcallProvider_IsActiveOut(env->ecallProvider)) {
        EraGlonassEcallProvider_CheckSms(env->ecallProvider);
        LoggerCnInfoStatic(LOGGER, LOG_SIGN, ".")
        if (times < SystemGetMs() && (wasNewSetMsd == true)) {
            setMsdToPull(env, mndSendFlag, &wasNewSetMsd, &wasResent, msdEncoded);
            times = SystemGetMs() + 5000;
            LoggerCnInfoStatic(LOGGER, LOG_SIGN, "Установлен новый пакет МНД для PUL запроса")
        }
        SystemDelayMs(500);
    }

    reSetMsdToPull(env, &wasNewSetMsd, &wasResent, msdEncoded);
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Звонок завершен")
    return callResult;
}











///=====================================================================================================================
///=====================================================================================================================
///=====================================================================================================================
///=====================================================================================================================
///=====================================================================================================================



bool EraGlonassUveos_ResentMsdTry(tEraGlonassUveos *env, tEraGlonassMsdTableItem *msdItem) {
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Переотправка МНД...")
    tMsdEncoded msdEncoded;
    EraGlonassUveos_CompileMsd(env, &msdItem->msd, &msdEncoded);
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Отправка смс...")

    if (EraGlonassUveos_EmergencySendMsdSmsTry(env, &msdEncoded)) {
        EraGlonassEcallProvider_DelSms(env->ecallProvider);
        LoggerInfoStatic(LOGGER, LOG_SIGN, "МНД отправлено по средствам СМС")
        EraGlonassUveosDumper_ForceDump(env->dumper);
        return true;
    } else {
        EraGlonassEcallProvider_DelSms(env->ecallProvider);
        LoggerErrorStatic(LOGGER, LOG_SIGN, "Не удалось отправить МНД по средствам СМС PERIODICAL")
        EraGlonassUveosDumper_ForceDump(env->dumper);
        return false;
    }
}

void EraGlonassUveos_UpdateCurrentSettingsMsd(tEraGlonassUveos *env, eEcallTimeSourse timeSourse) {
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Обнавляем настройки...")
    EraGlonassUveos_InvalidateSettings(env);
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Обновляем МНД...")
    EraGlonassUveos_UpdateMsd(env, timeSourse);
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Сохраняем изменения в ПЗУ")
    EraGlonassUveosDumper_ForceDump(env->dumper);
}

void EraGlonassUveos_GenCurrentMsd(tEraGlonassUveos *env,
                                   eEcallActivationType activationType,
                                   eEcallTestMode testMode,
                                   eEcallTimeSourse timeSourse) {
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Обнавляем настройки...")
    EraGlonassUveos_InvalidateSettings(env);
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Обновляем МНД...")
    EraGlonassUveos_UpdateMsd(env, timeSourse);
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Выделяем МНД ID в таблице")
    EraGlonassUveos_SignMsd(env, activationType, testMode);
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Сохраняем изменения в ПЗУ")
    EraGlonassUveosDumper_ForceDump(env->dumper);
}

void EraGlonassUveos_ClearSms(tEraGlonassUveos *env){
    uint32_t t = SystemGetMs() + 1252;
    while (t > SystemGetMs()){
        EraGlonassEcallProvider_DelSms(env->ecallProvider);
        SystemDelayMs(50);
    }
}

uint16_t getAttemptsLeft(tEraGlonassUveos *env, eEcallActivationType activationType){
    if(activationType == AUTOMATIC_ACTIVATION){
        return env->settings->ECALL_AUTO_DIAL_ATTEMPTS;
    } else if(activationType == MANUAL_ACTIVATION){
        return env->settings->ECALL_MANUAL_DIAL_ATTEMPTS;
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "==== ВНИМАНИЕ, КОЛИЧЕСТВО ПОПЫТОК ВЫЗОВОВ НЕ СКОНВИГУРИРОВАНО, БУДЕТ ВЫПОЛНЕНА 1 ПОПЫТКА!!! ====")
        return 1;
    }
}

eEraGlonassUveos_EcallProcessingResult EraGlonassUveos_ProcessingEmergency(
        tEraGlonassUveos *env,
        eEcallActivationType activationType,
        eEcallTestMode testMode,
        bool debugMode
) {

    LoggerInfoStatic(LOGGER, LOG_SIGN, "Обработка экстреной ситуации...")
    env->currentMsd->msd.MSD_Data.msgId = 1;
    tMsdEncoded msdEncoded;

    EraGlonassUveos_GenCurrentMsd(env, activationType, testMode, RTC_TIME_SOURSE);
    uint16_t attemptsLeft = getAttemptsLeft(env, activationType);
    env->currentMsd->attemptsLeft = env->settings->INT_MEM_TRANSMIT_ATTEMPTS;
    uint32_t dialTimeout = SystemGetMs() + (env->settings->ECALL_DIAL_DURATION * 60 * 1000);

//    if(testMode != TEST_CALL) {
//        EraGlonassUveos_Indicate(env, UVEOS_STATUS_CALL_INITIATE);
//    }

    eEraGlonassUveos_EcallProcessingResult resultSendEmergy = ERA_GLONASS_UVEOS_CALL_FAIL;

    bool pr_mndSendFlag = false;
    bool fl_audio = false;

    while (((SystemGetMs() < dialTimeout)) && (attemptsLeft > 0)) {

        if(fl_audio == true) {
#if (AURUS_CAR_UI == 1)
            if(testMode != TEST_CALL) {
                DEVTST_PLAY_SAMPLE("emerCool_aurus.mp3")
            }
#endif
#if (AURUS_CAR_UI == 0)
            DEVTST_PLAY_SAMPLE("ecall_on.mp3")
#endif
        }
        fl_audio = true;

//        if(testMode != TEST_CALL) {
//            EraGlonassUveos_Indicate(env, UVEOS_STATUS_DIALING);
//        }

//        EraGlonassUveos_Indicate(env, UVEOS_STATUS_WAIT_NETWORK);
//        bool isReg = EraGlonassEcallProvider_NetRegistration(env->ecallProvider,1);
//        if(isReg == false)
//        {
//            EraGlonassEcallProvider_NetRegistration(env->ecallProvider,1);
//            SystemDelayMs(2000);
//        }

        resultSendEmergy = EraGlonassUveos_EmergencyCallTry(
                env,
                &msdEncoded,
                activationType,
                testMode,
                dialTimeout,
                &pr_mndSendFlag,
                debugMode
        );
        EraGlonassEcallProvider_HangupEcl(env->ecallProvider);
        if(debugMode) {
            return resultSendEmergy;
        }

        if (resultSendEmergy == ERA_GLONASS_UVEOS_CALL_USER_BREAK) {
            return resultSendEmergy;
        }

        if ((pr_mndSendFlag) && (resultSendEmergy == ERA_GLONASS_UVEOS_CALL_SUCCESS)) {
            --attemptsLeft;
            break;
        }
        --attemptsLeft;
        EraGlonassEcallProvider_HangupEcl(env->ecallProvider);
        EraGlonassUveosDumper_ForceDump(env->dumper);
        env->currentMsd->msd.MSD_Data.msgId++;
        if(env->currentMsd->msd.MSD_Data.msgId == (getAttemptsLeft(env, activationType)) +1 ) {
            env->currentMsd->msd.MSD_Data.msgId = getAttemptsLeft(env, activationType);
        }
        dialTimeout = SystemGetMs() + (env->settings->ECALL_DIAL_DURATION * 60 * 1000);
    }
    if(debugMode) {
        return resultSendEmergy;
    }
    if (resultSendEmergy == ERA_GLONASS_UVEOS_CALL_SUCCESS) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Произведен успешный экстренный вызов")

        EraGlonassUveos_ClearSms(env);
        LoggerInfoStatic(LOGGER, LOG_SIGN, "СМС пакеты очищены из памяти коммуникационного модуля")
        env->currentMsd->attemptsLeft = 0;
        if(testMode != TEST_CALL) {
            EraGlonassUveosDumper_ForceDump(env->dumper);
        }
        env->currentMsd = EraGlonassMsdTable_GetNextFree(env->msdTable);
        return resultSendEmergy;
    } else if ((resultSendEmergy == ERA_GLONASS_UVEOS_CALL_FAIL) || (resultSendEmergy == ERA_GLONASS_UVEOS_SEND_FAIL)) {
        LoggerErrorStatic(LOGGER, LOG_SIGN,
                          "Не удалось совершить отправку МНД, производиться проверка сети и попытка отправки МНД по средствам СМС")
//        bool isReg = EraGlonassEcallProvider_NetRegistration(env->ecallProvider,1);
        if (EraGlonassEcallProvider_CheckNetState(env->ecallProvider, 5) == true) {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть присутствует")

#if (AURUS_CAR_UI == 1)
            DEVTST_PLAY_TONE(1)
#endif
#if (AURUS_CAR_UI == 0)
            DEVTST_PLAY_SAMPLE("msd_send.mp3")
#endif

            if(testMode != TEST_CALL) {
                EraGlonassUveos_Indicate(env, UVEOS_STATUS_CALL_FAILURE);
            }
            EraGlonassUveos_Indicate(env, UVEOS_STATUS_MSD_TRANSMIT);
            EraGlonassUveos_CompileMsd(env, &env->currentMsd->msd, &msdEncoded);
            resultSendEmergy = EraGlonassUveos_ProcessingSms(env, &msdEncoded);
        } else {
            bool isReg = EraGlonassEcallProvider_NetRegistration(env->ecallProvider,1);
            if(isReg){
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть присутствует")

#if (AURUS_CAR_UI == 1)
                DEVTST_PLAY_TONE(1)
#endif
#if (AURUS_CAR_UI == 0)
                DEVTST_PLAY_SAMPLE("msd_send.mp3")
#endif
                if(testMode != TEST_CALL) {
                    EraGlonassUveos_Indicate(env, UVEOS_STATUS_CALL_FAILURE);
                }
                EraGlonassUveos_Indicate(env, UVEOS_STATUS_MSD_TRANSMIT);
                EraGlonassUveos_CompileMsd(env, &env->currentMsd->msd, &msdEncoded);
                resultSendEmergy = EraGlonassUveos_ProcessingSms(env, &msdEncoded);
            } else {
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть отсутствует")
            }
        }
    }

    if ((pr_mndSendFlag) || ((int) resultSendEmergy == ERA_GLONASS_UVEOS_SMS_SENT)) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "МНД отправлено по средствам СМС")
        env->currentMsd->msd.MSD_Data.msgId ++;
        if(testMode != TEST_CALL) {
            EraGlonassUveos_Indicate(env, UVEOS_STATUS_MSD_TRANSMIT);
        }
    }

    if ((!pr_mndSendFlag) || ((int) resultSendEmergy == ERA_GLONASS_UVEOS_SEND_FAIL)) {
        LoggerErrorStatic(LOGGER, LOG_SIGN, "Не удалось отправить МНД по средствам СМС ECALL")
        if(testMode != TEST_CALL) {
            EraGlonassUveos_Indicate(env, UVEOS_STATUS_CALL_FAILURE);
        }
    }

    if ((resultSendEmergy == ERA_GLONASS_UVEOS_SEND_FAIL) || (resultSendEmergy == ERA_GLONASS_UVEOS_CALL_FAIL)) {
        env->currentMsd->attemptsLeft = env->settings->INT_MEM_TRANSMIT_ATTEMPTS;
    } else {
        env->currentMsd->attemptsLeft = 0;
    }

    EraGlonassUveos_ClearSms(env);
    if(testMode != TEST_CALL) {
        EraGlonassUveosDumper_ForceDump(env->dumper);
    }

    env->currentMsd = EraGlonassMsdTable_GetNextFree(env->msdTable);

    return resultSendEmergy;
}