//
// Created by cfif on 21.05.23.
//

#ifdef UVEOS_ADD_TELEMATICA

#include <egts.h>
#include <SystemDelayInterface.h>
#include <Nmea0183Parser.h>
#include <time.h>
#include <egtsWorker.h>
#include <AsciiStringAssmeblingUtils.h>
#include <Rtc.h>
#include <stdlib.h>
#include "EgtsProcessing.h"
#include "stddef.h"
#include "AtGsm_GetTime.h"
#include "EgtsInputCommands.h"
#include "EgtsOutputCommands.h"
#include "egtsWorkerExt.h"
#include "LoggerToSerialPort.h"
#include "string.h"
#include "EgtsTeledataPoint.h"
//#include "GsmWithGnss_Info.h"
#include "Network.h"
#include "AtGsm_NetworkRegistrationStatus.h"
#include "egts.h"
#include "AtGsmOperatorSelection.h"
#include "AtGsmTelitLe910_DefinePdpContext.h"


#define LOG_SIGN "EGTS"
#define LOGGER &env->slog->logger

bool onOffTelematica(tEgtsProcessing *env, bool *oneOn, bool *oneOff, char *task) {

    if (env->store->runtime.EGTS_FLEET_ON == false) {

        if (*oneOff) {
            *oneOn = true;
            *oneOff = false;
            LoggerStrFormatInfo(LOGGER, LOG_SIGN, "%s - отключена", task);
        }

        SystemDelayMs(1000);

        return true;

    } else {
        if (*oneOn) {
            *oneOn = false;
            *oneOff = true;
            LoggerStrFormatInfo(LOGGER, LOG_SIGN, "%s - включена", task);
        }
    }

    return false;

}

void EgtsProcessing_TransmitterTaskMain(tEgtsProcessing *env);

void EgtsProcessing_ListenerTask(tEgtsProcessing *env);

char *sendLogHex(tEgtsProcessing *env, uint8_t *data, size_t size) {

    memset(env->hexString, 0, sizeof(env->hexString));
    size_t len = 0;
    vAsciiStringAddBytesAsHex(env->hexString, &len, data, size);

    LoggerStrInfo(LOGGER, LOG_SIGN, env->hexString, strlen(env->hexString));

    return env->hexString;

}

size_t EgtsProcessing_WorkerRead(tEgtsProcessing *env, uint8_t *data, size_t size) {
    if (env->socketId != SOCKET_WRONG_CONTEXT) {
        return SocketInterface_read(&env->gsm->socketGsm.socketIO, env->socketId, data, size, 2000);
    }

    return 0;
}

uint8_t findDelimiter(tString32 *address, char ch) {

    for (uint8_t i = 0; i < address->length; ++i) {
        if (address->data[i] == ch)
            return i;
    }

    return 0;
}

_Noreturn void Processing_URC(tEgtsProcessing *env) {
    bool oneOn = true;
    bool oneOff = true;

    for (;;) {

        if (onOffTelematica(env, &oneOn, &oneOff, "Задача URC"))
            continue;

        if (osMutexAcquire(env->gsm->gsmAt.access, 5000) == osOK) {

            while (AtCmdReceiveNextLine(&env->gsm->gsmAt, 150) == AT_OK) {
                AtCmdProcessUnresolvedLine(&env->gsm->gsmAt);
            }

            osMutexRelease(env->gsm->gsmAt.access);

        } else {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа (Processing_URC)")
        }
        SystemDelayMs(40);
    }

}

const char LOG_TASK_GSM_SOCKET[] = "GSM SOCKET";

void EgtsProcessing_Init(
        tEgtsProcessing *env,
        tDeviceStorage *deviceStorage,
        tGpioPin *ignition,
        tGsmWithGnss *gsm,
        tRtcIO *rtcIO,
        tLoggerToSerialPort *slog
) {
    env->egtsEnv.readData = (void *) EgtsProcessing_WorkerRead;
    env->egtsEnv.readDataEnv = env;
    env->egtsEnv.workingBuffer = env->wb;
    env->egtsEnv.workingBufferLimit = sizeof(env->wb);
    env->egtsEnv.workingBufferLength = 0;
    env->gsm = gsm;
    env->slog = slog;
    //env->ebuReady = false;

    env->ignition = ignition;

    env->rtc = rtcIO;

    env->isEnableTelematicaSendPoints = false;
    env->rebootFirmware = false;
    env->egtsPacketId = 0;

    env->egtsCanEnv.isEbuData = false;

    env->fl_firstStartTimeUpdateEBU = false;

#ifdef UVEOS_ADD_TELEMATICA
    env->deviceTeledataStorageData = &deviceStorage->nvm.deviceTeledataStorageData;
#endif

    env->store = deviceStorage;

    env->isOneEBU = false;

    EgtsProcessing_Default_SendSensorsDig(env);
    EgtsProcessing_Default_SendSensorsAn(env);

    env->egtsTeledataAdditionalData.queue = osMessageQueueNew(TELEDATA_QUEUE_SIZE, sizeof(tEgtsTeledata), NULL);
    env->egtsTeledataAdditionalData.queueEvent = osMessageQueueNew(TELEDATA_QUEUE_SIZE, 1, NULL);
    env->egtsCommandConfirmationAdditionalData.queue = osMessageQueueNew(COMMAND_QUEUE_SIZE, sizeof(tEgtsCommand),
                                                                         NULL);

    env->deviceTeledataStorageData->telematica.EGTS_SERVER_ADDRESS.data[env->deviceTeledataStorageData->telematica.EGTS_SERVER_ADDRESS.length] = '\0';
    uint8_t pos = findDelimiter(&env->deviceTeledataStorageData->telematica.EGTS_SERVER_ADDRESS, ':');
    String32Copy(&env->srvAddr,
                 env->deviceTeledataStorageData->telematica.EGTS_SERVER_ADDRESS.data,
                 pos);
    env->srvPort = atoi(&env->deviceTeledataStorageData->telematica.EGTS_SERVER_ADDRESS.data[pos + 1]);

    LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Установка сервера: %s",
                        env->deviceTeledataStorageData->telematica.EGTS_SERVER_ADDRESS.data);

    SocketSocketGsm_Init(&env->gsm->socketGsm, &env->gsm->gsmAt,
                         &env->srvAddr, env->srvPort,
                         env->gsm->gsmAt.access);

    env->gsm->socketGsm.logger = &slog->logger;
    env->gsm->socketGsm.loggerTaskName = (char *) LOG_TASK_GSM_SOCKET;

//    InitThreadBlock(env->T_processing_Network, "Network", osPriorityNormal);
//    InitThreadBlock(env->T_processing_ebu, "EgtsPrcEbu", osPriorityNormal);

    InitThreadBlock(env->T_processing_input_command, "EgtsPrcInputCom", osPriorityNormal);
    InitThreadBlock(env->T_processing_event_teledata, "EgtsPrcEventTel", osPriorityNormal);
    InitThreadBlock(env->T_processing_teledata, "EgtsPrcTeledata", osPriorityNormal);
    InitThreadBlock(env->T_processing_main, "EgtsPrcMain", osPriorityNormal);
    InitThreadBlock(env->T_listener, "EgtsListner", osPriorityNormal);
    InitThreadBlock(env->T_processing_urc, "Urc", osPriorityNormal);
}

void EgtsProcessing_Start(tEgtsProcessing *env) {

//    ThreadBlock_Start(env->T_processing_Network, env, EgtsProcessing_InfoTask);
//    ThreadBlock_Start(env->T_processing_ebu, env, EgtsProcessing_TransmitterTaskEbu);

    ThreadBlock_Start(env->T_processing_input_command, env, EgtsProcessing_TransmitterTaskInputCommand);
    ThreadBlock_Start(env->T_processing_event_teledata, env, EgtsProcessing_EventTaskTeledata);
    ThreadBlock_Start(env->T_processing_teledata, env, EgtsProcessing_TransmitterTaskTeledata);
    ThreadBlock_Start(env->T_processing_main, env, EgtsProcessing_TransmitterTaskMain);
    ThreadBlock_Start(env->T_listener, env, EgtsProcessing_ListenerTask);
    ThreadBlock_Start(env->T_processing_urc, env, Processing_URC);
}

void EgtsProcessingCloseConnection(tEgtsProcessing *env) {
    SocketInterface_close(&env->gsm->socketGsm.socketIO, env->socketId);
}

bool EgtsProcessingSend(tEgtsProcessing *env, uint8_t *egtsRaw, uint16_t egtsRawLength,
                        eEgtsSendWait wait, volatile bool *wait1, volatile bool *wait2) {


    uint32_t retry = env->deviceTeledataStorageData->telematica.EGTS_SERVER_PACKET_RETRANSMIT_ATTEMPTS;

    while (retry) {

        bool result = true;

        if (SocketInterface_send(&env->gsm->socketGsm.socketIO, env->socketId, egtsRaw, egtsRawLength,
                                 defaultSocketTransmiteTimeout) != egtsRawLength) {
            result = false;
        }

        if (!result) {
            LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Ошибка отправки пакета (ошибка сокета)");
            return false;
        }

        if (wait == EGTS_WAIT_0)
            return result;

        uint32_t timeEnd = SystemGetMs() + env->deviceTeledataStorageData->telematica.EGTS_SERVER_PACKET_TOUT * 1000;

        while (timeEnd > SystemGetMs()) {

            if (wait == EGTS_WAIT_1) {
                if (*wait1) {
                    return true;
                }
            }

            if (wait == EGTS_WAIT_2) {
                if ((*wait1) && (*wait2)) {
                    return true;
                }
            }

            SystemDelayMs(1);
        }

        --retry;

        if (!isAuth(env)) {
            LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Ошибка отправки пакета (ошибка аутентификации)");
            return false;
        }

        LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Повторная отправка, осталось попыток: %d", retry);
    }

    return false;
}


bool EgtsProcessing_SendResponse(tEgtsProcessing *env,
                                 eEgtsServiceId sourceServiceId,
                                 eEgtsServiceId recipientServiceId,
                                 uint8_t srvFlags,
                                 uint8_t rst,
                                 uint16_t crn) {
    uint8_t egtsRaw[256];
    memset(egtsRaw, 0, sizeof(egtsRaw));

    if (env->socketId == SOCKET_WRONG_CONTEXT) {
        return false;
    }

    time_t timestamp;
    RtcGet(env->gsm->Rtc, &timestamp);

    tEgtsRecordResponseData args = {
            .CRN = crn,
            .RST = rst,
    };

    ++env->egtsPacketId;
    uint16_t packetResponseLength = vEgtsPackTransport(
            env->egtsEnv.header.packetId,
            env->egtsPacketId,
            egtsRaw,
            srvFlags,
            EGTS_PT_RESPONSE,
            sourceServiceId,
            recipientServiceId,
            timestamp,
            EGTS_SR_RECORD_RESPONSE,
            vEgtsPackResponseGen,
            &args
    );

    LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Отправка пакета подтверждения:");
    sendLogHex(env, egtsRaw, packetResponseLength);

    EgtsProcessingSend(env, egtsRaw, packetResponseLength, EGTS_WAIT_0, NULL, NULL);

    return true;
}

uint8_t EgtsProcessingOpenConnection(tEgtsProcessing *env) {
/*
    env->socketId = SocketInterface_open(
            &env->gsm->socketIO,
            eSocketType_TCP,
            env->clientType,
            env->srvAddr.data,
            env->srvAddr.length,
            env->srvPort,
            defaultSocketOpenTimeout
    );
*/
    env->socketId = SocketInterface_openStatic(&env->gsm->socketGsm.socketIO, eSocketType_TCP, env->srvAddr.data,
                                               env->srvPort, defaultSocketOpenTimeout);

    if (env->socketId == SOCKET_WRONG_CONTEXT) {
        return SOCKET_WRONG_CONTEXT;
    }

    return env->socketId;
}

bool isAuth(tEgtsProcessing *env) {

    if ((env->egtsIdentityAdditionalData.isReceivedResponse) &&
        (env->egtsIdentityAdditionalData.isReceivedResultCode)) {
        if (env->egtsIdentityAdditionalData.resultCodeAuth == 0) {
            return true;
        }
    }

    return false;
}


bool WaitNetworkRegistration(tEgtsProcessing *env, uint16_t timeReg) {

    uint32_t timeEnd = SystemGetMs() + timeReg;

    tAtGsm_NetworkRegistrationReportMode mode;
    tAtGsm_NetworkRegistrationState state;

    while (timeEnd > SystemGetMs()) {

        AtCommandResult result = AT_TIMEOUT;
        if (osMutexAcquire(env->gsm->gsmAt.access, 2000) == osOK) {
            result = AtGsm_NetworkRegistrationStatus(&env->gsm->gsmAt, &mode, &state);
            osMutexRelease(env->gsm->gsmAt.access);
        }

        if (result) {
            if (state == AT_NETWORK_REGISTRATION_STATE_REGISTERED_HOME ||
                state == AT_NETWORK_REGISTRATION_STATE_REGISTERED_ROAMING) {

                LoggerInfoStatic(LOGGER, LOG_SIGN, "Получена регистрация")

                return true;
            }
        }

        if (env->store->runtime.EGTS_FLEET_ON == false) {
            return AT_TIMEOUT;
        }

        SystemDelayMs(100);
    }

    return false;
}

bool NetworkRequire(tEgtsProcessing *env) {
    bool result = false;

    if (!WaitNetworkRegistration(env, 2000)) {

        if (env->store->runtime.EGTS_FLEET_ON == false) {
            return false;
        }

        LoggerInfoStatic(LOGGER, LOG_SIGN, "Включение регистрации в сети");
        for (uint8_t i = 0; i < 3; ++i) {

            if (osMutexAcquire(env->gsm->gsmAt.access, 2000) == osOK) {
                AtGsm_OperatorSelectionAutomatic(&env->gsm->gsmAt);
                osMutexRelease(env->gsm->gsmAt.access);
            }

            if (env->store->runtime.EGTS_FLEET_ON == false) {
                return false;
            }

            SystemDelayMs(100);
        }
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ждем сеть...");
        if (WaitNetworkRegistration(env, 2000)) {
            result = true;
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Регистрация в сети получена");
        } else {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Регистрация в сети не получена");
        }

    } else {
        result = true;
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Регистрация в сети присутствует");
    }


    return result;
}

bool Gsm_ActivatePdp(tEgtsProcessing *env) {
    AtCommandResult res = AT_ERROR;
    if (osMutexAcquire(env->gsm->gsmAt.access, 5000) == osOK) {

        res = AtGsmTelitLe910_PdpActivate(&env->gsm->gsmAt, 1);

        osMutexRelease(env->gsm->gsmAt.access);
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа (Gsm_ActivatePdp)")
    }
    return res == AT_OK;
}

bool Gsm_ActivateApn(tEgtsProcessing *env) {
    AtCommandResult res = AT_ERROR;
    if (osMutexAcquire(env->gsm->gsmAt.access, 5000) == osOK) {

        res = AtGsmTelitLe910_DefinePdpContext(&env->gsm->gsmAt, 1, AtGsmTelitLe910_PdpType_IP,
                                               env->deviceTeledataStorageData->telematica.EGTS_GPRS_APN.data,
                                               env->deviceTeledataStorageData->telematica.EGTS_GPRS_APN.length);

        osMutexRelease(env->gsm->gsmAt.access);
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа (Gsm_ActivateApn)")
    }

    return res == AT_OK;
}

bool Gsm_SetProfileERA(tEgtsProcessing *env) {
    AtCommandResult res = AT_ERROR;
    if (osMutexAcquire(env->gsm->gsmAt.access, 5000) == osOK) {

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

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

        osMutexRelease(env->gsm->gsmAt.access);
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа (Gsm_SetProfileERA)")
    }

    return res == AT_OK;
}

bool Gsm_SetProfileINTERNET(tEgtsProcessing *env) {
    AtCommandResult res = AT_ERROR;
    if (osMutexAcquire(env->gsm->gsmAt.access, 5000) == osOK) {

#ifdef UVEOS_ADD_TELEMATICA
        AtGsmTelitLe910_SimProfileSelect(&env->gsm->gsmAt,
                                         &env->store->nvm.deviceTeledataStorageData.telematica.EGTS_PROFILE_SIM_INTERNET);
#endif

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

        osMutexRelease(env->gsm->gsmAt.access);
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа (Gsm_SetProfileINTERNET)")
    }

    return res == AT_OK;
}

_Noreturn void EgtsProcessing_TransmitterTaskMain(tEgtsProcessing *env) {

    bool isFirstStart = true;
    uint32_t timeTeleOff = 0;
    uint8_t stepAuth = 1;

    for (;;) {
        if (env->deviceTeledataStorageData->telematica.EGTS_SERVER_ADDRESS.length == 0) {
            if (timeTeleOff < SystemGetMs()) {
                timeTeleOff = SystemGetMs() + 10000;
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Не установлен адрес сервера телематики")
            }
            SystemDelayMs(1000);
            continue;
        }

        if (env->deviceTeledataStorageData->telematica.EGTS_GPRS_APN.length == 0) {
            if (timeTeleOff < SystemGetMs()) {
                timeTeleOff = SystemGetMs() + 10000;
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Не установлен APN")
            }
            SystemDelayMs(1000);
            continue;
        }

        break;
    }

    uint8_t socketId = SOCKET_WRONG_CONTEXT;
    eSocketStatus socketStatus = eSocketStatus_Disconnected;

    uint32_t timeOutCheckConnect = 0;
    uint32_t timeIsNetworkRegistration = 0;
    uint32_t timeOutCheckNav = AURUS_CHECK_NAV;
    uint8_t stepCheckNav = 3;

    bool isRegistration;

    while (1) {


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

            env->store->runtime.telematicaCloseConnect = false;

            if (!isFirstStart) {
                isFirstStart = true;

                LoggerInfoStatic(LOGGER, LOG_SIGN, "Настройка телематики")

                Gsm_SetProfileINTERNET(env);

                Gsm_ActivateApn(env);
                Gsm_ActivatePdp(env);

            }

            if (env->deviceTeledataStorageData->telematica.telematicaIsActive) {
                env->isEnableTelematicaSendPoints = true;
            } else {
                env->isEnableTelematicaSendPoints = env->deviceTeledataStorageData->telematica.EGTS_SERVER_ENABLE_TELEMATICA;
            }

        } else {

            if (isFirstStart) {
                isFirstStart = false;
                EgtsProcessingCloseConnection(env);
                LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Соединение с сервером разорвано, ИД: %d", socketId);

                Gsm_SetProfileERA(env);
            }

            env->egtsIdentityAdditionalData.isReceivedResultCode = false;

            env->egtsEnv.workingBufferLength = 0;
            env->isEnableTelematicaSendPoints = false;
            env->fl_firstStartTimeUpdateEBU = false;

            env->store->runtime.telematicaCloseConnect = true;

            if (timeTeleOff < SystemGetMs()) {
                timeTeleOff = SystemGetMs() + 10000;
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Телематика отключена")
            }

            SystemDelayMs(100);
            continue;
        }


        //начало ---------------------------------Установка соединения с сервером---------------------------------------
        //начало ---------------------------------Установка соединения с сервером---------------------------------------
        //начало ---------------------------------Установка соединения с сервером---------------------------------------


        if ((socketStatus == eSocketStatus_Disconnected) || (socketId == SOCKET_WRONG_CONTEXT)) {
            uint32_t retry = env->deviceTeledataStorageData->telematica.EGTS_SERVER_CHECK_IN_ATTEMPTS;

            while (retry) {

                if (env->store->runtime.EGTS_FLEET_ON == false) {
                    break;
                }

                if (NetworkRequire(env)) {
                    isRegistration = true;
                } else {
                    isRegistration = false;
                }

                if (!isRegistration) {
                    LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Нет регистрации в сети");
                    continue;
                }

                EgtsProcessingCloseConnection(env);
                EgtsResetBuffer(&env->egtsEnv);
                LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Установка соединения с сервером");
                socketId = EgtsProcessingOpenConnection(env);
                if (socketId != SOCKET_WRONG_CONTEXT) {
                    stepAuth = 1;
                    LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Соединение с сервером установлено, ИД: %d", socketId);
                    SystemDelayMs(500);
                    socketStatus = SocketInterface_status(&env->gsm->socketGsm.socketIO, socketId);
                    if (socketStatus == eSocketStatus_Connected) {

                        LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Аутентификация на сервере");

                        if (EgtsProcessing_SendAuth(env)) {

                            if (!env->isOneEBU) {
                                env->isOneEBU = true;
                                env->firstStartTimeUpdateEBU = SystemGetMs() + 35000;
                                env->fl_firstStartTimeUpdateEBU = true;
                            }

                            addTeledataQueueEvent(env, EVENT_TCP_CONNECTION_START);

                            break;
                        }
                    } else {
                        LoggerStrInfoStatic(LOGGER, LOG_SIGN,
                                            "Аутентификация на сервере невозможна. Соединение разорвано");
                    }
                } else {

                    LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Ошибка соединения с сервером, код %d",
                                        env->gsm->codeResultOpen);


                    if ((env->gsm->codeResultOpen == 15) || (env->gsm->codeResultOpen == 10)) {

                        if (stepAuth == 0) {

                            stepAuth = 1;

//                            if (env->gsm->codeResultOpen == 15) {
//                                LoggerStrInfoStatic(LOGGER, LOG_SIGN,
//                                                    "Ошибка рукопожатия, переход на альтернативный сервер");
//                            }
//
//                            if (env->gsm->codeResultOpen == 10) {
//                                LoggerStrInfoStatic(LOGGER, LOG_SIGN,
//                                                    "Ошибка открытия сеанса, переход на альтернативный сервер");
//                            }

//                            if (env->gsm->codeResultOpen == 20) {
//                                LoggerStrInfoStatic(LOGGER, LOG_SIGN,
//                                                    "Ошибка выполнения команды, переход на альтернативный сервер");
//                            }

//                            changeServer(env, 1);

                        } else {

                            --stepAuth;

//                            if (env->gsm->codeResultOpen == 15) {
//                                LoggerFormatInfo(LOGGER, LOG_SIGN,
//                                                 "Ошибка рукопожатия, переход на альтернативный сервер через %u попыток",
//                                                 stepAuth);
//                            }
//
//                            if (env->gsm->codeResultOpen == 10) {
//                                LoggerFormatInfo(LOGGER, LOG_SIGN,
//                                                 "Ошибка открытия сеанса, переход на альтернативный сервер через %u попыток",
//                                                 stepAuth);
//                            }

//                            if (env->gsm->codeResultOpen == 20) {
//                                LoggerFormatInfo(LOGGER, LOG_SIGN,
//                                                 "Ошибка выполнения команды, переход на альтернативный сервер через %u попыток",
//                                                 stepAuth);
//                            }

                        }

                        continue;

                    } else {
                        stepAuth = 1;
                    }


                    LoggerStrFormatInfo(LOGGER, LOG_SIGN,
                                        "Соединение с сервером не установлено, повторная попытка соединения, через %d сек",
                                        env->deviceTeledataStorageData->telematica.EGTS_SERVER_CHECK_IN_PERIOD);

                    for (uint32_t i = 0;
                         i < env->deviceTeledataStorageData->telematica.EGTS_SERVER_CHECK_IN_PERIOD; ++i) {

                        if (env->store->runtime.EGTS_FLEET_ON == false) {
                            break;
                        }

                        SystemDelayMs(1000);
                    }


                }

                --retry;

                LoggerStrFormatInfo(LOGGER, LOG_SIGN,
                                    "Повторная попытка установки соединения с сервером, осталось попыток: %d", retry);
            }

            if (retry == 0) {


            }

        }
        //конец ---------------------------------Установка соединения с сервером---------------------------------------
        //конец ---------------------------------Установка соединения с сервером---------------------------------------
        //конец ---------------------------------Установка соединения с сервером---------------------------------------

        if (env->store->runtime.EGTS_FLEET_ON == false) {
            continue;
        }

        //начало ---------------------------------Проверка соединения---------------------------------------------------
        //начало ---------------------------------Проверка соединения---------------------------------------------------
        //начало ---------------------------------Проверка соединения---------------------------------------------------
        if ((timeOutCheckConnect < SystemGetMs()) || (env->gsm->isDisconnect)) {

            if (env->gsm->isDisconnect) {
                env->gsm->isDisconnect = false;
                LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Обнаружен разрыв соединения")
            }


            timeOutCheckConnect = SystemGetMs() + AURUS_CHECK_CONNECT;

            if (socketId != SOCKET_WRONG_CONTEXT) {

                socketStatus = SocketInterface_status(&env->gsm->socketGsm.socketIO, socketId);

                if (socketStatus == eSocketStatus_Disconnected) {
                    env->egtsIdentityAdditionalData.isReceivedResultCode = false;
                    LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Соединение с сервером разорвано, ИД: %d", socketId);
                    EgtsProcessingCloseConnection(env);
                }

            }

        }
        //конец ---------------------------------Проверка соединения---------------------------------------------------
        //конец ---------------------------------Проверка соединения---------------------------------------------------
        //конец ---------------------------------Проверка соединения---------------------------------------------------

        SystemDelayMs(1000);
    }

}

void EgtsProcessing_Worker(tEgtsProcessing *env) {
    bool oneOn = true;
    bool oneOff = true;
    uint8_t stepAuth = 1;

    for (;;) {

        if (onOffTelematica(env, &oneOn, &oneOff, "Задача драйвер протокола"))
            continue;

        EgtsCompleteResult *result = EgtsCompleteTransportExt(&env->egtsEnv);

        if ((result->completeResult == EGTS_COMPLETE_ERR_VER) ||
            (result->completeResult == EGTS_COMPLETE_HEADER_ERR_CRC) ||
            (result->completeResult == EGTS_COMPLETE_BODY_ERR_CRC) ||
            (result->completeResult == EGTS_COMPLETE_ERR_OVERFLOW)) {

            LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Ошибка в пакете ЕГТС");


            if (result->completeResult == EGTS_COMPLETE_ERR_OVERFLOW) {
                LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Переполнение приемного буфера");
            }
            if (result->completeResult == EGTS_COMPLETE_ERR_VER) {
                LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Ошибка номера версии в пакете ЕГТС");
            }

            if (result->completeResult == EGTS_COMPLETE_HEADER_ERR_CRC) {
                LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Ошибка CRC заголовка в пакете ЕГТС");

                LoggerFormatInfo(LOGGER, LOG_SIGN, "CRC CALC = 0x%02x, CRC RECEIVED = 0x%02x", result->calcHeaderCrc,
                                 result->receivedHeaderCrc);

                char bufLogHexString[40];
                memset(bufLogHexString, 0, sizeof(bufLogHexString));
                size_t lenLog = 0;
                vAsciiStringAddBytesAsHex(bufLogHexString, &lenLog, (uint8_t *) env->wb, 11);
                LoggerFormatInfo(LOGGER, LOG_SIGN, "HEADER (%d): %s", 11, bufLogHexString);

            }

            if (result->completeResult == EGTS_COMPLETE_BODY_ERR_CRC) {
                LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Ошибка CRC тела в пакете ЕГТС");

                LoggerFormatInfo(LOGGER, LOG_SIGN, "CRC CALC = 0x%04x, CRC RECEIVED = 0x%04x", result->calcBodyCrc,
                                 result->receivedBodyCrc);

//                char bufLogHexString[400];
//                memset(bufLogHexString, 0, sizeof(bufLogHexString));
//                size_t lenLog = 0;
//                vAsciiStringAddBytesAsHex(bufLogHexString, &lenLog, (uint8_t *) env->wb, result->fullLength);
//                LoggerFormatInfo(LOGGER, LOG_SIGN, "HEADER + BODY (%d): %s", result->fullLength, bufLogHexString);

            }


            if (env->socketId != SOCKET_WRONG_CONTEXT) {
                EgtsProcessingCloseConnection(env);
            }

        }

        if (EgtsIsTransportCompleteExt(&env->egtsEnv) == EGTS_COMPLETE_OK) {

            EgtsParseHeaderExt(&env->egtsEnv);
            EgtsParseFrameData(&env->egtsEnv);
            uint16_t lengthData = EgtsParseSrvRecordExt(&env->egtsEnv, env->egtsEnv.record);

            bool unknownPacket = true;

//            LoggerFormatInfo(LOGGER, LOG_SIGN, "env->egtsEnv.header.type = %u", env->egtsEnv.header.type);
//            LoggerFormatInfo(LOGGER, LOG_SIGN, "env->egtsEnv.recSourceService = %u", env->egtsEnv.recSourceService);
//            LoggerFormatInfo(LOGGER, LOG_SIGN, "nv->egtsEnv.subRecType = %u", env->egtsEnv.subRecType);

            //начало ---------------------------------Получена квитанция------------------------------------------------
            //начало ---------------------------------Получена квитанция------------------------------------------------
            //начало ---------------------------------Получена квитанция------------------------------------------------

            if (env->egtsEnv.header.type == EGTS_PT_RESPONSE) {

                //начало ---------------------------------Сервис АУТЕНТИФИКАЦИИ-----------------------------------------
                //начало ---------------------------------Сервис АУТЕНТИФИКАЦИИ-----------------------------------------
                //начало ---------------------------------Сервис АУТЕНТИФИКАЦИИ-----------------------------------------

                if (env->egtsEnv.recSourceService == EGTS_AUTH_SERVICE) {

                    if (env->egtsEnv.subRecType == EGTS_SR_RECORD_RESPONSE) {
                        if (env->egtsEnv.ptResponse.responsePacketId == env->egtsIdentityAdditionalData.idPacked) {

                            tEgtsRecordResponseData *egtsRecordResponseData = (tEgtsRecordResponseData *) env->egtsEnv.subRecData;

                            LoggerFormatInfo(LOGGER, LOG_SIGN,
                                             "Получен пакет (id: %u) подтверждения запроса аутентификации, status: %u  RST: %u",
                                             env->egtsEnv.ptResponse.responsePacketId, env->egtsEnv.ptResponse.status,
                                             egtsRecordResponseData->RST);

                            unknownPacket = false;

                            if ((env->egtsEnv.ptResponse.status == 0) && (egtsRecordResponseData->RST == 0))
                                env->egtsIdentityAdditionalData.isReceivedResponse = true;
                        } else {
                            unknownPacket = false;
                            LoggerFormatInfo(LOGGER, LOG_SIGN,
                                             "Получен пакет подтверждения запроса аутентификации (не верный), id: %u  id (ожидаемый): %u",
                                             env->egtsEnv.ptResponse.responsePacketId,
                                             env->egtsIdentityAdditionalData.idPacked);
                        }
                    }

                }



                //++++CFIFначало ---------------------------------Сервис АУТЕНТИФИКАЦИИ-----------------------------------------
                //начало ---------------------------------Сервис АУТЕНТИФИКАЦИИ-----------------------------------------
                //начало ---------------------------------Сервис АУТЕНТИФИКАЦИИ-----------------------------------------
                if (env->egtsEnv.recSourceService == EGTS_AUTH_SERVICE) {
                    if (env->egtsEnv.subRecType == EGTS_SR_RESULT_CODE) {

                        env->egtsIdentityAdditionalData.resultCodeAuth = *((uint8_t *) (env->egtsEnv.subRecData));

                        LoggerFormatInfo(LOGGER, LOG_SIGN,
                                         "Получен пакет результата аутентификации, код: %d",
                                         env->egtsIdentityAdditionalData.resultCodeAuth);

                        EgtsProcessing_SendResponse(env, EGTS_AUTH_SERVICE,
                                                    EGTS_AUTH_SERVICE,
                                                    EGTS_SERVICE_FLAGS_AUTH,
                                                    0,
                                                    env->egtsEnv.recordNumber);

                        // Ошибка АУТЕНТИФИКАЦИИ
                        if (env->egtsIdentityAdditionalData.resultCodeAuth == 165) {

                            if (stepAuth == 0) {
                                stepAuth = 1;

                                LoggerStrInfoStatic(LOGGER, LOG_SIGN,
                                                    "Не корректный сертификат, переход на альтернативный сервер");
//                                changeServer(env, 1);
                            } else {
                                --stepAuth;
                                LoggerFormatInfo(LOGGER, LOG_SIGN,
                                                 "Не корректный сертификат, переход на альтернативный сервер через %u попыток",
                                                 stepAuth);
                            }

                        } else {
                            stepAuth = 1;
                        }


                        unknownPacket = false;
                        env->egtsIdentityAdditionalData.isReceivedResultCode = true;
                    }
                }
                //конец ---------------------------------Сервис АУТЕНТИФИКАЦИИ------------------------------------------
                //конец ---------------------------------Сервис АУТЕНТИФИКАЦИИ------------------------------------------
                //конец ---------------------------------Сервис АУТЕНТИФИКАЦИИ------------------------------------------

                //конец ---------------------------------Сервис АУТЕНТИФИКАЦИИ------------------------------------------
                //конец ---------------------------------Сервис АУТЕНТИФИКАЦИИ------------------------------------------
                //конец ---------------------------------Сервис АУТЕНТИФИКАЦИИ------------------------------------------

                //начало ---------------------------------Сервис ПРОШИВКИ-----------------------------------------------
                //начало ---------------------------------Сервис ПРОШИВКИ-----------------------------------------------
                //начало ---------------------------------Сервис ПРОШИВКИ-----------------------------------------------
/*
                if (env->egtsEnv.recSourceService == EGTS_FIRMWARE_SERVICE) {
                    if (env->egtsEnv.subRecType == EGTS_SR_RECORD_RESPONSE) {

                        if (env->egtsEnv.ptResponse.responsePacketId ==
                            env->egtsIdentityAdditionalData.idPacked) {

                            tEgtsRecordResponseData *egtsRecordResponseData = (tEgtsRecordResponseData *) env->egtsEnv.subRecData;

                            LoggerFormatInfo(LOGGER, LOG_SIGN,
                                             "Получен пакет (id: %u) подтверждения запроса прошивки, status: %u  RST: %u",
                                             env->egtsEnv.ptResponse.responsePacketId, env->egtsEnv.ptResponse.status,
                                             egtsRecordResponseData->RST);

                            unknownPacket = false;

                            if ((env->egtsEnv.ptResponse.status == 0) && (egtsRecordResponseData->RST == 0))
                                env->egtsIdentityAdditionalData.isReceivedResponse = true;
                        } else {
                            unknownPacket = false;
                            LoggerFormatInfo(LOGGER, LOG_SIGN,
                                             "Получен пакет подтверждения запроса прошивки (не верный), id: %u  id (ожидаемый): %u",
                                             env->egtsEnv.ptResponse.responsePacketId,
                                             env->egtsIdentityAdditionalData.idPacked);
                        }


                    }
                }
*/
                //конец ---------------------------------Сервис ПРОШИВКИ------------------------------------------------
                //конец ---------------------------------Сервис ПРОШИВКИ------------------------------------------------
                //конец ---------------------------------Сервис ПРОШИВКИ------------------------------------------------

                //начало ---------------------------------Сервис ТЕЛЕДАННЫХ---------------------------------------------
                //начало ---------------------------------Сервис ТЕЛЕДАННЫХ---------------------------------------------
                //начало ---------------------------------Сервис ТЕЛЕДАННЫХ---------------------------------------------
                if (env->egtsEnv.recSourceService == EGTS_TELEDATA_SERVICE) {

                    if (env->egtsEnv.ptResponse.responsePacketId == env->egtsTeledataAdditionalData.idPacked) {
                        tEgtsRecordResponseData *egtsRecordResponseData = (tEgtsRecordResponseData *) env->egtsEnv.subRecData;
                        uint16_t POS_DATA_CRN = egtsRecordResponseData->CRN;
                        uint8_t POS_DATA_RST = egtsRecordResponseData->RST;
                        /*
                        lengthData += EgtsParseSrvRecordExt(&env->egtsEnv, env->egtsEnv.record + lengthData);
                        egtsRecordResponseData = (tEgtsRecordResponseData *) env->egtsEnv.subRecData;
                        uint16_t DIG_SENS_CRN = egtsRecordResponseData->CRN;
                        uint8_t DIG_SENS_RST = egtsRecordResponseData->RST;

                        LoggerFormatInfo(LOGGER, LOG_SIGN,
                                         "Получен пакет подтверждения отправки теледанных, status: %u  POS_DATA_RST: %u DIG_SENS_RST: %u",
                                         env->egtsEnv.ptResponse.status, POS_DATA_RST, DIG_SENS_RST);
                        */
                        LoggerFormatInfo(LOGGER, LOG_SIGN,
                                         "Получен пакет (id: %u) подтверждения отправки теледанных, status: %u  POS_DATA_RST: %u",
                                         env->egtsEnv.ptResponse.responsePacketId, env->egtsEnv.ptResponse.status,
                                         POS_DATA_RST);

                        unknownPacket = false;

                        env->egtsTeledataAdditionalData.isReceivedResponse = true;
                    } else {
                        unknownPacket = false;
                        LoggerFormatInfo(LOGGER, LOG_SIGN,
                                         "Получен пакет подтверждения отправки теледанных (не верный), id: %u  id (ожидаемый): %u",
                                         env->egtsEnv.ptResponse.responsePacketId,
                                         env->egtsIdentityAdditionalData.idPacked);
                    }
                }
                //конец ---------------------------------Сервис ТЕЛЕДАННЫХ----------------------------------------------
                //конец ---------------------------------Сервис ТЕЛЕДАННЫХ----------------------------------------------
                //конец ---------------------------------Сервис ТЕЛЕДАННЫХ----------------------------------------------

                //начало ---------------------------------Сервис КОМАНД-------------------------------------------------
                //начало ---------------------------------Сервис КОМАНД-------------------------------------------------
                //начало ---------------------------------Сервис КОМАНД-------------------------------------------------
                if (env->egtsEnv.recSourceService == EGTS_COMMANDS_SERVICE) {

                    if (env->egtsEnv.ptResponse.responsePacketId ==
                        env->egtsCommandConfirmationAdditionalData.idPacked) {
                        tEgtsRecordResponseData *egtsRecordResponseData = (tEgtsRecordResponseData *) env->egtsEnv.subRecData;
                        uint16_t POS_DATA_CRN = egtsRecordResponseData->CRN;
                        uint8_t POS_DATA_RST = egtsRecordResponseData->RST;

                        LoggerFormatInfo(LOGGER, LOG_SIGN,
                                         "Получен пакет (id: %u) подтверждения отправки команды, status: %u  POS_DATA_RST: %u",
                                         env->egtsEnv.ptResponse.responsePacketId, env->egtsEnv.ptResponse.status,
                                         POS_DATA_RST);

                        unknownPacket = false;

                        env->egtsCommandConfirmationAdditionalData.isReceivedResponse = true;
                    } else {
                        unknownPacket = false;
                        LoggerFormatInfo(LOGGER, LOG_SIGN,
                                         "Получен пакет подтверждения отправки команды (не верный), id: %u  id (ожидаемый): %u",
                                         env->egtsEnv.ptResponse.responsePacketId,
                                         env->egtsCommandConfirmationAdditionalData.idPacked);
                    }
                }
                //конец ---------------------------------Сервис КОМАНД-------------------------------------------------
                //конец ---------------------------------Сервис КОМАНД-------------------------------------------------
                //конец ---------------------------------Сервис КОМАНД-------------------------------------------------


            }
            //конец ---------------------------------Получена квитанция------------------------------------------------
            //конец ---------------------------------Получена квитанция------------------------------------------------
            //конец ---------------------------------Получена квитанция------------------------------------------------


            //начало ---------------------------------Получены данные---------------------------------------------------
            //начало ---------------------------------Получены данные---------------------------------------------------
            //начало ---------------------------------Получены данные---------------------------------------------------
            if (env->egtsEnv.header.type == EGTS_PT_APPDATA) {

                //начало ---------------------------------Сервис АУТЕНТИФИКАЦИИ-----------------------------------------
                //начало ---------------------------------Сервис АУТЕНТИФИКАЦИИ-----------------------------------------
                //начало ---------------------------------Сервис АУТЕНТИФИКАЦИИ-----------------------------------------
                if (env->egtsEnv.recSourceService == EGTS_AUTH_SERVICE) {
                    if (env->egtsEnv.subRecType == EGTS_SR_RESULT_CODE) {

                        env->egtsIdentityAdditionalData.resultCodeAuth = *((uint8_t *) (env->egtsEnv.subRecData));

                        LoggerFormatInfo(LOGGER, LOG_SIGN,
                                         "Получен пакет результата аутентификации, код: %d",
                                         env->egtsIdentityAdditionalData.resultCodeAuth);

                        EgtsProcessing_SendResponse(env, EGTS_AUTH_SERVICE,
                                                    EGTS_AUTH_SERVICE,
                                                    EGTS_SERVICE_FLAGS_AUTH,
                                                    0,
                                                    env->egtsEnv.recordNumber);

                        // Ошибка АУТЕНТИФИКАЦИИ
                        if (env->egtsIdentityAdditionalData.resultCodeAuth == 165) {

                            if (stepAuth == 0) {
                                stepAuth = 1;

                                LoggerStrInfoStatic(LOGGER, LOG_SIGN,
                                                    "Не корректный сертификат, переход на альтернативный сервер");
//                                changeServer(env, 1);
                            } else {
                                --stepAuth;
                                LoggerFormatInfo(LOGGER, LOG_SIGN,
                                                 "Не корректный сертификат, переход на альтернативный сервер через %u попыток",
                                                 stepAuth);
                            }

                        } else {
                            stepAuth = 1;
                        }


                        unknownPacket = false;
                        env->egtsIdentityAdditionalData.isReceivedResultCode = true;
                    }
                }
                //конец ---------------------------------Сервис АУТЕНТИФИКАЦИИ------------------------------------------
                //конец ---------------------------------Сервис АУТЕНТИФИКАЦИИ------------------------------------------
                //конец ---------------------------------Сервис АУТЕНТИФИКАЦИИ------------------------------------------

                //начало ---------------------------------Сервис КОМАНД-------------------------------------------------
                //начало ---------------------------------Сервис КОМАНД-------------------------------------------------
                //начало ---------------------------------Сервис КОМАНД-------------------------------------------------
                if (env->egtsEnv.recSourceService == EGTS_COMMANDS_SERVICE) {
                    unknownPacket = false;

                    tEgtsCommand egtsCommand;
                    egtsCommand.cmdType = env->egtsEnv.srCommand->cmdType;
                    egtsCommand.cmdId = env->egtsEnv.srCommand->cmdId;
                    egtsCommand.act = env->egtsEnv.srCommand->act;
                    egtsCommand.cmd = env->egtsEnv.srCommand->cmd;
                    egtsCommand.dataSize = env->egtsEnv.subRecLength - 15;

                    if (egtsCommand.dataSize > 32)
                        egtsCommand.dataSize = 32;

                    memcpy(egtsCommand.data, env->egtsEnv.srCommand->dataPointer, egtsCommand.dataSize);

                    EgtsProcessing_SendResponse(env, EGTS_COMMANDS_SERVICE,
                                                EGTS_COMMANDS_SERVICE,
                                                EGTS_SERVICE_FLAGS_COMMAND,
                                                0,
                                                env->egtsEnv.recordNumber);

                    addCommandQueue(env, &egtsCommand);

                }
                //конец ---------------------------------Сервис КОМАНД-------------------------------------------------
                //конец ---------------------------------Сервис КОМАНД-------------------------------------------------
                //конец ---------------------------------Сервис КОМАНД-------------------------------------------------

                //начало --------------------------------Сервис ПРОШИВКИ-----------------------------------------------
                //начало --------------------------------Сервис ПРОШИВКИ-----------------------------------------------
                //начало --------------------------------Сервис ПРОШИВКИ-----------------------------------------------
                if (env->egtsEnv.recSourceService == EGTS_FIRMWARE_SERVICE) {
                    if (env->egtsEnv.subRecType == EGTS_SR_SERVICE_PART_DATA) {
                        unknownPacket = false;
//                        receivedUpdateFirmware(env);
                    }
                }
                //конец ---------------------------------Сервис ПРОШИВКИ------------------------------------------------
                //конец ---------------------------------Сервис ПРОШИВКИ------------------------------------------------
                //конец ---------------------------------Сервис ПРОШИВКИ------------------------------------------------

            }
            //конец ---------------------------------Получены данные----------------------------------------------------
            //конец ---------------------------------Получены данные----------------------------------------------------
            //конец ---------------------------------Получены данные----------------------------------------------------


            if (unknownPacket) {
                uint16_t len =
                        env->egtsEnv.headerLength + env->egtsEnv.frameDataLength + env->egtsEnv.frameDataSrcLength;
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Получен неопознанный пакет:");
                sendLogHex(env, env->egtsEnv.workingBuffer, len);

            }

            EgtsResetBuffer(&env->egtsEnv);
        }

    }
}

_Noreturn void EgtsProcessing_ListenerTask(tEgtsProcessing *env) {
    while (1) {
        EgtsProcessing_Worker(env);
    }
}

#endif