//
// Created by cfif on 20.03.23.
//
#include <stddef.h>
#include <SystemDelayInterface.h>
#include <ModemMain.h>
#include <CmsisRtosThreadUtils.h>
#include "SerialPort.h"
#include "stdlib.h"
#include "string.h"
#include "httpd_types.h"
#include "httpd_base_func.h"
#include "fs_base_func.h"
#include "math.h"
#include "fs_base_func.h"
#include "file_logger.h"
#include "ModemReceiveFunc.h"
#include "ModemSendFunc.h"
#include "ModemAlmanah.h"

#define LOGGER env->logger
#define LOG_SIGN "GONEC"


bool isModemCheck(tModemMain *env) {
    if (!env->isModemCheck) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Модем ГОНЕЦ не доступен");
    }

    return env->isModemCheck;
}

// Загрузка ключей с проверкой
idPostResult_t ModemLoadKey(tModemMain *env, uint32_t key_num, char *buf, size_t buf_len) {
    bool result = false;
    if (!isModemCheck(env)) return Post_LOAD_KEY_ERR;

    if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) {


        result = Modem_LoadKey(&env->modemAt, key_num, buf, buf_len);
        if (!result) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды записи ключа в модем");
        }


        osMutexRelease(env->accessMODEM);
    } else {
        return Post_MUTEX_ERR;
    }

    if (!result)
        return Post_LOAD_KEY_ERR;

    return Post_OK;
}


// Прошивка крипто-платы
idPostResult_t ModemCryptoWrite(tModemMain *env, uint8_t *pBuf, uint32_t crc, uint32_t offset, uint32_t size) {
    bool result = false;

    if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) {

        // Останов ожидания маркерного сигнала
//        result = Modem_Stop(&env->modemAt);
//        if (!result) {
//            LoggerInfoStatic(LOGGER, LOG_SIGN,
//                             "Ошибка выполнения команды модема: Переход в режим ожидания команды (AT#STOP)");
//        }

        result = Modem_CryptoSend(&env->modemAt, pBuf, crc, offset, size);
        if (!result) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды записи в модем: Запись прошивки модема или крипто-платы (WRITE)");
        }

        // Запуск ожидания маркерного сигнала
//        result = Modem_Start(&env->modemAt);
//        if (!result) {
//            LoggerInfoStatic(LOGGER, LOG_SIGN,
//                             "Ошибка выполнения команды модема: Переход в основной режим работы (AT#START)");
//        }

        osMutexRelease(env->accessMODEM);
    } else {
        return Post_MUTEX_ERR;
    }

    if (!result)
        return Post_SET_MODEM;

    return Post_OK;
}

// Запуск получения альманаха
bool AlmaRun(tModemMain *env) {

    bool result = false;
    if (!isModemCheck(env)) return false;

    if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) {

#ifdef DEBUG_MODEM
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Запуск задачи получения альманаха");
#endif
        result = Modem_AlmaRun(&env->modemAt);
        if (!result) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Запуск получения альманаха (AT#STARTALMANACTASK)");
        }

        env->stateRequest.stateReqAlma = StateReqAlmaSendStatus;

        osMutexRelease(env->accessMODEM);
    }

    return result;
}

// Останов получения альманаха
bool AlmaStop(tModemMain *env) {

    bool result = false;
    if (!isModemCheck(env)) return false;

    if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) {

#ifdef DEBUG_MODEM
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Останов задачи получения альманаха");
#endif
        result = Modem_AlmaStop(&env->modemAt);
        if (!result) {
#ifdef DEBUG_MODEM
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Запуск получения альманаха (AT#STOPALMANACTASK)");
#endif

        }


//        env->stateRequest.stateReqAlma = StateReqAlmaNoSendStatus;

        osMutexRelease(env->accessMODEM);
    }

    return result;
}

bool ModemDateTime(tModemMain *env, time_t *timestamp) {
    bool result = false;
    if (!isModemCheck(env)) return false;

    if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) {

        // Останов ожидания маркерного сигнала
//        result = Modem_Stop(&env->modemAt);
//        if (!result) {
//            LoggerInfoStatic(LOGGER, LOG_SIGN,
//                             "Ошибка выполнения команды модема: Переход в режим ожидания команды (AT#STOP)");
//        }
        // Очистка слота
        result = Modem_DateTime(&env->modemAt, timestamp);

        if (!result) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды модема: Установка даты и времени (AT#DATETIME)");
        }

        // Запуск ожидания маркерного сигнала
//        result = Modem_Start(&env->modemAt);
//        if (!result) {
//            LoggerInfoStatic(LOGGER, LOG_SIGN,
//                             "Ошибка выполнения команды модема: Переход в основной режим работы (AT#START)");
//        }

        osMutexRelease(env->accessMODEM);
    }

    return result;
}

// Запрос чтения состояния получения альманаха
bool AlmaGetRun(tModemMain *env, uint8_t *status) {
    bool result = false;
    if (!isModemCheck(env)) return false;

//    if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) {

    // Чтение состояния
    result = Modem_Get_AlmaRun(&env->modemAt, status);

//        if (!result) {
//            LoggerInfoStatic(LOGGER, LOG_SIGN,
//                             "Ошибка выполнения команды модема: Запрос чтения состояния получения альманаха (AT#STATUSALMANACTASK)");
//        }

    if (result) {
        if (*status == 1)
            env->stateRequest.stateReqAlma = StateReqAlmaSendStatus;

        if (*status == 0)
            env->stateRequest.stateReqAlma = StateReqAlmaNoSendStatus;
    }

//        osMutexRelease(env->accessMODEM);
//    }



    return result;
}

// Запрос состояния получения альманаха
bool AlmaStatus(tModemMain *env, uint8_t *status) {
    bool result = false;
    if (!isModemCheck(env)) return false;

    if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) {

        // Чтение состояния
        result = Modem_AlmaStatus(&env->modemAt, status);

        if (!result) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды модема: Запрос состояния получения альманаха (AT#GETRESALMANACTASK)");
        }

        osMutexRelease(env->accessMODEM);
    }


    return result;
}

// Чтение альманаха
bool AlmaRead(tModemMain *env) {
    bool result = false;
    if (!isModemCheck(env)) return false;

    if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) {

        // Останов ожидания маркерного сигнала
//        result = Modem_Stop(&env->modemAt);
//        if (!result) {
//            LoggerInfoStatic(LOGGER, LOG_SIGN,
//                             "Ошибка выполнения команды модема: Переход в режим ожидания команды (AT#STOP)");
//        }
        // Чтение данных из слота
        result = Modem_Read_Alma(&env->modemAt, &env->bufReceivedPacketLen, env->bufReceivedPacket);

        if (!result) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды модема: Чтение пакета альманаха (AT#ALMAREAD)");
        }

        // Запуск ожидания маркерного сигнала
//        result = Modem_Start(&env->modemAt);
//        if (!result) {
//            LoggerInfoStatic(LOGGER, LOG_SIGN,
//                             "Ошибка выполнения команды модема: Переход в основной режим работы (AT#START)");
//        }

        osMutexRelease(env->accessMODEM);
    }

    return result;
}


// Очистка данных пакета альманаха
bool AlmaClear(tModemMain *env) {
    bool result = false;
    if (!isModemCheck(env)) return false;

    if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) {

        // Останов ожидания маркерного сигнала
//        result = Modem_Stop(&env->modemAt);
//        if (!result) {
//            LoggerInfoStatic(LOGGER, LOG_SIGN,
//                             "Ошибка выполнения команды модема: Переход в режим ожидания команды (AT#STOP)");
//        }
        // Очистка слота
        result = Modem_Clear_Alma(&env->modemAt);

        if (!result) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды модема: Очистка пакета альманаха (AT#ALMACLEAR)");
        }

        // Запуск ожидания маркерного сигнала
//        result = Modem_Start(&env->modemAt);
//        if (!result) {
//            LoggerInfoStatic(LOGGER, LOG_SIGN,
//                             "Ошибка выполнения команды модема: Переход в основной режим работы (AT#START)");
//        }

        osMutexRelease(env->accessMODEM);
    }

    return result;
}

bool ModemGetSlot(tModemMain *env, uint8_t id[], uint8_t status[], uint8_t count) {
    bool result = false;
    if (!isModemCheck(env)) return false;

    if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) {

        // Получение слотов
        result = Modem_Get_Slot(&env->modemAt, id, status, count);

        osMutexRelease(env->accessMODEM);
    }

    return result;

}

bool ModemGetLog(tModemMain *env, int32_t *rssi, int32_t *temp, uint32_t *pwramp, uint32_t *state, uint32_t *wasreboot,
                 uint32_t *size, uint8_t *pBuf) {
    bool result = false;
    if (!isModemCheck(env)) return false;

    if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) {
        // Получение логов
        result = Modem_Get_Log(&env->modemAt, rssi, temp, pwramp, state, wasreboot, size, pBuf);
        osMutexRelease(env->accessMODEM);
    }

    return result;
}

bool ModemStopSend(tModemMain *env) {
    bool result = false;
    if (!isModemCheck(env)) return false;

    if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) {

#ifdef DEBUG_MODEM
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Останов задачи передачи сообщений");
#endif

        // Останов передачи
        result = Modem_StopSendTask(&env->modemAt);
        if (!result) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды модема: Останов задачи передачи сообщений (AT#STOPSENDTASK)");

        }
        osMutexRelease(env->accessMODEM);
    }

    return result;
}


bool ModemStartSend(tModemMain *env) {
    bool result = false;
    if (!isModemCheck(env)) return false;

    if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) {

#ifdef DEBUG_MODEM
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Запуск задачи передачи сообщений");
#endif

        // Останов передачи
        result = Modem_StartSendTask(&env->modemAt);
        if (!result) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды модема: Запуск задачи передачи (AT#STARTSENDTASK)");

        }

        osMutexRelease(env->accessMODEM);
    }

    return result;
}

// Запись данных в пакет
bool SlotWrite(tModemMain *env, uint8_t id, uint32_t addressAT, uint32_t addressEND, uint32_t urgency,
               uint32_t confirmation, uint32_t lenTransPaket) {
    bool result = false;
    if (!isModemCheck(env)) return false;

    if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) {

        // Останов передачи
//        result = Modem_StopSendTask(&env->modemAt);
//        if (!result) {
//            LoggerInfoStatic(LOGGER, LOG_SIGN,
//                             "Ошибка выполнения команды модема: Останов задачи передачи (AT#STOPSENDTASK)");
//
//        }

        // Запись данных в слот
        result = Modem_Write_Slot(&env->modemAt, env->modemStatus.id[id], addressAT, addressEND, urgency,
                                  confirmation, lenTransPaket,
                                  env->bufSendPacket);
        if (!result) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды модема: Запись данных в пакет (AT#WRITEPKT)");
        }

        // Запуск передачи
//        result = Modem_StartSendTask(&env->modemAt);
//        if (!result) {
//            LoggerInfoStatic(LOGGER, LOG_SIGN,
//                             "Ошибка выполнения команды модема: Запуск задачи передачи (AT#STARTSENDTASK)");
//
//        }

        osMutexRelease(env->accessMODEM);
    }

    return result;
}


// Чтение данных из пакета
bool SlotRecvRead(tModemMain *env, uint8_t id) {
    bool result = false;
    if (!isModemCheck(env)) return false;

    if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) {

        // Чтение данных из слота
        result = Modem_Read_Recv_Slot(&env->modemAt, id, &env->bufReceivedPacketLen, env->bufReceivedPacket);

        if (!result) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды модема: Чтение данных из пакета (AT#READPKT)");
        }

        osMutexRelease(env->accessMODEM);
    }

    return result;
}

// Очистка данных из пакета приема
bool SlotRecvClear(tModemMain *env, char *id) {
    bool result = false;
    if (!isModemCheck(env)) return false;

    if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) {

        // Останов приема
//        result = Modem_StopRecvTask(&env->modemAt);
//        if (!result) {
//            LoggerInfoStatic(LOGGER, LOG_SIGN,
//                             "Ошибка выполнения команды модема: Останов задачи приема (AT#STOPRECVTASK)");
//        }

        // Очистка слота
        result = Modem_Clear_Recv_Slot(&env->modemAt, id);

        if (!result) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды модема: Очистка пакета (AT#DELRECVPKT)");
        }

        // Старт приема
//        result = Modem_StartRecvTask(&env->modemAt);
//        if (!result) {
//            LoggerInfoStatic(LOGGER, LOG_SIGN,
//                             "Ошибка выполнения команды модема: Запуск задачи приема (AT#STARTRECVTASK)");
//        }

        osMutexRelease(env->accessMODEM);
    }

    return result;
}

// Получение состояния слотов приема
bool ModemGetRecvSlot(tModemMain *env, uint8_t id[], uint8_t status[], uint8_t count) {
    bool result = false;
    if (!isModemCheck(env)) return false;

    if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) {

        result = Modem_Get_Recv_Slot(&env->modemAt, id, status, count);

        osMutexRelease(env->accessMODEM);
    }

    return result;
}

// Очистка данных из пакета
bool SlotClearNoStartTask(tModemMain *env, char *id) {
    bool result = false;
    if (!isModemCheck(env)) return false;

    if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) {

        env->modemWorkingState = MODEM_WORKING_NONE;

        // Останов передачи
        result = Modem_StopSendTask(&env->modemAt);
        if (!result) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды модема: Останов задачи передачи (AT#STOPSENDTASK)");
        }

        // Очистка слота
        result = Modem_Clear_Slot(&env->modemAt, id);

        if (!result) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды модема: Очистка пакета (AT#DELSENDPKT)");
        }

        osMutexRelease(env->accessMODEM);
    }

    return result;
}

// Очистка данных из пакета
bool SlotClearNoStopTask(tModemMain *env, char *id) {
    bool result = false;
    if (!isModemCheck(env)) return false;

    if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) {

        // Очистка слота
        result = Modem_Clear_Slot(&env->modemAt, id);

        if (!result) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды модема: Очистка пакета (AT#DELSENDPKT)");
        }

        osMutexRelease(env->accessMODEM);
    }

    return result;
}

// Очистка данных из пакета
bool SlotClear(tModemMain *env, char *id) {
    bool result = false;
    if (!isModemCheck(env)) return false;

    if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) {

        // Останов передачи
        result = Modem_StopSendTask(&env->modemAt);
        if (!result) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды модема: Останов задачи передачи (AT#STOPSENDTASK)");
        }

        // Очистка слота
        result = Modem_Clear_Slot(&env->modemAt, id);

        if (!result) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды модема: Очистка пакета (AT#DELSENDPKT)");
        }

        // Старт передачи
        result = Modem_StartSendTask(&env->modemAt);
        if (!result) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды модема: Запуск задачи передачи (AT#STARTSENDTASK)");
        }

        osMutexRelease(env->accessMODEM);
    }

    return result;
}


idPostResult_t ModemGetInitAt(tModemMain *env, bool *isWriteMem, bool grp1, bool grp2, bool grp3, bool grp25) {
    bool ret;
    bool b1 = false, b2 = false, b3 = false, b4 = false, /*b5 = false,*/ b6 = false, b7 = false, b8 = false, b9 = false, b10 = false;
    bool b11 = false, /*b12 = false,*/ b13 = false, b14 = false;
    bool b15 = false;
    bool b16 = false;
    bool b17 = false;

    *isWriteMem = false;

    if (!isModemCheck(env)) return Post_SET_MODEM;

    uint32_t value1;
    uint32_t value2;
    uint32_t value3;
    uint32_t value4;
    char valueStr255[255];

    bool isErrorAtModem = false;


//    if ((grp1) || (grp2) || (grp3)) {
    // Останов ожидания маркерного сигнала
//        ret = Modem_Stop(&env->modemAt);
//        if (!ret) {
//            LoggerInfoStatic(LOGGER, LOG_SIGN,
//                             "Ошибка выполнения команды модема: Переход в режим ожидания команды (AT#STOP)");
//            return Post_SET_MODEM;
//        }
//    }

    if (grp1) {
        // Ввод сетевого адреса модема - 1
        ret = Modem_Get_NetAddress(&env->modemAt, &b2, env->store->runtime.Settings_General.ATnum_v, &value1);
        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка выполнения команды чтения из модема: Сетевой адрес AT (AT#NETADDRESS)");
            isErrorAtModem = true;
        }
        if (b2)
            env->store->runtime.Settings_General.ATnum_v = value1;

        // Установка приоритета - 2
        ret = Modem_Get_Priority(&env->modemAt, &b7, env->store->runtime.Settings_General.ATpriority_v, &value1);
        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды чтения из модема: Приоритет AT (AT#PRIORITY)");
            isErrorAtModem = true;
        }
        if (b7)
            env->store->runtime.Settings_General.ATpriority_v = value1;


        // Запрещенные КА - 10
        if (strlen(env->store->runtime.BannedSAT_ex) > 0) {

        } else {
            ret = Modem_Get_RestrictSc(&env->modemAt, &b8, env->store->runtime.Settings_General.BannedSAT_v,
                                       valueStr255);
        }

        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды чтения из модема: Запрещенные КА (AT#RESTRICTSC)");
            isErrorAtModem = true;
        }

        if (b8) {
            memset(env->store->runtime.Settings_General.BannedSAT_v, 0, sizeof(valueStr255));
            strcpy(env->store->runtime.Settings_General.BannedSAT_v, valueStr255);
        }

    }


    if (grp2) {
        // Ввод каналов ожидания маркерного сигнала 18, 19
        ret = Modem_Get_MarkerCh(&env->modemAt, &b3, env->store->runtime.Settings_Frequency_Speed.freqMC1_v,
                                 env->store->runtime.Settings_Frequency_Speed.freqMC2_v, &value1, &value2);
        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка выполнения команды чтения из модема: Номер частоты МС1, MC2 (MARKERCH)");
            isErrorAtModem = true;
        }

        if (b3) {
            env->store->runtime.Settings_Frequency_Speed.freqMC1_v = value1;
            env->store->runtime.Settings_Frequency_Speed.freqMC2_v = value2;
        }


        // Установка скоростей - 20
        ret = Modem_Get_RxTxBitrate(&env->modemAt, &b6, env->store->runtime.Settings_Frequency_Speed.SpeedPKsig_v,
                                    env->store->runtime.Settings_Frequency_Speed.SpeedPKdata_v,
                                    env->store->runtime.Settings_Frequency_Speed.SpeedOKsig_v,
                                    env->store->runtime.Settings_Frequency_Speed.SpeedOKdata_v,
                                    &value1, &value2, &value3, &value4);
        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды чтения из модема: Скорости ПК, ОК каналов данных (AT#RXTXBITRATE)");
            isErrorAtModem = true;
        }

        if (b6) {
            env->store->runtime.Settings_Frequency_Speed.SpeedPKsig_v = value1;
            env->store->runtime.Settings_Frequency_Speed.SpeedPKdata_v = value2;
            env->store->runtime.Settings_Frequency_Speed.SpeedOKsig_v = value3;
            env->store->runtime.Settings_Frequency_Speed.SpeedOKdata_v = value4;
        }


        // 25
        ret = Modem_Get_DelTasi(&env->modemAt, &b1, env->store->runtime.Settings_Frequency_Speed.SItimeAdv_v,
                                &value1);
        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды чтения из модема: Опережение СИ борта (AT#DELTASI)");
            isErrorAtModem = true;
        }

        if (b1)
            env->store->runtime.Settings_Frequency_Speed.SItimeAdv_v = value1;

        // Установка региона - 29
        ret = Modem_Get_RegRegion(&env->modemAt, &b9, env->store->runtime.Settings_Frequency_Speed.RegionRegistr_v,
                                  &value1);
        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды чтения из модема: Георегион регистрации (AT#REGREGION)");
            isErrorAtModem = true;
        }

        if (b9)
            env->store->runtime.Settings_Frequency_Speed.RegionRegistr_v = value1;

        // Время жизни регистрации - 28
        ret = Modem_Get_RegTime(&env->modemAt, &b10, env->store->runtime.Settings_Frequency_Speed.TimeLifeRegistr_v,
                                &value1);
        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды чтения из модема: Время жизни регистрации (AT#REGTIME)");
            isErrorAtModem = true;
        }

        if (b10)
            env->store->runtime.Settings_Frequency_Speed.TimeLifeRegistr_v = value1;




        // Максимальная дальность до КА
        ret = Modem_Get_MaxDist(&env->modemAt, &b15, env->store->runtime.Settings_Frequency_Speed.MaxDistanceSAT_v,
                                &value1);
        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды чтения из модема: Максимальная дальность до КА (AT#MAXDIST)");
            isErrorAtModem = true;
        }

        if (b15)
            env->store->runtime.Settings_Frequency_Speed.MaxDistanceSAT_v = value1;

        // Запрещенные георегионы
//        if (strlen(env->store->runtime.Settings_Frequency_Speed.AllowedReg_v) > 0) {
        ret = Modem_Get_Reg(&env->modemAt, &b16, env->store->runtime.Settings_Frequency_Speed.AllowedReg_v,
                            valueStr255);
        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды чтения из модема: Разрешенные георегионы (AT#REGION)");
            isErrorAtModem = true;
//            }
        }

        if (b16) {
            memset(env->store->runtime.Settings_Frequency_Speed.AllowedReg_v, 0, sizeof(valueStr255));
            strcpy(env->store->runtime.Settings_Frequency_Speed.AllowedReg_v, valueStr255);
        }


    }

    if (grp3) {


        // Периодичность запроса на съем, МС:
        ret = Modem_Get_PerDown(&env->modemAt, &b17, env->store->runtime.Settings_Basic_Access.PerReqDown_v,
                                &value1);
        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды чтения из модема: Периодичность запроса на съем, МС (AT#PERDOWN)");
            isErrorAtModem = true;
        }

        if (b17)
            env->store->runtime.Settings_Basic_Access.PerReqDown_v = value1;


        // Ввод тип адреса 2 - косвенный; 1 - прямой
        ret = Modem_Get_AddressType(&env->modemAt, &b4,
                                    env->store->runtime.Settings_Basic_Access.TypeAddressing_v - 1,
                                    &value1);
        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды чтения из модема: Режим доступа (AT#ADDRESSTYPE)");
            isErrorAtModem = true;
        }

        if (b4)
            env->store->runtime.Settings_Basic_Access.TypeAddressing_v = value1 - 1;
    }

    if (grp25) {

        ret = Modem_Get_TransmitterPWR(&env->modemAt, &b11,
                                       env->store->runtime.Settings_Transmitter.CorPwr1,
                                       env->store->runtime.Settings_Transmitter.CorPwr2,
                                       env->store->runtime.Settings_Transmitter.CorPwr3,
                                       env->store->runtime.Settings_Transmitter.CorPwr4,
                                       &value1,
                                       &value2,
                                       &value3,
                                       &value4);
        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды чтения из модема: Коррекция передатчика (AT#SETUPPWR)");
            isErrorAtModem = true;
        }

        if (b11) {
            env->store->runtime.Settings_Transmitter.CorPwr1 = value1;
            env->store->runtime.Settings_Transmitter.CorPwr2 = value2;
            env->store->runtime.Settings_Transmitter.CorPwr3 = value3;
            env->store->runtime.Settings_Transmitter.CorPwr4 = value4;
        }


        ret = Modem_Get_SelectPWR(&env->modemAt, &b14, env->store->runtime.Settings_Transmitter.SelectCorPwr, &value1);

        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды чтения из модема: Выбор параметра мощности (AT#SELECTPWR)");
            isErrorAtModem = true;
        }

        if (b14) {
            env->store->runtime.Settings_Transmitter.SelectCorPwr = value1;
        }


        ret = Modem_Get_LogExtended(&env->modemAt, &b13,
                                    env->store->runtime.Settings_Transmitter.LogExtendedEn,
                                    &value1);
        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды чтения из модема: Разрешение системных логов (AT#SYSLOGENABLE)");
            isErrorAtModem = true;
        }

        if (b13)
            env->store->runtime.Settings_Transmitter.LogExtendedEn = value1;


    }

    //
//    ret = Modem_Region(&env->modemAt, &b5, 1, 11, 25, 33, 49, 52, 51, 8);
//    if (!ret)
//        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка выполнения команды REGION");


//    if ((grp1) || (grp2) || (grp3)) {
    // Запуск ожидания маркерного сигнала
//        ret = Modem_Start(&env->modemAt);
//        if (!ret) {
//            LoggerInfoStatic(LOGGER, LOG_SIGN,
//                             "Ошибка выполнения команды модема: Переход в основной режим работы (AT#START)");
//            return Post_SET_MODEM;
//        }
//    }

    // Если было изменение настроек, записать в настройки
    if ((b1) || (b2) || (b3) || (b4) || /*(b5) ||*/ (b6) || (b7) || (b8) || (b9) || (b10) || (b11) ||
        /*(b12) ||*/ (b13) || (b14) || (b15) || (b16) || (b17)) {
        *isWriteMem = true;
    }

    if (isErrorAtModem) {
        return Post_SET_MODEM;
    }


    return Post_OK;
}

idPostResult_t ModemInitAt(tModemMain *env, bool grp1, bool grp2, bool grp3, bool grp25) {
    bool ret;
    bool b1 = false, b2 = false, b3 = false, b4 = false, /*b5 = false,*/ b6 = false, b7 = false, b8 = false, b9 = false, b10 = false;
    bool b11 = false, /*b12 = false,*/ b13 = false;
    bool b14 = false;
    bool b15 = false;
    bool b16 = false;
    bool b17 = false;

    if (!isModemCheck(env)) return Post_SET_MODEM;

//    if ((grp1) || (grp2) || (grp3)) {
    // Останов ожидания маркерного сигнала
//        ret = Modem_Stop(&env->modemAt);
//        if (!ret) {
//            LoggerInfoStatic(LOGGER, LOG_SIGN,
//                             "Ошибка выполнения команды модема: Переход в режим ожидания команды (AT#STOP)");
//            return Post_SET_MODEM;
//        }
//    }

    bool isErrorAtModem = false;

    if (grp1) {
        // Ввод сетевого адреса модема - 1
        ret = Modem_NetAddress(&env->modemAt, &b2, env->store->runtime.Settings_General.ATnum_v);
        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка выполнения команды записи в модем: Сетевой адрес AT (AT#NETADDRESS)");
            isErrorAtModem = true;
        }

        // Установка приоритета - 2
        ret = Modem_Priority(&env->modemAt, &b7, env->store->runtime.Settings_General.ATpriority_v);
        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды записи в модем: Приоритет AT (AT#PRIORITY)");
            isErrorAtModem = true;
        }
        // Запрещенные КА - 10
//        if (strlen(env->store->runtime.Settings_General.BannedSAT_v) > 0) {
        ret = Modem_RestrictSc(&env->modemAt, &b8, env->store->runtime.Settings_General.BannedSAT_v);
        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды записи в модем: Запрещенные КА (AT#RESTRICTSC)");
            isErrorAtModem = true;
//            }
        }

    }


    if (grp2) {
        // Ввод каналов ожидания маркерного сигнала 18, 19
        ret = Modem_MarkerCh(&env->modemAt, &b3, env->store->runtime.Settings_Frequency_Speed.freqMC1_v,
                             env->store->runtime.Settings_Frequency_Speed.freqMC2_v);
        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка выполнения команды записи в модем: Номер частоты МС1, MC2 (MARKERCH)");
            isErrorAtModem = true;
        }

        // Установка скоростей - 20
        ret = Modem_RxTxBitrate(&env->modemAt, &b6, env->store->runtime.Settings_Frequency_Speed.SpeedPKsig_v,
                                env->store->runtime.Settings_Frequency_Speed.SpeedPKdata_v,
                                env->store->runtime.Settings_Frequency_Speed.SpeedOKsig_v,
                                env->store->runtime.Settings_Frequency_Speed.SpeedOKdata_v);
        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды записи в модем: Скорости ПК, ОК каналов данных (AT#RXTXBITRATE)");
            isErrorAtModem = true;
        }

        // 25
        ret = Modem_DelTasi(&env->modemAt, &b1, env->store->runtime.Settings_Frequency_Speed.SItimeAdv_v);
        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды записи в модем: Опережение СИ борта (AT#DELTASI)");
            isErrorAtModem = true;
        }

        // Установка региона - 29
        ret = Modem_RegRegion(&env->modemAt, &b9, env->store->runtime.Settings_Frequency_Speed.RegionRegistr_v);
        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды записи в модем: Георегион регистрации (AT#REGREGION)");
            isErrorAtModem = true;
        }

        // Время жизни регистрации - 28
        ret = Modem_RegTime(&env->modemAt, &b10, env->store->runtime.Settings_Frequency_Speed.TimeLifeRegistr_v);
        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды записи в модем: Время жизни регистрации (AT#REGTIME)");
            isErrorAtModem = true;
        }


        // Максимальная дальность до КА
        ret = Modem_MaxDist(&env->modemAt, &b15, env->store->runtime.Settings_Frequency_Speed.MaxDistanceSAT_v);
        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды записи в модем: Максимальная дальность до КА (AT#MAXDIST)");
            isErrorAtModem = true;
        }

        // Запрещенные георегионы
        ret = Modem_Reg(&env->modemAt, &b16, env->store->runtime.Settings_Frequency_Speed.AllowedReg_v);
        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды записи в модем: Разрешенные георегионы (AT#REGION)");
            isErrorAtModem = true;
        }

    }

    if (grp3) {

        // Периодичность запроса на съем, МС:
        ret = Modem_PerDown(&env->modemAt, &b17, env->store->runtime.Settings_Basic_Access.PerReqDown_v);
        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды записи в модема: Периодичность запроса на съем, МС (AT#PERDOWN)");
            isErrorAtModem = true;
        }


        // Ввод тип адреса 2 - косвенный; 1 - прямой

        ret = Modem_AddressType(&env->modemAt, &b4, env->store->runtime.Settings_Basic_Access.TypeAddressing_v + 1);
        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды записи в модем: Режим доступа (AT#ADDRESSTYPE)");
            isErrorAtModem = true;
        }

    }


    if (grp25) {

        ret = Modem_TransmitterPWR(&env->modemAt, &b11, env->store->runtime.Settings_Transmitter.CorPwr1,
                                   env->store->runtime.Settings_Transmitter.CorPwr2,
                                   env->store->runtime.Settings_Transmitter.CorPwr3,
                                   env->store->runtime.Settings_Transmitter.CorPwr4);
        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды записи в модем: Коррекция передатчика (AT#SETUPPWR)");
            isErrorAtModem = true;
        }

        ret = Modem_SelectPWR(&env->modemAt, &b14, env->store->runtime.Settings_Transmitter.SelectCorPwr);

        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды модема: Выбор параметра мощности (AT#SELECTPWR)");
        }


//        ret = Modem_LogEnable(&env->modemAt, &b12, env->store->runtime.Settings_Transmitter.LogEn);
//        if (!ret) {
//            LoggerInfoStatic(LOGGER, LOG_SIGN,
//                             "Ошибка выполнения команды записи в модем: Разрешение логов (AT#LOGENABLE)");
//            isErrorAtModem = true;
//        }

        ret = Modem_LogExtended(&env->modemAt, &b13, env->store->runtime.Settings_Transmitter.LogExtendedEn);
        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды записи в модем: Разрешение системных логов (AT#SYSLOGENABLE)");
            isErrorAtModem = true;
        }

    }


    //
//    ret = Modem_Region(&env->modemAt, &b5, 1, 11, 25, 33, 49, 52, 51, 8);
//    if (!ret)
//        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка выполнения команды REGION");


    // Если было изменение настроек, записать во флеш модема
    if ((b1) || (b2) || (b3) || (b4) || /*(b5) ||*/ (b6) || (b7) || (b8) || (b9) || (b10) || (b11) ||
        /* (b12) ||*/ (b13) || (b14) || (b15) || (b16) || (b17)) {
        // Запись во флеш модема
        ret = Modem_WriteMem(&env->modemAt);
        if (!ret) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды: Запись текущих настроек в память (AT#WRITEMEM)");
            isErrorAtModem = true;
        }
    }

//    if ((grp1) || (grp2) || (grp3)) {
    // Запуск ожидания маркерного сигнала
//        ret = Modem_Start(&env->modemAt);
//        if (!ret) {
//            LoggerInfoStatic(LOGGER, LOG_SIGN,
//                             "Ошибка выполнения команды модема: Переход в основной режим работы (AT#START)");
//            return Post_SET_MODEM;
//        }
//    }

    if (isErrorAtModem) {
        return Post_SET_MODEM;
    } else {
        return Post_OK;
    }
}

// Переход в основной режим работы
idPostResult_t ModemStartAt(tModemMain *env) {
    bool ret;

    // Запуск ожидания маркерного сигнала
    ret = Modem_Start(&env->modemAt);
    if (!ret) {
        LoggerInfoStatic(LOGGER, LOG_SIGN,
                         "Ошибка выполнения команды модема: Переход в основной режим работы (AT#START)");
        return Post_SET_MODEM;
    }

    return Post_OK;
}




// Запрос версий
bool Modem_Get_Version_Modem(tModemMain *env, char *versionModem, uint8_t *sizeModem, char *versionCrypto,
                             uint8_t *sizeCrypto) {
    bool result = false;

    if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) {


        result = Modem_Get_Version(&env->modemAt, versionModem, sizeModem, versionCrypto, sizeCrypto);

        if (!result) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды модема: Запрос версий (VERSION)");
        }

        osMutexRelease(env->accessMODEM);
    }

    return result;
}

// Запуск прошивки
bool RunModemOrCrypto(tModemMain *env) {
    bool result = false;

    if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) {

        // Запуск прошивки
        result = Modem_RunModemOrCrypto(&env->modemAt);

        if (!result) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды модема: Запуск прошивки (RUN)");
        }

        osMutexRelease(env->accessMODEM);
    }

    return result;
}



// Запуск регистрации
bool StartRegTask(tModemMain *env) {
    bool result = false;
    if (!isModemCheck(env)) return false;

    if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) {

#ifdef DEBUG_MODEM
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Запуск задачи регистрации");
#endif
        // Останов ожидания маркерного сигнала
//        result = Modem_Stop(&env->modemAt);
//        if (!result) {
//            LoggerInfoStatic(LOGGER, LOG_SIGN,
//                             "Ошибка выполнения команды модема: Переход в режим ожидания команды (AT#STOP)");
//        }

        result = Modem_StartRegTask(&env->modemAt);

        if (!result) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды модема: Запуск регистрации (AT#STARTREGTASK)");
        }

        // Запуск ожидания маркерного сигнала
//        result = Modem_Start(&env->modemAt);
//        if (!result) {
//            LoggerInfoStatic(LOGGER, LOG_SIGN,
//                             "Ошибка выполнения команды модема: Переход в основной режим работы (AT#START)");
//        }

        osMutexRelease(env->accessMODEM);
    }

    return result;
}

// Останов регистрации
bool StopRegTask(tModemMain *env) {
    bool result = false;
    if (!isModemCheck(env)) return false;

    if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) {


#ifdef DEBUG_MODEM
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Останов задачи регистрации");
#endif

        // Останов ожидания маркерного сигнала
//        result = Modem_Stop(&env->modemAt);
//        if (!result) {
//            LoggerInfoStatic(LOGGER, LOG_SIGN,
//                             "Ошибка выполнения команды модема: Переход в режим ожидания команды (AT#STOP)");
//        }

        result = Modem_StopRegTask(&env->modemAt);

        if (!result) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды модема: Останов регистрации (AT#STOPREGTASK)");
        }

        // Запуск ожидания маркерного сигнала
//        result = Modem_Start(&env->modemAt);
//        if (!result) {
//            LoggerInfoStatic(LOGGER, LOG_SIGN,
//                             "Ошибка выполнения команды модема: Переход в основной режим работы (AT#START)");
//        }

        osMutexRelease(env->accessMODEM);
    }

    return result;
}

// Запрос статуса регистрации
bool ModemGetRegStatus(tModemMain *env, uint8_t *status) {
    bool result = false;
    if (!isModemCheck(env)) return false;

    if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) {

        // Чтение состояния
        result = Modem_RegStatus(&env->modemAt, status);

        if (!result) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды модема: Запрос состояния регистрации (AT#GETREGSTATUS)");
        }

        osMutexRelease(env->accessMODEM);
    }


    return result;
}


// Установка координат
bool ModemSet_Coord(tModemMain *env, int latitude, int longitude) {
    bool result = false;
    if (!isModemCheck(env)) return false;

    if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) {

        // Останов ожидания маркерного сигнала
//        result = Modem_Stop(&env->modemAt);
//        if (!result) {
//            LoggerInfoStatic(LOGGER, LOG_SIGN,
//                             "Ошибка выполнения команды модема: Переход в режим ожидания команды (AT#STOP)");
//        }

        result = Modem_Coord(&env->modemAt, latitude, longitude);

        if (!result) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды модема: Установка координат (AT#SETCOORD)");
        }

        // Запуск ожидания маркерного сигнала
//        result = Modem_Start(&env->modemAt);
//        if (!result) {
//            LoggerInfoStatic(LOGGER, LOG_SIGN,
//                             "Ошибка выполнения команды модема: Переход в основной режим работы (AT#START)");
//        }

        osMutexRelease(env->accessMODEM);
    }


    return result;
}


bool TestAFU(tModemMain *env) {
    bool result = false;
    if (!isModemCheck(env)) return false;

    if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) {

        // Чтение данных из слота
        result = Modem_TestAFU(&env->modemAt);

        if (!result) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды модема: Запуск теста АФУ (AT#TESTAFU)");
        }

        osMutexRelease(env->accessMODEM);
    }

    return result;
}

bool TestAPO(tModemMain *env) {
    bool result = false;
    if (!isModemCheck(env)) return false;

    if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) {

        result = Modem_TestAPO(&env->modemAt);

        if (!result) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды модема: Запуск приемника в режиме измерения шума (AT#RSSIAPO)");
        }

        osMutexRelease(env->accessMODEM);
    }

    return result;
}

bool SetRoutingRestrictSc(tModemMain *env, char *banned) {
    bool result = false;
    if (!isModemCheck(env)) return false;

    if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) {

        bool fl;
        result = Modem_RestrictSc(&env->modemAt, &fl, banned);
        if (!result) {
            LoggerInfoStatic(LOGGER, LOG_SIGN,
                             "Ошибка выполнения команды записи в модем: Запрещенные КА (AT#RESTRICTSC)");
        }

        osMutexRelease(env->accessMODEM);
    }

    return result;
}