//
// Created by cfif on 13.06.2024.
//
#include "EgtsEbu.h"
#include "string.h"
#include "lfs_file_utils.h"
#include "EgtsOutputCommands.h"
#include "ext_telematica.h"
#include "SystemDelayInterface.h"
#include "Rtc.h"
#include "FirmwareMetadataSection.h"
#include "ld_adr.h"

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

#define ADD_TO_DATA_CHAR_SHORT(DATA) *(uint8_t *) (out + offset) = DATA; *(uint8_t *) (out + offset + 1) = 0; offset+=2;
#define ADD_TO_DATA_SHORT(DATA) *(uint8_t *) (out + offset) = (uint8_t)DATA; *(uint8_t *) (out + offset + 1) = (uint8_t)(DATA >> 8); offset+=2;
#define ADD_TO_DATA_BYTE(DATA) *(uint8_t *) (out + offset) = (uint8_t)DATA; offset+=1;
#define ADD_TO_DATA(DATA, LEN) memcpy(out + offset, (uint8_t * ) & DATA, LEN); offset+=LEN;

extern tFirmwareLoader FIRMWARE_TELE_LOADER;
extern tFirmwareLoader FIRMWARE_LOADER;


const tEgtsEbuName egtsEbuName[EBU_COUNT_TABLE_ITEMS] = {
        {EBU_GNSS, "GNSS~UAZ", 0x0000, 0x0000,                                         0x0000, {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},

        {EBU_ABS,  "ABS~UAZ1APG",     TESTER_REQUEST_ABS_ESP, TESTER_RESPONSE_ABS_ESP, 0x4000, {0xF187, 0xF18A, 0xF18C, 0xF190, 0xF193, 0xF195, 0xF197, 0xF199, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
        {EBU_ABS,  "ABS~UAZ1TRINOVA", TESTER_REQUEST_ABS_ESP, TESTER_RESPONSE_ABS_ESP, 0x0200, {0xF112, 0xF180, 0xF183, 0xF187, 0xF189, 0xF18A, 0xF18B, 0xF18C, 0xF190, 0xF192, 0xF193, 0xF194, 0xF195, 0xF197, 0xF198, 0xF199, 0xF19D, 0x0000}},

        {EBU_ECM,  "ECM~UAZ1ITL",     TESTER_REQUEST_ECM,     TESTER_RESPONSE_ECM,     0x0090, {0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 0x0098, 0x0099, 0x009A, 0x00A1, 0x00A2, 0x00A3, 0x0000, 0x0000, 0x0000, 0x0000}},
        {EBU_ECM,  "ECM~UAZ1DPLUS",   TESTER_REQUEST_ECM,     TESTER_RESPONSE_ECM,     0xF187, {0xF187, 0xF189, 0xF18A, 0xF18B, 0xF18C, 0xF190, 0xF192, 0xF193, 0xF194, 0xF195, 0xF197, 0xF198, 0xF199, 0xF19D, 0xF1F9, 0x0000, 0x0000, 0x0000}},

        {EBU_HVAC, "HVAC~UAZ1",       TESTER_REQUEST_HVAC,    TESTER_RESPONSE_HVAC,    0xF112, {0xF112, 0xF122, 0xF132, 0xF150, 0xF151, 0xF153, 0xF18C, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},

        {EBU_IMMO, "IMMO~UAZ1ITL",    TESTER_REQUEST_ITELMA_IMMO_D,  TESTER_RESPONSE_ITELMA_IMMO_D,  0x0000, {0x0007, 0x0100, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
        {EBU_IMMO, "IMMO~UAZ1DPLUS",    TESTER_REQUEST_IMMO_D,  TESTER_RESPONSE_IMMO_D,  0x0000, {0xF190, 0xF193, 0xF195, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},

        {EBU_PTS,  "PTS~UAZ1ABIX",    TESTER_REQUEST_PTS,     TESTER_RESPONSE_PTS,     0xF183, {0xF183, 0xF184, 0xF18E, 0xF190, 0xF191, 0xF199, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}}

};

const tEgtsEbuTestName egtsEbuTestName[EBU_COUNT_TEST_ITEMS] = {
        {TEST_FIRMWARE,        "FIRMWARE"},
        {TEST_IGNITION,        "IGNITION"},
        {TEST_BAT_CONNECT,     "BAT_CONNECT"},
        {TEST_BAT_CHARGE,      "BAT_CHARGE"},
        {TEST_BAT_VOLTAGE,     "BAT_VOLTAGE"},
        {TEST_GNSS_ANT,        "GNSS_ANT"},
        {TEST_SPEAKER_CONNECT, "SPEAKER_CONNECT"},
        {TEST_BIP_CONNECT,     "BIP_CONNECT"},
        {TEST_ACCEL,           "ACCEL"},
        {TEST_GSM,             "GSM"},
        {TEST_AUDIO_CODEC,     "AUDIO_CODEC"},
        {TEST_VIN,             "VIN"},
        {TEST_ACCEL_CALIB,     "ACCEL_CALIB"},
        {TEST_EOL,             "EOL"},
        {TEST_MODEM_SOFT_REV,  "MODEM_SOFT_REV"},
        {TEST_CERT_REV,        "MODEM_CERT_REV"},
        {TEST_AUDIO_FILE,      "MODEM_AUDIO_FILE"},
        {TEST_AMPLIFIER,       "AMPLIFIER"},
        {TEST_SIM_ERA,         "SIM_ERA"},
        {TEST_SIM_COMERS,      "SIM_COMERS"}
};

bool addEbuTableItem(tEgtsProcessing *env, tEgtsEbuState *ebuState, tEgtsEbuItemState *ebuItemState) {

    if (ebuState->count >= EBU_COUNT_FS_ITEMS)
        return false;

    ebuState->ebuItemState[ebuState->count].ebu = ebuItemState->ebu;
    ebuState->ebuItemState[ebuState->count].timestamp = ebuItemState->timestamp;
    ++ebuState->count;

    return true;
}

void setUpdateEbuAll(tEgtsProcessing *env, tEgtsEbuState *ebuState) {
    if (osMutexAcquire(env->accessEbu, 2000) == osOK) {

        for (uint16_t i = 0; i < ebuState->count; ++i) {
            if (ebuState->ebuItemState[i].ebu == i) {
                ebuState->ebuItemState[i].timestamp = 0;
            }
        }

        dumpEbuTable(env);

        osMutexRelease(env->accessEbu);
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа setUpdateEbu")
    }
}

void setUpdateEbu(tEgtsProcessing *env, tEgtsEbuState *ebuState, eEgtsEbu egtsEbu, uint32_t state) {
    if (osMutexAcquire(env->accessEbu, 2000) == osOK) {

        for (uint16_t i = 0; i < ebuState->count; ++i) {
            if (ebuState->ebuItemState[i].ebu == egtsEbu) {
                ebuState->ebuItemState[i].timestamp = state;
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Состояние ЭБУ найдено")
                dumpEbuTable(env);
                break;
            }
        }

        osMutexRelease(env->accessEbu);
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа setUpdateEbu")
    }
}

void setUpdateEbuClearDTC(tEgtsProcessing *env, tEgtsEbuState *ebuState, eEgtsEbu egtsEbu, bool clearDTC) {
    if (osMutexAcquire(env->accessEbu, 2000) == osOK) {

        for (uint16_t i = 0; i < ebuState->count; ++i) {
            if (ebuState->ebuItemState[i].ebu == egtsEbu) {
                ebuState->ebuItemState[i].clearDTC = clearDTC;
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Состояние ЭБУ найдено")
                break;
            }
        }

        osMutexRelease(env->accessEbu);
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа setUpdateEbuClearDTC")
    }
}

bool dumpEbuTable(tEgtsProcessing *env) {
    bool isMain = true;

    env->ebuState.version = VERSION_EBU;
    uint32_t crc = lfs_crc(0, &env->ebuState, sizeof(env->ebuState) - sizeof(env->ebuState.crc));
    env->ebuState.crc = crc;

    int lfs_err = dumpEbuFile(&env->fs->lfs, "ebu.bin", &env->ebuState, sizeof(tEgtsEbuState));

    if (lfs_err != LFS_ERR_OK) {
        LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Сохранение состояния ЭБУ - ошибка");
        isMain = false;
    }

    if (!isMain)
        return false;

    LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Сохранение состояния ЭБУ - успешно");
    return true;
}

bool loadEbuTable(tEgtsProcessing *env) {

    bool crc_main = false;

    int lfs_err = loadEbuFile(&env->fs->lfs, "ebu.bin", &env->ebuState, sizeof(tEgtsEbuState));

    if (lfs_err == LFS_ERR_OK) {
        uint32_t crc = lfs_crc(0, &env->ebuState, sizeof(tEgtsEbuState) - sizeof(env->ebuState.crc));

        if (crc == env->ebuState.crc) {
            LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Загрузка состояния ЭБУ - успешно");
            crc_main = true;
        } else {
            LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Загрузка состояния ЭБУ - ошибка контрольной суммы");
        }
    }

    if ((!crc_main) || (env->ebuState.count == 0) || (env->ebuState.version != VERSION_EBU)) {
        LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Загрузка состояния ЭБУ - восстановление значений по умолчанию");

        tEgtsEbuItemState egtsEbuItemState;
        egtsEbuItemState.timestamp = 0;

        for (uint16_t i = 0; i < EBU_COUNT_FS_ITEMS; ++i) {
            egtsEbuItemState.ebu = i;
            addEbuTableItem(env, &env->ebuState, &egtsEbuItemState);
        }

        dumpEbuTable(env);
    }

    return true;
}

bool setEgtsNameEbu(tEgtsProcessing *env, uint8_t ebu) {

    if (ebu >= EBU_COUNT_TABLE_ITEMS)
        return false;

    env->egtsFirmwareDataArgs.module[0] = '\0';
    strcat(env->egtsFirmwareDataArgs.module, egtsEbuName[ebu].ebuName);

    return true;
/*
    for (uint8_t i = 0; i < EBU_COUNT_TABLE_ITEMS; ++i) {
        if (egtsEbuName[i].ebu == ebu) {
            env->egtsFirmwareDataArgs.module[0] = '\0';
            strcat(env->egtsFirmwareDataArgs.module, egtsEbuName[i].ebuName);
            return true;
        }
    }

    return false;
*/
}

void clearResultTest() {

    for (uint16_t i = 0; i < EXT_ENV_TELE.testsTable->count; ++i) {
        EXT_ENV_TELE.testsTable->items[i].resultFix = 0;
    }

}

bool isCertTest() {
    for (uint16_t i = 0; i < EXT_ENV_TELE.testsTable->count; ++i) {
        if (memcmp(EXT_ENV_TELE.testsTable->items[i].name.str, "MODEM_CERT_REV",
                   EXT_ENV_TELE.testsTable->items[i].name.length) == 0) {

            if (EXT_ENV_TELE.testsTable->items[i].resultFix == DEVICE_TESTING_CODE_PASSED) {
                return true;
            } else {
                return false;
            }

        }
    }

    return false;
}

eEgtsTestEbu getResultTest(uint8_t indexTest, eDeviceTestingCode *deviceTestingCode) {

    /**
     * todo: Есть риск коллизии
     * Потенциальная ситуация (пример)
     * memcmp("ACCEL", "ACCEL_CALIB",5(длинна "ACCEL") ) вернет 0
     */
    for (uint16_t i = 0; i < EBU_COUNT_TEST_ITEMS; ++i) {
        if (memcmp(EXT_ENV_TELE.testsTable->items[indexTest].name.str, egtsEbuTestName[i].ebuTestName,
                   EXT_ENV_TELE.testsTable->items[indexTest].name.length) == 0) {
            *deviceTestingCode = EXT_ENV_TELE.testsTable->items[indexTest].resultFix;
            return egtsEbuTestName[i].ebu;
        }

    }

    return 0xFF;
}

uint16_t SetEbuDTCerror(tEgtsProcessing *env, uint8_t *out, uint16_t offset, eUdsErrorDTC codeError) {
    ADD_TO_DATA_BYTE(UDS_DTC_Error[codeError].DTCHighByte)
    ADD_TO_DATA_BYTE(UDS_DTC_Error[codeError].DTCMiddleByte)
    ADD_TO_DATA_BYTE(UDS_DTC_Error[codeError].DTCLowByte)
    ADD_TO_DATA_BYTE(0x01)

    return offset;
}


void getMetaDataUveos(tString32 *FW_NAME, tString32 *HW_NAME, tString32 *FW_INTERFACE) {
    memset(FW_NAME, 0, sizeof(tString32));
    memset(HW_NAME, 0, sizeof(tString32));
    memset(FW_INTERFACE, 0, sizeof(tString32));

    uint32_t offsetMeta = 0x08000000 + BOOT_AREA_LENGTH + FIRMWARE_MAIN_AREA_LENGTH - 256;

    uint32_t pos = offsetMeta;
    uint32_t offsetMetaCrc = (*(uint32_t *) pos);
    pos += 4;
    uint32_t offsetMetaSize = (*(uint32_t *) (pos));
    pos += 4;

    // FW
    FW_NAME->length = (*(uint8_t *) (pos));
    pos += 1;

    if (FW_NAME->length > 32) {
        FW_NAME->length = 0;
        return;
    }

    memcpy(FW_NAME->data, (uint8_t *) (pos), FW_NAME->length);
    pos += FW_NAME->length;

    // HW
    HW_NAME->length = (*(uint8_t *) (pos));
    pos += 1;

    if (HW_NAME->length > 32) {
        HW_NAME->length = 0;
        return;
    }

    memcpy(HW_NAME->data, (uint8_t *) (pos), HW_NAME->length);
    pos += HW_NAME->length;

    // FW_INTERFACE
    FW_INTERFACE->length = (*(uint8_t *) (pos));
    pos += 1;

    if (FW_INTERFACE->length > 32) {
        FW_INTERFACE->length = 0;
        return;
    }

    memcpy(FW_INTERFACE->data, (uint8_t *) (pos), FW_INTERFACE->length);
    pos += FW_INTERFACE->length;

}

void setBufEbu(tEgtsProcessing *env) {
    uint16_t offset = 0;
    uint8_t *out = env->egtsFirmwareDataArgs.bufEbu;

    // начало------------------------------------------Ошибки-----------------------------------------------------------
    ADD_TO_DATA_SHORT(0x1902)
    ADD_TO_DATA_SHORT(0x0004)
    ADD_TO_DATA_BYTE(0xFF)
    ADD_TO_DATA_BYTE(0x00)
    ADD_TO_DATA_BYTE(0x00)
    ADD_TO_DATA_BYTE(0xE0)

    for (uint16_t i = 0; i < EXT_ENV_TELE.testsTable->count; ++i) {

        eDeviceTestingCode deviceTestingCode;
        eEgtsTestEbu egtsTestEbu = getResultTest(i, &deviceTestingCode);

        if (egtsTestEbu == TEST_FIRMWARE) {
            // DEVICE_TESTING_CODE_ERROR
        }

        if (egtsTestEbu == TEST_IGNITION) {
            // DEVICE_TESTING_CODE_ERROR
        }

        if (egtsTestEbu == TEST_BAT_CONNECT) {
            // DEVICE_TESTING_CODE_ERROR
            if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR)
                offset = SetEbuDTCerror(env, out, offset, UDS_TEST_BAT_CONNECT);
        }

        if (egtsTestEbu == TEST_BAT_CHARGE) {
            // DEVICE_TESTING_CODE_ERROR
            if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR)
                offset = SetEbuDTCerror(env, out, offset, UDS_TEST_BAT_CHARGE);
        }

        if (egtsTestEbu == TEST_BAT_VOLTAGE) {
            // DEVICE_TESTING_CODE_ERROR
            if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR)
                offset = SetEbuDTCerror(env, out, offset, UDS_TEST_BAT_VOLTAGE);
        }

        if (egtsTestEbu == TEST_GNSS_ANT) {
            // DEVICE_TESTING_CODE_ERROR
            // DEVICE_TESTING_CODE_NOT_CONNECTED
            // DEVICE_TESTING_CODE_SHORT_CIRCUIT
            if ((deviceTestingCode == DEVICE_TESTING_CODE_ERROR) ||
                (deviceTestingCode == DEVICE_TESTING_CODE_NOT_CONNECTED) ||
                (deviceTestingCode == DEVICE_TESTING_CODE_SHORT_CIRCUIT))
                offset = SetEbuDTCerror(env, out, offset, UDS_TEST_GNSS_ANT);
        }

        if (egtsTestEbu == TEST_SPEAKER_CONNECT) {
            // DEVICE_TESTING_CODE_ERROR
            // DEVICE_TESTING_CODE_NOT_CONNECTED
            if ((deviceTestingCode == DEVICE_TESTING_CODE_ERROR) ||
                (deviceTestingCode == DEVICE_TESTING_CODE_NOT_CONNECTED))
                offset = SetEbuDTCerror(env, out, offset, UDS_TEST_SPEAKER_CONNECT);

        }

        if (egtsTestEbu == TEST_BIP_CONNECT) {
            if (deviceTestingCode == DEVICE_TESTING_CODE_NOT_CONNECTED)
                offset = SetEbuDTCerror(env, out, offset, UDS_TEST_MICROPHONE_CONNECT);
        }

        if (egtsTestEbu == TEST_ACCEL) {
            // DEVICE_TESTING_CODE_ERROR
            if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR)
                offset = SetEbuDTCerror(env, out, offset, UDS_TEST_ACCEL);
        }

        if (egtsTestEbu == TEST_GSM) {
            // DEVICE_TESTING_CODE_ERROR
            if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR)
                offset = SetEbuDTCerror(env, out, offset, UDS_TEST_GSM);
        }


        if (egtsTestEbu == TEST_AUDIO_CODEC) {
            // DEVICE_TESTING_CODE_ERROR
            if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR)
                offset = SetEbuDTCerror(env, out, offset, UDS_TEST_GSM_AUDIO_CODEC);
        }

        if (egtsTestEbu == TEST_VIN) {
            // DEVICE_TESTING_CODE_ERROR
            if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR)
                offset = SetEbuDTCerror(env, out, offset, UDS_TEST_VIN);
        }

        if (egtsTestEbu == TEST_ACCEL_CALIB) {
            // DEVICE_TESTING_CODE_ERROR
            if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR)
                offset = SetEbuDTCerror(env, out, offset, UDS_TEST_ACCEL_CALIB);
        }

        if (egtsTestEbu == TEST_EOL) {
            // DEVICE_TESTING_CODE_ERROR
//            if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR)
//                offset = SetEbuDTCerror(env, out, offset, UDS_TEST_EOL);
        }

        if (egtsTestEbu == TEST_MODEM_SOFT_REV) {
            // DEVICE_TESTING_CODE_ERROR
            if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR)
                offset = SetEbuDTCerror(env, out, offset, UDS_TEST_MODEM_SOFT_REV);
        }

        if (egtsTestEbu == TEST_CERT_REV) {
            // DEVICE_TESTING_CODE_ERROR
            if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR)
                offset = SetEbuDTCerror(env, out, offset, UDS_TEST_CERT_REV);
        }

        if (egtsTestEbu == TEST_AUDIO_FILE) {
            // DEVICE_TESTING_CODE_ERROR
            if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR)
                offset = SetEbuDTCerror(env, out, offset, UDS_TEST_AUDIO_FILE);
        }


        if (egtsTestEbu == TEST_AMPLIFIER) {
            // DEVICE_TESTING_CODE_ERROR
            if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR)
                offset = SetEbuDTCerror(env, out, offset, UDS_TEST_AMPLIFIER);
        }


        if (egtsTestEbu == TEST_SIM_ERA) {
            // DEVICE_TESTING_CODE_ERROR
            if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR)
                offset = SetEbuDTCerror(env, out, offset, UDS_TEST_SIM_ERA);
        }

        if (egtsTestEbu == TEST_SIM_COMERS) {
            // DEVICE_TESTING_CODE_ERROR
            if (deviceTestingCode == DEVICE_TESTING_CODE_ERROR)
                offset = SetEbuDTCerror(env, out, offset, UDS_TEST_SIM_COMERS);
        }

    }

    if (offset > 8) {
        uint16_t *len = (uint16_t *) &out[2];
        uint8_t *err = (uint8_t *) &out[7];
        *len = offset - 4;
        *err = 0;
        asm("nop");
    }

    // конец-------------------------------------------Ошибки-----------------------------------------------------------


    // IMEI
    uint8_t IMEI_len = EXT_ENV_TELE.store.device->cgsmid.length;
    if (EXT_ENV_TELE.store.device->cgsmid.length >= 2) {
        if ((EXT_ENV_TELE.store.device->cgsmid.data[IMEI_len - 1] == '\n') &&
            (EXT_ENV_TELE.store.device->cgsmid.data[IMEI_len - 2] == '\r')) {
            IMEI_len = EXT_ENV_TELE.store.device->cgsmid.length - 2;
        }
    }


    uint8_t dataBuf[50];

    memset(dataBuf, 0, sizeof(dataBuf));
    memcpy(dataBuf, EXT_ENV_TELE.store.device->cgsmid.data, IMEI_len);
    ADD_TO_DATA_SHORT(0x0411);
    ADD_TO_DATA_CHAR_SHORT(15);
    ADD_TO_DATA(dataBuf, 15)

    memset(dataBuf, 0, sizeof(dataBuf));
    memcpy(dataBuf, EXT_ENV_TELE.store.gost->VIN.data, EXT_ENV_TELE.store.gost->VIN.length);
    ADD_TO_DATA_SHORT(0x0190);
    ADD_TO_DATA_CHAR_SHORT(17);
    ADD_TO_DATA(dataBuf, 17)

    memset(dataBuf, 0, sizeof(dataBuf));
    memcpy(dataBuf, EXT_ENV_TELE.store.device->ccidComers.data, EXT_ENV_TELE.store.device->ccidComers.length);
    ADD_TO_DATA_SHORT(0x001E);
    ADD_TO_DATA_CHAR_SHORT(20);
    ADD_TO_DATA(dataBuf, 20)

    memset(dataBuf, 0, sizeof(dataBuf));
    memcpy(dataBuf, EXT_ENV_TELE.store.device->ccid.data, EXT_ENV_TELE.store.device->ccid.length);
    ADD_TO_DATA_SHORT(0x001D);
    ADD_TO_DATA_CHAR_SHORT(19);
    ADD_TO_DATA(dataBuf, 19)
/*
    tString32 FW_NAME;
    FW_NAME.length = *FIRMWARE_LOADER.main.metadata.nameLength;

    if (FW_NAME.length > 32) {
        FW_NAME.length = 0;
    } else {
        memcpy(FW_NAME.data, FIRMWARE_LOADER.main.metadata.name, FW_NAME.length);
    }
*/
    tString32 FW_NAME;
    tString32 HW_NAME;
    tString32 FW_INTERFACE;

    getMetaDataUveos(&FW_NAME, &HW_NAME, &FW_INTERFACE);

    uint8_t posDel = findDelimiter(&FW_INTERFACE, ' ');

    memset(dataBuf, 0, sizeof(dataBuf));
    memcpy(dataBuf, FIRMWARE_TELE_LOADER.main.metadata.name, *FIRMWARE_TELE_LOADER.main.metadata.nameLength);
    memcpy(&dataBuf[*FIRMWARE_TELE_LOADER.main.metadata.nameLength], &FW_INTERFACE.data[posDel], FW_INTERFACE.length - posDel);

    ADD_TO_DATA_SHORT(0x0600);
    ADD_TO_DATA_CHAR_SHORT(32);
    ADD_TO_DATA(dataBuf, 32)

    memset(dataBuf, 0, sizeof(dataBuf));
    memcpy(dataBuf, &EXT_ENV_TELE.store.device->telematicaIsActive, 1);
    ADD_TO_DATA_SHORT(0x0604);
    ADD_TO_DATA_CHAR_SHORT(1);
    ADD_TO_DATA(dataBuf, 1)

/*
    // Serial Number

//    ADD_TO_DATA_SHORT(0xF18C);
//    ADD_TO_DATA_CHAR_SHORT(env->storage->nvm.device.serialNumber.value.length);
//    ADD_TO_DATA(env->storage->nvm.device.serialNumber.value.data, env->storage->nvm.device.serialNumber.value.length)

    // IMEI
    uint8_t IMEI_len = EXT_ENV_TELE.store.device->cgsmid.length;
    if (EXT_ENV_TELE.store.device->cgsmid.length >= 2) {
        if ((EXT_ENV_TELE.store.device->cgsmid.data[IMEI_len - 1] == '\n') &&
            (EXT_ENV_TELE.store.device->cgsmid.data[IMEI_len - 2] == '\r')) {
            IMEI_len = EXT_ENV_TELE.store.device->cgsmid.length - 2;
        }
    }

    ADD_TO_DATA_SHORT(0xF101);
    ADD_TO_DATA_CHAR_SHORT(IMEI_len);
    ADD_TO_DATA(EXT_ENV_TELE.store.device->cgsmid.data, IMEI_len)

    // Phone Number

    // Hardware Version
    tString32 fw;
    fw.length = META_FW_NAME_SIZE;
    memcpy(&fw.data, (uint8_t *) META_FW_NAME, fw.length);

    tString32 hw;
    hw.length = META_HW_NAME_SIZE;
    memcpy(&hw.data, (uint8_t *) META_HW_NAME, hw.length);

    // Hardware Version
    ADD_TO_DATA_SHORT(0xF193);
    ADD_TO_DATA_CHAR_SHORT(hw.length);
    ADD_TO_DATA(hw.data, hw.length)

    // Vehicle VIN Number
    ADD_TO_DATA_SHORT(0xF190);
    ADD_TO_DATA_CHAR_SHORT(EXT_ENV_TELE.store.gost->VIN.length);
    ADD_TO_DATA(EXT_ENV_TELE.store.gost->VIN.data, EXT_ENV_TELE.store.gost->VIN.length)

    // Main Server
    ADD_TO_DATA_SHORT(0xF104);
    ADD_TO_DATA_CHAR_SHORT(env->deviceTeledataStorageData->telematica.EGTS_SERVER_ADDRESS.length);
    ADD_TO_DATA(env->deviceTeledataStorageData->telematica.EGTS_SERVER_ADDRESS.data,
                env->deviceTeledataStorageData->telematica.EGTS_SERVER_ADDRESS.length)

    // Second Server
    ADD_TO_DATA_SHORT(0xF105);
    ADD_TO_DATA_CHAR_SHORT(env->deviceTeledataStorageData->telematica.EGTS_ALT_SERVER_ADDRESS.length);
    ADD_TO_DATA(env->deviceTeledataStorageData->telematica.EGTS_ALT_SERVER_ADDRESS.data,
                env->deviceTeledataStorageData->telematica.EGTS_ALT_SERVER_ADDRESS.length)

*/

    env->egtsFirmwareDataArgs.bufLen = offset;
}

void _Noreturn EgtsProcessing_TransmitterTaskEbu(tEgtsProcessing *env) {

    time_t timestamp = 0;
    uint8_t egtsEbuIndex = 0;

    uint32_t timeTeleOff = 0;

    bool isTimestamp = true;

    bool oneOn = true;
    bool oneOff = true;

    for (;;) {

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


        //начало ---------------------------------Отправка прошивки ЭБУ-------------------------------------------------
        //начало ---------------------------------Отправка прошивки ЭБУ-------------------------------------------------
        //начало ---------------------------------Отправка прошивки ЭБУ-------------------------------------------------

        if (!isAuth(env)) {
//            LoggerInfoStatic(LOGGER, LOG_SIGN, "Ожидание аутентификации на сервере")
            SystemDelayMs(1000);
            continue;
        }

        if (!env->isEnableTelematicaSendPoints) {
            if (timeTeleOff < SystemGetMs()) {
                timeTeleOff = SystemGetMs() + 10000;
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Ожидание разрешения телематики")
            }
            SystemDelayMs(1000);
            continue;
        }


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

        if (timestamp < 1718359909) {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Ожидание получения временной метки")
            SystemDelayMs(1000);
            continue;
        } else {
            if (isTimestamp) {
                isTimestamp = false;
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Временная метка получена")
            }
        }

        // Передача прошивки через ВРЕМЯ
        if ((env->fl_firstStartTimeUpdateEBU) && (env->firstStartTimeUpdateEBU < SystemGetMs())) {
            EXT_ENV_TELE.store.runtime->telematicaWaitConnect = true;

            egtsEbuIndex = EBU_GNSS;
            setEgtsNameEbu(env, egtsEbuIndex);
            setBufEbu(env);

            if (EgtsProcessing_SendFirmware(env) == false) {
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Передача данных ЭБУ (автоматическая) не удалась")
            } else {
                env->fl_firstStartTimeUpdateEBU = false;
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Передача данных ЭБУ (автоматическая) завершена успешно")
            }
        }

        if (!env->ebuReady) {

            if (env->ebuState.ebuItemState[EBU_GNSS].timestamp == 0) {

                egtsEbuIndex = EBU_GNSS;
                setEgtsNameEbu(env, egtsEbuIndex);
                setBufEbu(env);

                env->ebuReady = true;
            } else {

                if (env->CanMainAdditional.egtsEbuUdsReady.isUdsBufReady) {

                    egtsEbuIndex = env->CanMainAdditional.egtsEbuUdsReady.ebuIndex;
                    setEgtsNameEbu(env, egtsEbuIndex);

                    env->egtsFirmwareDataArgs.bufLen = env->CanMainAdditional.egtsEbuUdsReady.bufLen;
                    memcpy(env->egtsFirmwareDataArgs.bufEbu,
                           (uint8_t *) env->CanMainAdditional.egtsEbuUdsReady.buf,
                           env->CanMainAdditional.egtsEbuUdsReady.bufLen);

                    env->ebuReady = true;
                }


            }

        }

        if (env->ebuReady) {

            env->ebuReady = false;
/*
            setUpdateEbu(env, &env->ebuState, egtsEbuName[egtsEbuIndex].ebu, timestamp + 86400); // !!!!!!!!!
            env->CanMainAdditional.egtsEbuUdsReady.ebuIndex = 0;  // !!!!!!!!!
            env->CanMainAdditional.egtsEbuUdsReady.isUdsBufReady = false; // !!!!!!!!!!!!
*/


            // Передача прошивки
            if (EgtsProcessing_SendFirmware(env) == false) {
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Передача данных ЭБУ не удалась")
            } else {
                setUpdateEbu(env, &env->ebuState, egtsEbuName[egtsEbuIndex].ebu, timestamp + 86400);

                if (egtsEbuIndex != EBU_GNSS) {
                    env->CanMainAdditional.egtsEbuUdsReady.ebuIndex = 0;
                    env->CanMainAdditional.egtsEbuUdsReady.isUdsBufReady = false;
                }

            }

        }


        //конец ---------------------------------Отправка прошивки ЭБУ--------------------------------------------------
        //конец ---------------------------------Отправка прошивки ЭБУ--------------------------------------------------
        //конец ---------------------------------Отправка прошивки ЭБУ--------------------------------------------------

        SystemDelayMs(1000);
    }
}