//
// Created by xemon on 30.10.22.
//


#include <AudioPlayerInterface.h>
#include <SystemDelayInterface.h>
#include "DeviceTesting.h"
#include "UserInput.h"
#include "DeviceTesting_TestsWithUser.h"
#include "Adc.h"
#include "EraGlonassMsd.h"
#include "EraGlonassUveos.h"
#include "Accel.h"
#include "GsmWithGnss.h"
#include "AsciiStringAssmeblingUtils.h"
#include "semphr.h"
#include "MainModesArbiter_Private.h"

#define LOGGER env->logger
#define LOG_SIGN "Тест."

bool DeviceTesting_Init(
        tDeviceTesting *env,

        tUserInputButtonWatcher *UserInputButtonWatcher,
        tGpioPin *ignPin,
        tAdcIO *gnssAntAdc,
        tSpekTestPower *spekTestPower,
        tBipPins *bipDiagnost,
        tBatteryPower *batteryPower,
        tAccel *accel,

        tGsmWithGnss *gsmWithGnss,
        tAudioCodec *audioCodec,
        tLoggerInterface *logger,
        tAtCmd *gsmAt,

        tAudioPlayerInterface *audioPlayer,
        tAudioRecorderInterface *audioRecorder,

        tUserButtonsInterface *input,
        tUserIndication *indication,

        tEraGlonassUveos *ErGlUv,
        bool *antMode,
        tGpioPin *ring,
        tPowerManagement *powerManagement,

        tDeviceStorage *deviceStorage,
        tDeviceModes *deviceModes,
        tAmplifier *amplifier,
        tModemDataColl *modemDataColl,
        eQueryUDSState *queryUDSState,
        float *boardVoltCalbCof,
        bool *telematicaIsActive,
        bool *fl_telematicaServerIsActive,
        eDeviceTestingCode *deviceTestingCodeCan
) {
    env->boardVoltCalbCof = boardVoltCalbCof;
    env->audioHintsMode = HINTS_FULL;
    env->queryUDSState = queryUDSState;
    env->amplifier = amplifier;
    env->modemDataColl = modemDataColl;
    env->UserInputButtonWatcher = UserInputButtonWatcher;
    env->logger = logger;
    env->audioPlayer = audioPlayer;
    env->audioRecorder = audioRecorder;
    env->input = input;
    env->indication = indication;
    env->ErGlUv = ErGlUv;
    env->accelDFI = &accel->accelDataFlow;
    env->pinIgnition = ignPin;
    env->ringPin = ring;
    env->antDiscript.externalAdc = gnssAntAdc;
    env->antDiscript.gsmAt = gsmAt;
    env->antDiscript.mode = antMode;
    env->gsmWithGnss = gsmWithGnss;
    env->spekTestPower = spekTestPower;
    env->powerManagement = powerManagement;
    env->bipDiagnost = bipDiagnost;
    env->deviceStorage = deviceStorage;
    env->fl_oneTestResult = false;
    env->telematicaIsActive = false;
    env->systemExitStatus = SYSTEM_IS_FREE;

    env->modemVersionRevisionTest.deviceModes = deviceModes;
    env->modemVersionRevisionTest.modemDataCollector = modemDataColl;
    env->modemVersionRevisionTest.deviceStorage = deviceStorage;
    env->modemVersionRevisionTest.checkCert.isFind1 = false;
    env->modemVersionRevisionTest.checkCert.isFind2 = false;
    env->modemVersionRevisionTest.checkCert.isFind3 = false;
    env->modemVersionRevisionTest.gsmWithGnss = gsmWithGnss;
    env->modemVersionRevisionTest.telematicaIsActive = telematicaIsActive;
    env->modemVersionRevisionTest.fl_telematicaServerIsActive = fl_telematicaServerIsActive;
    env->modemVersionRevisionTest.testTelematicaIsActive = &env->telematicaIsActive;

    env->canTest.deviceTestingCodeCan = deviceTestingCodeCan;
    env->canTest.deviceStorage = deviceStorage;
    env->canTest.fl_IsLoad = &env->modemVersionRevisionTest.modemDataCollector->fl_IsLoad;

    env->mux_testingMode = osMutexNew(NULL);

    DeviceTests_InitTestsTable(
            env,
            ignPin,
            env->spekTestPower,
            env->bipDiagnost,
            batteryPower,
            gsmAt,
            audioCodec,
            accel,
            &env->antDiscript,
            deviceStorage,
            &env->modemVersionRevisionTest,
            env->amplifier,
            &env->canTest
    );

    InitThreadAtrStatic(&env->threadUserTest.attr, "Thread_UserTest", env->threadUserTest.controlBlock,
                        env->threadUserTest.stack, osPriorityNormal);

    env->flagAutoTestSucsess = false;
    env->flagAcsessExitThread = SYSTEM_IS_FREE;
    return true;
}

void DeviceTesting_SetTelematicaTestMode(tDeviceTesting *env, bool mode) {
    env->telematicaIsActive = mode;
}

void DeviceTesting_StartUserTestThread(tDeviceTesting *env) {
    if (!env->threadUserTest.id) {
        env->threadUserTest.id = osThreadNew(
                (osThreadFunc_t) (DeviceTesting_ManualTestMode),
                (void *) (env),
                &env->threadUserTest.attr
        );
    }
}

bool DeviceTesting_ExitTestMode(tDeviceTesting *env) {
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Освобождение потока подсистемы тестирования")
    uint32_t tm = SystemGetMs() + 8000;
    while (tm > SystemGetMs()) {
        if (osMutexAcquire(env->gsmWithGnss->gsmAt.access, 100) == osOK) {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Блокировка АТ интерфейса снята")
            if (osThreadTerminate(env->threadUserTest.id) == osOK) {
                SystemDelayMs(10);


                env->threadUserTest.id = NULL;
                env->flagAcsessExitThread = SYSTEM_IS_FREE;
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Поток подсистемы тестирования освобождён")
                osMutexRelease(env->gsmWithGnss->gsmAt.access);
                AudioRecord_StopToEndRec(env->audioRecorder, 1000);

                return 1;
            } else {
                osMutexRelease(env->gsmWithGnss->gsmAt.access);
                return 0;
            }
        }
        SystemDelayMs(1);
    }
    return 0;
}

void DeviceTesting_ChekExit(tDeviceTesting *env) {
    SystemDelayMs(50);
    EraGlonassUveos_DoNothingModeDistance(env->ErGlUv, false);
}

bool DeviceTesting_RunUserTests(tDeviceTesting *env) {
    if (osMutexAcquire(env->mux_testingMode, 3000) == osOK) {

        DeviceTesting_StartUserTestThread(env);

        for (;;) {

            if (env->flagAcsessExitThread == SYSTEM_IS_BUSY) {
//                LoggerInfoStatic(LOGGER, LOG_SIGN,
//                                 "!!!!SYSTEM_IS_BUSY!!!!!")
                SystemDelayMs(400);
                continue;
            }

            if (env->queryUDSState->commands == COM_STOP) {
                LoggerInfoStatic(LOGGER, LOG_SIGN,
                                 "Попытка выхода из режима пользовательского тестирования, код 4")
                if (DeviceTesting_ExitTestMode(env)) {
                    EraGlonassUveos_DoNotingReset(env->ErGlUv);
                    LoggerInfoStatic(LOGGER, LOG_SIGN,
                                     "Автоматический выход из режима пользовательского тестирования, код 4")
                    env->queryUDSState->commands = COM_INIT;
                    osMutexRelease(env->mux_testingMode);
                    return 1;
                }
            }

            if (!GpioPinGet(env->pinIgnition) /*&& (env->flagAcsessExitThread == SYSTEM_IS_FREE)*/) {
                LoggerInfoStatic(LOGGER, LOG_SIGN,
                                 "Попытка выхода из режима пользовательского тестирования, код 3")
                if (DeviceTesting_ExitTestMode(env)) {
                    EraGlonassUveos_DoNotingReset(env->ErGlUv);
                    LoggerInfoStatic(LOGGER, LOG_SIGN,
                                     "Автоматический выход из режима пользовательского тестирования, код 3")
                    osMutexRelease(env->mux_testingMode);
                    return 1;
                }
            }

            if (env->flagAcsessExitThread == SYSTEM_IS_DONE) {
                LoggerInfoStatic(LOGGER, LOG_SIGN,
                                 "Попытка выхода из режима пользовательского тестирования, код 2")
                if (DeviceTesting_ExitTestMode(env)) {
                    EraGlonassUveos_DoNotingReset(env->ErGlUv);
                    LoggerInfoStatic(LOGGER, LOG_SIGN,
                                     "Автоматический выход из режима пользовательского тестирования, код 2")
                    osMutexRelease(env->mux_testingMode);
                    return 1;
                }
            }

            if (env->ErGlUv->doNothing.mode == UVEOS_DO_NOTHING_DISABLED) {
                LoggerInfoStatic(LOGGER, LOG_SIGN,
                                 "Попытка выхода из режима пользовательского тестирования, код 1")
                if (DeviceTesting_ExitTestMode(env)) {
                    EraGlonassUveos_DoNotingReset(env->ErGlUv);
                    LoggerInfoStatic(LOGGER, LOG_SIGN,
                                     "Автоматический выход из режима пользовательского тестирования, код 1")

                    osMutexRelease(env->mux_testingMode);
                    return 1;
                }

            }

            SystemDelayMs(400);
        }
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления ( DeviceTesting_RunUserTests )");
        return 0;
    }
}

void DeviceTesting_ManualTestMode(tDeviceTesting *env) {
    //запускаем режим тестирования с пользователем
    DeviceTesting_MainTestingMode(env);
}

//возвращает true в случае ошибки
bool DeviceTesting_OnIgnitionWithoutGsm(tDeviceTesting *env) {
    DeviceTestsTable_TestInMode(&env->testsTable, DEVICE_TESTING_MODE_IGNITION_WITHOUT_GSM, 0);
    return DeviceTestsTable_AnyTestHasCode(&env->testsTable, DEVICE_TESTING_CODE_ERROR);
}

//возвращает true в случае ошибки
bool DeviceTesting_OnIgnitionAfterGsm(tDeviceTesting *env) {
    DeviceTestsTable_TestInMode(&env->testsTable, DEVICE_TESTING_MODE_IGNITION_AFTER_GSM, 0);
    return DeviceTestsTable_AnyTestHasCode(&env->testsTable, DEVICE_TESTING_CODE_ERROR);
}

//возвращает true в случае ошибки
bool DeviceTesting_Always(tDeviceTesting *env) {
    DeviceTestsTable_TestInMode(&env->testsTable, DEVICE_TESTING_MODE_ALWAYS, 100);

    if ((DeviceTestsTable_AnyTestHasCode(&env->testsTable, DEVICE_TESTING_CODE_ERROR)) ||
        (DeviceTestsTable_AnyTestHasCode(&env->testsTable, DEVICE_TESTING_CODE_NOT_CONNECTED)) ||
        (DeviceTestsTable_AnyTestHasCode(&env->testsTable, DEVICE_TESTING_CODE_SHORT_CIRCUIT))
            ) {
        return true;
    } else {
        return false;
    }
}

//возвращает true в случае ошибки
bool DeviceTesting_Main(tDeviceTesting *env) {
    DeviceTestsTable_TestInMode(&env->testsTable, DEVICE_TESTING_MODE_MAIN, 0);
    return DeviceTestsTable_AnyTestHasCode(&env->testsTable, DEVICE_TESTING_CODE_ERROR);
}


//возвращает true в случае ошибки
bool DeviceTesting_Periodical(tDeviceTesting *env) {
    if (!env->testsTable.currentProcessIterationsLeft) {
        return false;
    }
    --env->testsTable.currentProcessIterationsLeft;
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Режим самотестирования")
    SystemDelayMs(5000);
    DeviceTestsTable_TestInMode(&env->testsTable, DEVICE_TESTING_MODE_PERIODICAL, 1000);
    bool errors = DeviceTestsTable_AnyTestHasCode(&env->testsTable, DEVICE_TESTING_CODE_ERROR);

    if (errors) {
        for (uint16_t testIdx = 0; testIdx < env->testsTable.count; ++testIdx) {
            tTestDescriptor *test = env->testsTable.items + testIdx;

            if (test->result == DEVICE_TESTING_CODE_ERROR) {
                LoggerCnErrorStatic(LOGGER, LOG_SIGN, "Тест ")
                LoggerCnError(LOGGER, LOG_SIGN, test->name.str, test->name.length)
                LoggerErrorStatic(LOGGER, LOG_SIGN, " не пройден")
            }
        }
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Все тесты пройдены")
    }

    return errors;
}

bool DeviceTesting_UserTests(tDeviceTesting *env) {
    DeviceTesting_ChekExit(env);
    EraGlonassMsd_ClearDiagnostic(&env->tmsdDiagRes);
    //задаем режим и обновляем индикторы
    UserIndication_SetMode(env->indication, DEVICE_MODE_TESTING);

    EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.uimFailure, DeviceTesting_Buttons(env));
    DeviceTesting_ChekExit(env);
    EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.speakersFailure, DeviceTesting_TestAudioSpeaker(env));
    DeviceTesting_ChekExit(env);
    EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.ignitionLineFailure, DeviceTesting_Ignition(env));
    DeviceTesting_ChekExit(env);
    EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.micFailure, DeviceTesting_TestMic(env));
    DeviceTesting_ChekExit(env);

    //выключаем индикацию
    UserIndication_StopThread(env->indication);
    EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.statusIndicatorFailure, DeviceTesting_Indication(env));
    DeviceTesting_ChekExit(env);
    //включаем индикацию
    UserIndication_StartThread(env->indication);
    return DeviceTesting_UserGetResult(env);
}

void DeviceTesting_GetSystemTest(tDeviceTesting *env) {

    DeviceTesting_ChekExit(env);

    if (DeviceTestsTable_MakeTest(env->namedTests.firmware) == DEVICE_TESTING_CODE_PASSED) {
        LoggerInfoStatic(LOGGER, LOG_SIGN,
                         "Автоматическое тестирование целостности ПО, вызванн      ое пользователем прошло успешно")
        EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.firmwareImageCorruption, false);
        if (env->audioHintsMode == HINTS_FULL) {
            DEVTST_PLAY_SAMPLE("po_ok")
        }

        if (!env->flagAutoTestSucsess) {
            env->flagAutoTestSucsess = true;
        }
    } else {
        if (!env->flagAutoTestSucsess) {
            env->flagAutoTestSucsess = false;
        }
    }

    DeviceTesting_ChekExit(env);

    if (DeviceTestsTable_MakeTest(env->namedTests.gsm) != DEVICE_TESTING_CODE_PASSED) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка модема при автоматическом тестировании пользователем")
        if (env->audioHintsMode == HINTS_FULL) {
            DEVTST_PLAY_SAMPLE("modem_error.mp3.mp3")
        }

        EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.commModuleFailure, true);
        if (env->flagAutoTestSucsess) {
            env->flagAutoTestSucsess = false;
        }
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Автоматическое тестирование модема, вызванное пользователем прошло успешно")
        if (env->audioHintsMode == HINTS_FULL) {
            DEVTST_PLAY_SAMPLE("modem_ok.mp3")
        }

        EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.commModuleFailure, false);
    }

    DeviceTesting_ChekExit(env);

    if (DeviceTestsTable_MakeTest(env->namedTests.accel) == DEVICE_TESTING_CODE_PASSED) {
        LoggerInfoStatic(LOGGER, LOG_SIGN,
                         "Автоматическое тестирование акселеромерта, вызванное пользователем прошло успешно")
        if (env->audioHintsMode == HINTS_FULL) {
            DEVTST_PLAY_SAMPLE("acsel_ok.mp3")
        }

        EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.crashSensorFailure, false);
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка акселеромерта при автоматическом тестировании пользователем")
        if (env->audioHintsMode == HINTS_FULL) {
            DEVTST_PLAY_SAMPLE("acsel_error.mp3")
        }

        EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.crashSensorFailure, true);
        if (env->flagAutoTestSucsess) {
            env->flagAutoTestSucsess = false;
        }
    }

    DeviceTesting_ChekExit(env);

    if (DeviceTestsTable_MakeTest(env->namedTests.batteryCharge) != DEVICE_TESTING_CODE_ERROR) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Автоматическое тестирование АКБ, вызванное пользователем прошло успешно")
        if (env->audioHintsMode == HINTS_FULL) {
            DEVTST_PLAY_SAMPLE("akb_ok.mp3")
        }

        EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.batteryFailure, false);
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка АКБ при автоматическом тестировании пользователем")
        if (env->audioHintsMode == HINTS_FULL) {
            DEVTST_PLAY_SAMPLE("akb_error.mp3")
        }

        EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.batteryFailure, true);
        if (env->flagAutoTestSucsess) {
            env->flagAutoTestSucsess = false;
        }
    }

    if (
            (DeviceTestsTable_MakeTest(env->namedTests.gnssAnt) == DEVICE_TESTING_CODE_CONNECTED) ||
            (DeviceTestsTable_MakeTest(env->namedTests.gnssAnt) == DEVICE_TESTING_CODE_INPUT_ANTENA_OK)
            ) {
        LoggerInfoStatic(LOGGER, LOG_SIGN,
                         "Автоматическое тестирование антенны, вызванное пользователем прошло успешно")
        if (env->audioHintsMode == HINTS_FULL) {
            DEVTST_PLAY_SAMPLE("ant_ok.mp3")
        }

        EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.gnssAntennaFailure, false);
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка антенны при автоматическом тестировании пользователем")
        if (env->audioHintsMode == HINTS_FULL) {
            DEVTST_PLAY_SAMPLE("ant_error.mp3")
        }

        EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.gnssAntennaFailure, true);
        if (env->flagAutoTestSucsess) {
            env->flagAutoTestSucsess = false;
        }
    }

    DeviceTesting_ChekExit(env);

    env->powerManagement->powerSusystem->SpekTestPower.speakTestAcsess = true;
    if (DeviceTestsTable_MakeTest(env->namedTests.audioCodec) == DEVICE_TESTING_CODE_PASSED) {
        LoggerInfoStatic(LOGGER, LOG_SIGN,
                         "Автоматическое тестирование аудио тракта, вызванное пользователем прошло успешно")
        if (env->audioHintsMode == HINTS_FULL) {
            DEVTST_PLAY_SAMPLE("audioSub_ok.mp3")
        }

        EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.speakersFailure, false);
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка аудио тракта при автоматическом тестировании пользователем")
        if (env->audioHintsMode == HINTS_FULL) {
            DEVTST_PLAY_SAMPLE("audioSub_error.mp3")
        }

        EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.speakersFailure, true);
        if (env->flagAutoTestSucsess) {
            env->flagAutoTestSucsess = false;
        }
    }

    DeviceTesting_ChekExit(env);

    if (DeviceTestsTable_MakeTest(env->namedTests.bipConnect) == DEVICE_TESTING_CODE_CONNECTED) {
        LoggerInfoStatic(LOGGER, LOG_SIGN,
                         "Автоматическое тестирование подключения блока интерфейса пользователя выполнено успешно")
        if (env->audioHintsMode == HINTS_FULL) {
            DEVTST_PLAY_SAMPLE("bip_is_connect.mp3")
        }

        EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.uimFailure, false);
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка подключения блока интерфейса пользователя выполнено успешно")
        if (env->audioHintsMode == HINTS_FULL) {
            DEVTST_PLAY_SAMPLE("bip_is_not_connect.mp3")
        }

        EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.uimFailure, true);
        if (env->flagAutoTestSucsess) {
            env->flagAutoTestSucsess = false;
        }
    }

    DeviceTesting_ChekExit(env);

    if (env->audioHintsMode == HINTS_NORMAL) {
        DEVTST_PLAY_SAMPLE("dataStateDevIsCollections.mp3")
    }
}

void DeviceTesting_MainTestingStopMode(tDeviceTesting *env) {
    env->flagAcsessExitThread = SYSTEM_IS_DONE;
    uint32_t timer = SystemGetMs() + 20000;
    while (1) {
        if (timer < SystemGetMs()) {
//            return;
        }
        SystemDelayMs(5000);
    }
}

void DeviceTesting_RunInternalTests(tDeviceTesting *env) {
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Выполняются внутренние тесты")
    DeviceTesting_GetSystemTest(env);
}

void DeviceTesting_AudioReportAsInternalTests(tDeviceTesting *env, bool userTestsOk) {
#if (AURUS_CAR_UI == 1)
    if (env->flagAutoTestSucsess) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Внутренние тесты завершены успешно")
        DEVTST_PLAY_SAMPLE("notError.mp3")
    } else  {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка внутреннего теста")
        DEVTST_PLAY_SAMPLE("isError.mp3")
    }

#endif
#if (AURUS_CAR_UI == 0)
    if (env->flagAutoTestSucsess) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Внутренние тесты завершены успешно")
    }
    DeviceTesting_ChekExit(env);
    if (userTestsOk && !env->flagAutoTestSucsess) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка внутреннего теста")
        DEVTST_PLAY_SAMPLE("test_full_error.mp3")
    }
#endif

}

bool DeviceTesting_RunTestCall(tDeviceTesting *env) {

    bool result = false;
    UserInputButtonWatcher_Clear(env->UserInputButtonWatcher);
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Начало тестирования вызова с передачей данных с результатами проверки")

#if (AURUS_CAR_UI == 1)
    DEVTST_PLAY_SAMPLE("testCoolUp.mp3")
#endif
#if (AURUS_CAR_UI == 0)
    DEVTST_PLAY_SAMPLE("ecall_test.mp3")
#endif

    env->flagAcsessExitThread = SYSTEM_IS_BUSY;
    result = DeviceTesting_Ecall(env);
    env->flagAcsessExitThread = SYSTEM_IS_FREE;
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Тестовый вызов пройден")
    DeviceTesting_ChekExit(env);


#if (AURUS_CAR_UI == 0)
    DeviceTesting_GetEcalRes(env);
#endif


    if (env->ecallAddStatusRes == 1) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Выполняются вызов оператору 112")
        env->ErGlUv->currentMsd->msd.MSD_Data.msgId = 1;
        env->flagAcsessExitThread = SYSTEM_IS_BUSY;
        if (EraGlonassUveos_ManualEmergencyCall(env->ErGlUv) == ERA_GLONASS_UVEOS_CALL_SUCCESS) {
            result = true;
        }
        env->flagAcsessExitThread = SYSTEM_IS_FREE;
    }

#if (AURUS_CAR_UI == 1)
    if(result == true){
        DEVTST_PLAY_SAMPLE("testCoolDoneTestingDone.mp3")
    }
#endif

    return result;
}

void DeviceTesting_MainTestingModeExitIsTimeOut(tDeviceTesting *env) {
    if (
            env->ErGlUv->timings.lastTestCall &&
            (env->ErGlUv->timings.lastTestCall > SystemGetMs())
            ) {
        env->queryUDSState->state = QUERY_ERROR;
        DEVTST_PLAY_SAMPLE("tets_call_timeuot.mp3");
        DeviceTesting_MainTestingStopMode(env);
    }
}

bool DeviceTesting_GetNetworkReg(tGsmWithGnss *env) {
    if (!GsmWithGnss_WaitNetworkRegistration(env, 1500)) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть или сим-чип отсутствует, попытка регистрации код 6");
        if (GsmWithGnss_NetworkSetStateInnaterups(env, 4, 20000) == AT_OK) {
            return true;
            LoggerTraceStatic(LOGGER, LOG_SIGN, "Сеть присутствует")
        } else {
            LoggerErrorStatic(LOGGER, LOG_SIGN, "нет сети");
            return false;
        }
    } else {
        return true;
        LoggerErrorStatic(LOGGER, LOG_SIGN, "Регистрация в сети присутствует");
    }
}

bool DeviceTesting_TestingECool(tDeviceTesting *env) {
    UserIndication_SetMode(env->indication, DEVICE_MODE_TESTING);
    DeviceTesting_RunInternalTests(env);
    DeviceTesting_ChekExit(env);
    DeviceTesting_AudioReportAsInternalTests(env, true);
    DeviceTesting_ChekExit(env);

    bool res = DeviceTesting_RunTestCall(env);

    DeviceTesting_ChekExit(env);
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Голосовой отчёт по тестовому вызову выполнен")
    return res;
}

void DeviceTesting_MainTestingMode(tDeviceTesting *env) {
//    UserIndication_Uiu(env->indication, UIU_OFF);

    UserButtons_Clear(env->input);
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Начало пользовательского тестирования")


    if (env->queryUDSState->source == REG_TO_NETWORK) {
        UserIndication_SetMode(env->indication, DEVICE_MODE_TESTING);
//        AtGsm_OperatorSelectionDeregister(&env->gsmWithGnss->gsmAt);
//        SystemDelayMs(500);
//        AtGsm_OperatorSelectionAutomatic(&env->gsmWithGnss->gsmAt);
//        bool regRes = false;
//        uint32_t tmt = SystemGetMs()+180000;
//        while ( (regRes == false) || (tmt > SystemGetMs()) ) {
//            regRes = true;//GsmWithGnss_WaitNetworkRegistration(env->gsmWithGnss, 1500);
//            SystemDelayMs(1000);
//        }

        bool regRes = true;
        if (regRes) {
            env->queryUDSState->state = QUERY_DONE;
        } else {
            env->queryUDSState->state = QUERY_ERROR;
        }

        DeviceTesting_MainTestingStopMode(env);
        return;
    }

    if (env->queryUDSState->source == REG_BOARD_VOLTAGE_CALIBRATION) {
        UserIndication_SetMode(env->indication, DEVICE_MODE_TESTING);
        bool calibRes = Adcs_SetCalibBoardVoltage(
                env->powerManagement->powerSusystem->boardPower.boardVoltage,
                env->boardVoltCalbCof
        );

        if (calibRes) {
            EraGlonassUveosDumper_ForceDump(env->ErGlUv->dumper);
            env->queryUDSState->state = QUERY_DONE;
        } else {
            env->queryUDSState->state = QUERY_ERROR;
        }
        DeviceTesting_MainTestingStopMode(env);
        return;
    }

    if (env->queryUDSState->source == LEDS_TEST) {
        eAudioHintsMode audioHintsModeTmp = env->audioHintsMode;
        env->audioHintsMode = HINTS_MINIMAL;

        UserIndication_StopThread(env->indication);
        env->fl_oneTestResult = DeviceTesting_Indication(env);
        UserIndication_StartThread(env->indication);

        if (env->fl_oneTestResult == false) {
            env->queryUDSState->state = QUERY_DONE;
        } else {
            env->queryUDSState->state = QUERY_ERROR;
        }

        env->audioHintsMode = audioHintsModeTmp;
        DeviceTesting_MainTestingStopMode(env);

        return;
    }

    if (env->queryUDSState->source == SPEAK_MICR_TEST) {
        DEVTST_PLAY_SAMPLE("test_dinam_one.mp3")
        //задаем режим и обновляем индикторы
        UserIndication_SetMode(env->indication, DEVICE_MODE_TESTING);
        env->fl_oneTestResult = DeviceTesting_TestMic(env);

        if (env->fl_oneTestResult == false) {
            env->queryUDSState->state = QUERY_DONE;
        } else {
            env->queryUDSState->state = QUERY_ERROR;
        }
        DeviceTesting_MainTestingStopMode(env);

        return;
    }

    if (env->queryUDSState->source == ECALL_TEST) {

        DeviceTesting_MainTestingModeExitIsTimeOut(env);
        env->audioHintsMode = HINTS_NORMAL;

        bool res = DeviceTesting_TestingECool(env);
        env->audioHintsMode = HINTS_FULL;
        if (res == true) {
            env->queryUDSState->state = QUERY_DONE;
        } else {
            env->queryUDSState->state = QUERY_ERROR;
        }
        DeviceTesting_MainTestingStopMode(env);
        return;
    }

    if (env->queryUDSState->source == ECALL_NOT_REG_TEST) {
        DeviceTesting_MainTestingModeExitIsTimeOut(env);
        env->audioHintsMode = HINTS_NORMAL;
        UserIndication_SetMode(env->indication, DEVICE_MODE_TESTING);
        DeviceTesting_RunInternalTests(env);
        DeviceTesting_ChekExit(env);
        DeviceTesting_AudioReportAsInternalTests(env, true);

        DeviceTesting_ChekExit(env);
        DEVTST_PLAY_SAMPLE("not_reg_to_net.mp3")
        bool res = DeviceTesting_RunTestCall(env);
        DeviceTesting_ChekExit(env);
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Голосовой отчёт по тестовому вызову выполнен")
        env->audioHintsMode = HINTS_FULL;
        if (res == true) {
            env->queryUDSState->state = QUERY_DONE;
        } else {
            env->queryUDSState->state = QUERY_ERROR;
        }
        DeviceTesting_MainTestingStopMode(env);
        return;
    }

    if (env->queryUDSState->source == FULL_TESTS) {
        bool userTestsOk = DeviceTesting_UserTests(env);
        DeviceTesting_RunInternalTests(env);
        DeviceTesting_ChekExit(env);
        DeviceTesting_AudioReportAsInternalTests(env, userTestsOk);

        DeviceTesting_ChekExit(env);
        if (userTestsOk && env->flagAutoTestSucsess) {
            if (!DeviceTesting_Main(env)) {
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Все тесты пройдены успешно")
                DEVTST_PLAY_SAMPLE("test_full_ok.mp3")
            }
        }

        DeviceTesting_ChekExit(env);
        DeviceTesting_RunTestCall(env);
        DeviceTesting_ChekExit(env);
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Голосовой отчёт по тестовому вызову выполнен")

        DeviceTesting_MainTestingStopMode(env);
    }

    if (env->queryUDSState->source == INTERNAL_ONE_TEST) {

        eAudioHintsMode audioHintsMode = env->audioHintsMode;
        env->audioHintsMode = HINTS_NONE;
        DeviceTesting_RunInternalTests(env);

        DeviceTesting_ChekExit(env);
        DeviceTesting_AudioReportAsInternalTests(env, NULL);
        DeviceTesting_ChekExit(env);

        env->fl_oneTestResult = DeviceTesting_TestSpeakMic(env);

        if ((env->flagAutoTestSucsess)&&(!env->fl_oneTestResult)) {
            if (!DeviceTesting_Main(env)) {
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Все тесты пройдены успешно")
            }
        }

        if(env->gsmWithGnss->gnss.currentRmc.status != 'A') {
            DEVTST_PLAY_SAMPLE("satelitNone.mp3")
        }

        DeviceTesting_RunTestCall(env);
        DeviceTesting_ChekExit(env);
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Голосовой отчёт по тестовому вызову выполнен")

        env->audioHintsMode = audioHintsMode;
        DeviceTesting_MainTestingStopMode(env);
    }
}