//
// Created by cfif on 11.04.2024.
//
#include "EgtsInputCommands.h"
#include "EgtsOutputCommands.h"
#include "Rtc.h"
#include "string.h"
#include "EgtsEbu.h"
#include "ext_telematica.h"
#include "SystemDelayInterface.h"
#include "EgtsTeledataPoint.h"

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

egtsAurusCommandResult egtsAurusSetTimestamp(tEgtsProcessing *env) {

    time_t timestampServer = *((uint32_t *) env->egtsCommandSent.data);

//    LoggerFormatInfo(LOGGER, LOG_SIGN, "Получена временная метка (1681246800): %u", timestamp)

    timestampServer = timestampServer + 1681246800 + 3600 * 3;

    time_t timestampLocal = 0;
    RtcGet(EXT_ENV_TELE.rtcIO, &timestampLocal);

    LoggerFormatInfo(LOGGER, LOG_SIGN, "Получена временная метка с сервера: %u, текущая временная метка: %u", (uint32_t)timestampServer, (uint32_t)timestampLocal)

    RtcSet(EXT_ENV_TELE.rtcIO, &timestampServer);

    //1681246800

    if (env->egtsCommandSent.dataSize >= 5) {

        uint8_t isRunTelematica = env->egtsCommandSent.data[4];

        LoggerFormatInfo(LOGGER, LOG_SIGN, "Получен статус удаленного включения (не перманентного) телематики: %u", isRunTelematica)

        if (isRunTelematica) {
            return EGTS_AURUS_COMMAND_RESULT_TIMESTAMP_TELE_RUN_OK;

        }

    } else {
        EXT_ENV_TELE.store.runtime->telematicaWaitConnect = true;
    }

    return EGTS_AURUS_COMMAND_RESULT_TIMESTAMP_TELE_STOP_OK;
}

egtsAurusCommandResult egtsAurusGetReport(tEgtsProcessing *env) {

    uint16_t command = *((uint16_t *) (env->egtsCommandSent.data + 2));
    uint16_t block = *((uint16_t *) env->egtsCommandSent.data);

    bool isResponseCommand = false;

    if (command == 101) {
        LoggerFormatInfo(LOGGER, LOG_SIGN, "Получена команда сброса ошибок, код команды: %u, код блока: %u",
                         command, block)
        isResponseCommand = true;

    }

    if (command == 102) {
        LoggerFormatInfo(LOGGER, LOG_SIGN, "Получена команда обновления отчета, код команды: %u, код блока: %u",
                         command, block)
        isResponseCommand = true;
    }

    if (!isResponseCommand) {
        LoggerFormatInfo(LOGGER, LOG_SIGN, "Получена команда, код команды: %u, код блока: %u",
                         command, block)
    }

    // GNSS
    if (block == CODE_BLOCK_GNSS) {

        if (command == 101) {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Сброс ошибок")
            clearResultTest();
        }

        if (command == 102) {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Обновление отчетов блока GNSS")
            setUpdateEbu(env, &env->ebuState, EBU_GNSS, 0);
        }

    }

    if (block == CODE_BLOCK_ALL) {
        if (command == 102) {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Обновление отчетов всех блоков")
            setUpdateEbuAll(env, &env->ebuState);
        }
    }


    // ABS
    if (block == CODE_BLOCK_ABS) {

        if (command == 101) {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Сброс ошибок блока ABS")
            setUpdateEbuClearDTC(env, &env->ebuState, EBU_ABS, true);
            setUpdateEbu(env, &env->ebuState, EBU_ABS, 0);
        }

        if (command == 102) {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Обновление отчетов блока ABS")
            setUpdateEbu(env, &env->ebuState, EBU_ABS, 0);
        }
    }

    // ECM
    if (block == CODE_BLOCK_ECM) {
        if (command == 101) {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Сброс ошибок блока ECM")
            setUpdateEbuClearDTC(env, &env->ebuState, EBU_ECM, true);
            setUpdateEbu(env, &env->ebuState, EBU_ECM, 0);
        }

        if (command == 102) {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Обновление отчетов блока ECM")
            setUpdateEbu(env, &env->ebuState, EBU_ECM, 0);
        }
    }

    // HVAC
    if (block == CODE_BLOCK_HVAC) {
        if (command == 101) {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Сброс ошибок блока HVAC")
            setUpdateEbuClearDTC(env, &env->ebuState, EBU_HVAC, true);
            setUpdateEbu(env, &env->ebuState, EBU_HVAC, 0);
        }

        if (command == 102) {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Обновление отчетов блока HVAC")
            setUpdateEbu(env, &env->ebuState, EBU_HVAC, 0);
        }
    }

    // IMMO
    if (block == CODE_BLOCK_IMMO) {
        if (command == 101) {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Сброс ошибок блока IMMO")
            setUpdateEbuClearDTC(env, &env->ebuState, EBU_IMMO, true);
            setUpdateEbu(env, &env->ebuState, EBU_IMMO, 0);
        }

        if (command == 102) {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Обновление отчетов блока IMMO")
            setUpdateEbu(env, &env->ebuState, EBU_IMMO, 0);
        }
    }

    // PTS
    if (block == CODE_BLOCK_PTS) {
        if (command == 101) {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Сброс ошибок блока PTS")
            setUpdateEbuClearDTC(env, &env->ebuState, EBU_PTS, true);
            setUpdateEbu(env, &env->ebuState, EBU_PTS, 0);
        }

        if (command == 102) {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Обновление отчетов блока PTS")
            setUpdateEbu(env, &env->ebuState, EBU_PTS, 0);
        }
    }

    return EGTS_AURUS_COMMAND_RESULT_OK;
}

egtsAurusCommandResult egtsAurusSetRestart(tEgtsProcessing *env) {
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Получена команда перезагрузки устройства")
    return EGTS_AURUS_COMMAND_RESULT_RESTART_OK;
}

egtsAurusCommandResult egtsSetEnablePermanentTelematica(tEgtsProcessing *env) {

    uint8_t isRunTelematica = env->egtsCommandSent.data[0];
    LoggerFormatInfo(LOGGER, LOG_SIGN, "Получена команда удаленного включения (перманентно) телематики: %u", isRunTelematica)

    // Если телематика уже включена
    if (EXT_ENV_TELE.store.device->telematicaIsActive) {
        if (isRunTelematica) {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Телематика включена (перманентно) удаленно")
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Запись настроек не требуется")
        } else {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Телематика выключена (перманентно) удаленно")
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Запись настроек")
            EXT_ENV_TELE.store.device->telematicaIsActive = false;
            EraGlonassUveosDumper_ForceDump(EXT_ENV_TELE.store.uveosDumper);
        }

    } else {
        if (isRunTelematica) {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Телематика включена (перманентно) удаленно")
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Запись настроек")
            EXT_ENV_TELE.store.device->telematicaIsActive = true;
            EraGlonassUveosDumper_ForceDump(EXT_ENV_TELE.store.uveosDumper);
        } else {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Телематика выключена (перманентно) удаленно")
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Запись настроек не требуется")
        }

    }



    return EGTS_AURUS_COMMAND_RESULT_OK;
}

egtsAurusCommandResult egtsAurusGetState(tEgtsProcessing *env) {
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Получена команда запроса состояния")

    addTeledataQueueEvent(env, EVENT_RESPONSE);

    return EGTS_AURUS_COMMAND_RESULT_OK;
}

uint8_t VariablesTable_ExGetVarTypeLength(tVariableDescriptor *var) {

    if (var->typeId == VARIABLE_TYPE_UINT8)
        return 0x01;
    if (var->typeId == VARIABLE_TYPE_UINT16)
        return 0x02;
    if (var->typeId == VARIABLE_TYPE_STRING)
        return 0x00;
    if (var->typeId == VARIABLE_TYPE_BOOL)
        return 0x01;
    if (var->typeId == VARIABLE_TYPE_FLOAT32)
        return 0x04;
    if (var->typeId == VARIABLE_TYPE_INT32)
        return 0x04;
    if (var->typeId == VARIABLE_TYPE_UINT32)
        return 0x04;
    if (var->typeId == VARIABLE_TYPE_INT16)
        return 0x02;
    if (var->typeId == VARIABLE_TYPE_INT64)
        return 0x08;
    if (var->typeId == VARIABLE_TYPE_ARR_U8_STATIC)
        return 0x00;

    return 0;
}

egtsAurusCommandResult egtsAurusAnalizCommands(tEgtsProcessing *env) {

    env->egtsCommandSent.commandConfirmationType = CC_OK;

    if (env->egtsCommandSent.cmd == EGTS_SET_TIME) {
        return egtsAurusSetTimestamp(env);
    }

    if (env->egtsCommandSent.cmd == EGTS_SET_PERMANENT_TELEMATICA) {
        return egtsSetEnablePermanentTelematica(env);
    }

    if (env->egtsCommandSent.cmd == EGTS_GET_REPORT) {
        return egtsAurusGetReport(env);
    }

    if (env->egtsCommandSent.cmd == EGTS_SET_RESTART) {
        return egtsAurusSetRestart(env);
    }

    if (env->egtsCommandSent.cmd == EGTS_FLEET_GET_STATE) {
        return egtsAurusGetState(env);
    }

/*
    tVariableDescriptor *var = VariablesTable_GetById(&env->storage->publicVariablesTable, env->egtsCommandSent.cmd);

    if (var != NULL) {

        uint8_t typeLen = VariablesTable_ExGetVarTypeLength(var);

        if (env->egtsCommandSent.act == 2) {
            var->name.str[var->name.length] = '\0';
            env->egtsCommandSent.data[env->egtsCommandSent.dataSize] = '\0';

            uint32_t data;

            if (env->egtsCommandSent.dataSize == 4)
                data = *(uint32_t*)env->egtsCommandSent.data;

            if (env->egtsCommandSent.dataSize == 2)
                data = *(uint16_t*)env->egtsCommandSent.data;

            if (env->egtsCommandSent.dataSize == 1)
                data = *(uint8_t*)env->egtsCommandSent.data;

            if (typeLen == 0) {
                LoggerFormatInfo(LOGGER, LOG_SIGN, "Получена команда установки параметров: %s = %s", var->name.str, env->egtsCommandSent.data)
            } else {
                LoggerFormatInfo(LOGGER, LOG_SIGN, "Получена команда установки параметров: %s = %u", var->name.str, data)
            }

        }

        if (env->egtsCommandSent.act == 1) {
            var->name.str[var->name.length] = '\0';
            LoggerFormatInfo(LOGGER, LOG_SIGN, "Получена команда запроса параметров: %s", var->name.str)
        }

        if (typeLen == 0) {


            // Установка значения
            if (env->egtsCommandSent.act == 2) {

                if (env->egtsCommandSent.dataSize > var->limit)
                    env->egtsCommandSent.dataSize = var->limit;

                if (osMutexAcquire(env->storage->publicVariablesTable.writeAccess, 2000) == osOK) {

                    *(uint8_t *) var->len = env->egtsCommandSent.dataSize;
                    memcpy(var->addr, env->egtsCommandSent.data, env->egtsCommandSent.dataSize);
                    VariablesTable_VariableChanged(&env->storage->publicVariablesTable, var);

                    osMutexRelease(env->storage->publicVariablesTable.writeAccess);
                } else {
                    LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа (egtsAurusAnalizCommands)")
                }
                env->egtsCommandSent.dataSize = 0;
            }



            // Запрос значения
            if (env->egtsCommandSent.act == 1) {
                env->egtsCommandSent.dataSize = *(uint8_t *) var->len;
                memcpy(env->egtsCommandSent.data, var->addr, env->egtsCommandSent.dataSize);
            }

        } else {

            // Установка значения
            if (env->egtsCommandSent.act == 2) {

                if (osMutexAcquire(env->storage->publicVariablesTable.writeAccess, 2000) == osOK) {

                    memcpy(var->addr, env->egtsCommandSent.data, typeLen);
                    VariablesTable_VariableChanged(&env->storage->publicVariablesTable, var);

                    osMutexRelease(env->storage->publicVariablesTable.writeAccess);
                } else {
                    LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа (egtsAurusAnalizCommands)")
                }

                env->egtsCommandSent.dataSize = 0;
            }

            // Запрос значения
            if (env->egtsCommandSent.act == 1) {
                memcpy(env->egtsCommandSent.data, var->addr, typeLen);
            }
        }

        return EGTS_AURUS_COMMAND_RESULT_OK;
    }
*/
    env->egtsCommandSent.commandConfirmationType = CC_ILL;

    return EGTS_AURUS_COMMAND_RESULT_UNKNOWN;
}

void addCommandQueue(tEgtsProcessing *env, tEgtsCommand *egtsCommand) {

    osStatus_t status = osMessageQueuePut(env->egtsCommandConfirmationAdditionalData.queue, egtsCommand, 0x0, 0U);

    if (status != osOK) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка добавления в очередь addCommandQueue")
    }
}

bool extractCommandQueue(tEgtsProcessing *env, tEgtsCommand *egtsCommandSent, uint32_t timeout) {
    osStatus_t status = osMessageQueueGet(env->egtsCommandConfirmationAdditionalData.queue, egtsCommandSent, 0,
                                          timeout);

    if ((status != osOK) && (status != osErrorTimeout)) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка извлечения из очереди extractCommandQueue")
    }

    if (status == osOK) {
        return true;
    }

    return false;
}


_Noreturn void EgtsProcessing_TransmitterTaskInputCommand(tEgtsProcessing *env) {

    bool oneOn = true;
    bool oneOff = true;

    for (;;) {
        if (onOffTelematica(env, &oneOn, &oneOff, "Задача обработки команд"))
            continue;


        //начало ---------------------------------Обработка команд------------------------------------------------------
        //начало ---------------------------------Обработка команд------------------------------------------------------
        //начало ---------------------------------Обработка команд------------------------------------------------------

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

        if (extractCommandQueue(env, &env->egtsCommandSent, 1000)) {

            egtsAurusCommandResult resultCom = egtsAurusAnalizCommands(env);

            if (env->egtsCommandSent.commandConfirmationType == CC_ILL) {
                LoggerFormatInfo(LOGGER, LOG_SIGN,
                                 "Получен неизвестный код команды: %d",
                                 env->egtsCommandSent.cmd);

            }

            EgtsProcessing_SendCommandConfirmation(env,
                                                   CT_COMCONF,
                                                   env->egtsCommandSent.commandConfirmationType,
                                                   env->egtsCommandSent.cmdId,
                                                   0,

                                                   0,
                                                   0,
                                                   0,
                                                   env->egtsCommandSent.cmd,

                                                   env->egtsCommandSent.data,
                                                   env->egtsCommandSent.dataSize);


//                if (resultCom == EGTS_AURUS_COMMAND_RESULT_ERROR) {
//                    env->egtsIdentityAdditionalData.isReceivedResultCode = false;
//                    LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Принудительный разрыв соединения с сервером, ИД: %d",
//                                        env->socketId);
//                    EgtsProcessingCloseConnection(env);
//                }

            if (resultCom == EGTS_AURUS_COMMAND_RESULT_RESTART_OK) {
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Закрытие соединения")
                EgtsProcessingCloseConnection(env);
                SystemDelayMs(1000);
                EXT_ENV_TELE.osFreeRTOS.nvic_system_reset();
            }


            if (resultCom == EGTS_AURUS_COMMAND_RESULT_TIMESTAMP_TELE_STOP_OK) {
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Телематика выключена (не перманентно) удаленно")

                env->isEnableTelematicaSendPoints = false;

                if (env->deviceTeledataStorageData->telematica.EGTS_SERVER_ENABLE_TELEMATICA) {
                    env->deviceTeledataStorageData->telematica.EGTS_SERVER_ENABLE_TELEMATICA = false;
                    EraGlonassUveosDumper_ForceDump(EXT_ENV_TELE.store.uveosDumper);
                }

                env->TelematicaServerNotActiveWaitTime = SystemGetMs() + 40000;

//                if(EXT_ENV_TELE.store.device->telematicaIsActive == false){
//                    LoggerInfoStatic(LOGGER, LOG_SIGN, "Закрытие соединения")
//                    EgtsProcessingCloseConnection(env);
//                }

//                EXT_ENV_TELE.store.runtime->telematicaServerIsActive = false;
//                EXT_ENV_TELE.store.runtime->telematicaWaitConnect = true;

            }

            if (resultCom == EGTS_AURUS_COMMAND_RESULT_TIMESTAMP_TELE_RUN_OK) {
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Телематика включена (не перманентно) удаленно")

                env->isEnableTelematicaSendPoints = true;

                if (!env->deviceTeledataStorageData->telematica.EGTS_SERVER_ENABLE_TELEMATICA) {
                    env->deviceTeledataStorageData->telematica.EGTS_SERVER_ENABLE_TELEMATICA = true;
                    EraGlonassUveosDumper_ForceDump(EXT_ENV_TELE.store.uveosDumper);
                }


                EXT_ENV_TELE.store.runtime->telematicaServerIsActive = true;
                EXT_ENV_TELE.store.runtime->telematicaWaitConnect = true;
            }


        }


        //конец ---------------------------------Обработка команд-------------------------------------------------------
        //конец ---------------------------------Обработка команд-------------------------------------------------------
        //конец ---------------------------------Обработка команд-------------------------------------------------------

    }
}