#include <stddef.h>
#include <memory.h>
#include "ModemDataCollector.h"
#include "BaseTypes/Strings.h"
#include "AtCmdBase.h"
//#include "AtCmdCommonProtected.h"
#include "VariablesTable.h"
#include "DeviceStorage.h"
#include "SystemDelayInterface.h"
#include "AtGsmSimComA7600_SSL_LOAD_CA.h"
//#include "PowerManagment.h"

//
// Created by zemon on 28.08.24.
//
#define LOG_SIGN "Сборщик данных модема"
#define LOGGER env->logger

void ModemDataCollectorItit(
        tModemDataColl *env,
        tSim7600ePower *sim7600ePower,
        tLoggerInterface *logger,
        tAtCmd *gsmAt,
        tDeviceStorage *storage,
        tSystemSelector *systemSelector
) {

    env->modemVersionRevision.validAudio = MOD_ERROR;
    env->modemVersionRevision.sertRevision.validSert = MOD_ERROR;
    env->modemVersionRevision.modemStateIsValid = false;
    env->fl_IsLoad = false;
    env->modemVersionRevision.valid_CCID = MOD_UNDEFANDED;
    env->modemVersionRevision.valid_CCIDComer = MOD_UNDEFANDED;

    env->logger = logger;
    env->gsmAt = gsmAt;
    env->storage = storage;
    env->sim7600ePower = sim7600ePower;
    env->systemSelector = systemSelector;
    tVariableDescriptor *var;
    env->modemVersionRevision.resIsChipSelect = false;

    env->timeIsTestModemLimit = SystemGetMs() + 60000;

    var = VariablesTable_GetByNameStatic(&env->storage->publicVariablesTable, "GSM_SIM_PROFILE");
    if (var->len) {
        env->simProfile.length = var->len;
        env->simProfile.data = var->addr;
    }
}

// окерпичиватель модема
void ModemDataCollector_ModemFlashing(tModemDataColl *env) {
    env->storage->nvm->device.factoryMode = true;
    EraGlonassUveosDumper_ForceDump(&env->storage->uveosDumper);
    AtGsm_Gsnss_Simcom7600_GnssStopThread(env->gsmAt);
    LoggerInfoStatic(LOGGER, LOG_SIGN,
                     "Инициализирован повторный переход в режим производственного контроля, команда получена по UDS")
}

void ModemDataCollector_GeIds(tModemDataColl *env) {
    tVariableDescriptor *var;

    if (env->sim7600ePower->thisSimChip == CHIP_ERA) {
        var = VariablesTable_GetByNameStatic(&env->storage->publicVariablesTable, "GSM_CCID");
    } else {
        var = VariablesTable_GetByNameStatic(&env->storage->publicVariablesTable, "GSM_CCID_COMERS");
    }

    if (var->len) {
        tStringLink idValueIsStorage = {
                .length = var->len,
                .data = var->addr
        };

        size_t length;
        AtCommandResult resIds_readIdEra = AT_ERROR;
        AtCommandResult resIds_readIdComers = AT_ERROR;

        if (osMutexAcquire(env->gsmAt->access, 4000) == osOK) {
            if (env->sim7600ePower->thisSimChip == CHIP_ERA) {
                resIds_readIdEra = AtGsm_Gsnss_Simcom7600_GetCCID(env->gsmAt, env->modemVersionRevision.ssidValue.data,
                                                                  &length);
                env->modemVersionRevision.ssidValue.length = length;
            } else {
                resIds_readIdComers = AtGsm_Gsnss_Simcom7600_GetCCID(env->gsmAt,
                                                                     env->modemVersionRevision.ssidComersValue.data,
                                                                     &length);
                env->modemVersionRevision.ssidComersValue.length = length;
            }
            osMutexRelease(env->gsmAt->access);
        } else {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления Mma_GetCGSN_1")
        }

        if (var->len) {
            if (env->sim7600ePower->thisSimChip == CHIP_ERA) {
                if (resIds_readIdEra == AT_OK) {
                    if (
                            (memcmp(env->modemVersionRevision.ssidValue.data, idValueIsStorage.data, length) != 0) ||
                            (env->modemVersionRevision.ssidValue.length != *idValueIsStorage.length)
                            ) {

                        memcpy(idValueIsStorage.data, env->modemVersionRevision.ssidValue.data, length);
                        *idValueIsStorage.length = length;
                        env->modemVersionRevision.ssidValue.length = length;
                        DeviceStorage_DelayedDump(env->storage);
                    }
                    env->modemVersionRevision.valid_CCID = MOD_READY;

                } else {
                    length = 19;
                    if (
                            (memcmp(idValueIsStorage.data, "1111111111111111111", length) == 0) &&
                            (*idValueIsStorage.length == length)
                            ) {
                        memcpy(env->modemVersionRevision.ssidValue.data, idValueIsStorage.data, length);
                        env->modemVersionRevision.ssidValue.length = length;
                        env->modemVersionRevision.valid_CCID = MOD_ERROR;
                        return;
                    } else {
                        memcpy(idValueIsStorage.data, "1111111111111111111", length);
                        memcpy(env->modemVersionRevision.ssidValue.data, idValueIsStorage.data, length);
                        *idValueIsStorage.length = length;
                        env->modemVersionRevision.ssidValue.length = length;
                        env->modemVersionRevision.valid_CCID = MOD_ERROR;
                        DeviceStorage_DelayedDump(env->storage);
                    }
                }
            }

            if (env->sim7600ePower->thisSimChip == CHIP_COMERS) {
                env->modemVersionRevision.ssidComersValue.length = length;
                if (resIds_readIdComers == AT_OK) {
                    if (
                            (memcmp(env->modemVersionRevision.ssidComersValue.data, idValueIsStorage.data, length) !=
                             0) ||
                            (env->modemVersionRevision.ssidComersValue.length != *idValueIsStorage.length)
                            ) {

                        *idValueIsStorage.length = length;
                        memcpy(idValueIsStorage.data, env->modemVersionRevision.ssidComersValue.data, length);
                        env->modemVersionRevision.ssidComersValue.length = length;
                        DeviceStorage_DelayedDump(env->storage);
                    }
                    env->modemVersionRevision.valid_CCIDComer = MOD_READY;
                } else {
                    length = 20;
                    if (
                            (memcmp(idValueIsStorage.data, "1111111111111111111", length) == 0) &&
                            (*idValueIsStorage.length == 20)
                            ) {
                        memcpy(env->modemVersionRevision.ssidComersValue.data, idValueIsStorage.data, length);
                        env->modemVersionRevision.ssidComersValue.length = length;
                        env->modemVersionRevision.valid_CCIDComer = MOD_ERROR;
                        return;
                    } else {
                        memcpy(idValueIsStorage.data, "1111111111111111111", length);
                        memcpy(env->modemVersionRevision.ssidComersValue.data, idValueIsStorage.data, length);
                        *idValueIsStorage.length = length;
                        env->modemVersionRevision.ssidComersValue.length = length;
                        env->modemVersionRevision.valid_CCIDComer = MOD_ERROR;
                        DeviceStorage_DelayedDump(env->storage);
                    }
                }
            }
        }
    }
}

void ModemDataCollector_GetCGSN(tModemDataColl *env) {
    tVariableDescriptor *var = VariablesTable_GetByNameStatic(&env->storage->publicVariablesTable, "GSM_CGSN");
    if (var->len) {
        tStringLink cgsmidValueStorage = {
                .length = var->len,
                .data = var->addr
        };

        size_t length;
        AtCommandResult resGetCGSN = AT_ERROR;
        if (osMutexAcquire(env->gsmAt->access, 2000) == osOK) {
            resGetCGSN = AtGsm_Gsnss_Simcom7600_GetCGSN(env->gsmAt, env->modemVersionRevision.cgsmValue.data, &length);
            osMutexRelease(env->gsmAt->access);
        } else {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления Mma_GetCGSN_4")
        }
        if (var->len) {
            if (resGetCGSN == AT_OK) {
                env->modemVersionRevision.cgsmValue.length = length;
                if (
                        (memcmp(env->modemVersionRevision.cgsmValue.data, cgsmidValueStorage.data, length) != 0) ||
                        (env->modemVersionRevision.cgsmValue.length != *cgsmidValueStorage.length)
                        ) {
                    memcpy(cgsmidValueStorage.data, env->modemVersionRevision.cgsmValue.data, length);
                    *cgsmidValueStorage.length = length;
                    env->modemVersionRevision.cgsmValue.length = length;
                    DeviceStorage_DelayedDump(env->storage);
                }
            } else {
                length = 20;
                if (
                        (memcmp(cgsmidValueStorage.data, "1111111111111111111", length) == 0) &&
                        (*cgsmidValueStorage.length == 20)
                        ) {
                    memcpy(env->modemVersionRevision.cgsmValue.data, cgsmidValueStorage.data, length);
                    env->modemVersionRevision.cgsmValue.length = length;
                    return;
                } else {
                    memcpy(cgsmidValueStorage.data, "1111111111111111111", length);
                    memcpy(env->modemVersionRevision.cgsmValue.data, cgsmidValueStorage.data, length);
                    *cgsmidValueStorage.length = length;
                    env->modemVersionRevision.cgsmValue.length = length;
                    DeviceStorage_DelayedDump(env->storage);
                }
            }

        }
    }
}

bool DeviceTesting_ValidAsCerts(tIsFind *env) {
    if ((env->isFind1) &&
        (env->isFind2) &&
        (env->isFind3)
            ) {
        return true;
    } else {
        return false;
    }
}

void ModemDataCollector_GetSertRev(tModemDataColl *env) {
    if (!DeviceTesting_ValidAsCerts(&env->modemVersionRevision.sertRevision.checkCert)) {
        if (osMutexAcquire(env->gsmAt->access, 500) == osOK) {
            env->modemVersionRevision.sertRevision.checkCert = AtGsmSimComA7600_SSL_CHECK_CA(env->gsmAt,
                                                                                             "ca.pem",
                                                                                             sizeof("ca.pem") - 1,
                                                                                             "crt.pem",
                                                                                             sizeof("crt.pem") - 1,
                                                                                             "key.pem",
                                                                                             sizeof("key.pem") - 1,
                                                                                             500);
            osMutexRelease(env->gsmAt->access);

            if (DeviceTesting_ValidAsCerts(&env->modemVersionRevision.sertRevision.checkCert)) {
                env->modemVersionRevision.sertRevision.validSert = MOD_READY;
            } else {
                env->modemVersionRevision.sertRevision.validSert = MOD_ERROR;
            }
        } else {
            env->modemVersionRevision.sertRevision.validSert = MOD_UNDEFANDED;
        }
    } else {
        env->modemVersionRevision.sertRevision.validSert = MOD_READY;
    }
}

void ModemDataCollector_GetAudioRev(tModemDataColl *env) {
    AtCommandResult resGetCgmr;
    if (env->modemVersionRevision.validAudio != MOD_READY) {
        if (osMutexAcquire(env->gsmAt->access, 500) == osOK) {
            resGetCgmr = AtGsm_Gsnss_Simcom7600_GetAudioFilesValidation(env->gsmAt);
            osMutexRelease(env->gsmAt->access);
            if (resGetCgmr == AT_OK) {
                env->modemVersionRevision.validAudio = MOD_READY;
                return;
            }
            if (resGetCgmr == AT_TIMEOUT) {
                env->modemVersionRevision.validAudio = MOD_UNDEFANDED;
            }
            if (resGetCgmr == AT_ERROR) {
                env->modemVersionRevision.validAudio = MOD_ERROR;
                return;
            }
        } else {
            env->modemVersionRevision.validAudio = MOD_UNDEFANDED;
        }
    }
}

void ModemDataCollector_GetSoftRev(tModemDataColl *env) {
    AtCommandResult resGetCgmr = AT_ERROR;

    tString32 cgmrValue;
    size_t length;
    if (osMutexAcquire(env->gsmAt->access, 2000) == osOK) {
        resGetCgmr = AtGsm_Gsnss_Simcom7600_GetSoftRevInModem(env->gsmAt, cgmrValue.data, &length);
        osMutexRelease(env->gsmAt->access);
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления Mma_GetCGSN_5")
    }

    if (resGetCgmr == AT_OK) {

        if (length > 32) {
            length = 32;
        }

        memcpy(env->modemVersionRevision.softValue.data, cgmrValue.data, length);
        env->modemVersionRevision.softValue.length = length;

        // Сравнение с версией в storage
        if (((length != env->storage->nvm->modemSaveDeviceSoftVers.length) ||
             (memcmp(cgmrValue.data, env->storage->nvm->modemSaveDeviceSoftVers.data,
                     cgmrValue.length) != 0))) {

            env->storage->nvm->modemSaveDeviceSoftVers.length = length;
            memcpy(env->storage->nvm->modemSaveDeviceSoftVers.data, cgmrValue.data, cgmrValue.length);

            DeviceStorage_DelayedDump(env->storage);

        }

    }

}

bool ModemDataCollector_ChekSelectSimChips(tModemDataColl *env, const eSubSystems *subSystems) {
    if (*subSystems == UNDEFANDET) {
        ModemDataCollector_SetThisSubSystem(env->systemSelector, UNDEFANDET);
        return false;
    }

    tString32 ssidValueThis;
    size_t length;

    if (*subSystems == TELEMATICA) {
        if (env->modemVersionRevision.valid_CCIDComer == MOD_READY) {
            if (osMutexAcquire(env->gsmAt->access, 4000) == osOK) {
                if (AtGsm_Gsnss_Simcom7600_GetCCID(env->gsmAt, ssidValueThis.data, &length) == AT_OK) {

                    if (
                            (memcmp(env->modemVersionRevision.ssidComersValue.data, ssidValueThis.data, length) == 0) ||
                            (env->modemVersionRevision.ssidComersValue.length == length)
                            ) {
                        osMutexRelease(env->gsmAt->access);
                        return true;
                    } else {
                        osMutexRelease(env->gsmAt->access);
                        return false;
                    }

                } else {
                    osMutexRelease(env->gsmAt->access);
                    return false;
                }
            }
        } else {
            return false;
        }

    } else if (*subSystems == UVEOS) {
        if (env->modemVersionRevision.valid_CCID == MOD_READY) {
            if (osMutexAcquire(env->gsmAt->access, 4000) == osOK) {
                if (AtGsm_Gsnss_Simcom7600_GetCCID(env->gsmAt, ssidValueThis.data, &length) == AT_OK) {

                    if (
                            (memcmp(env->modemVersionRevision.ssidValue.data, ssidValueThis.data, length) == 0) ||
                            (env->modemVersionRevision.ssidValue.length == length)
                            ) {
                        osMutexRelease(env->gsmAt->access);
                        return true;
                    } else {
                        osMutexRelease(env->gsmAt->access);
                        return false;
                    }

                } else {
                    osMutexRelease(env->gsmAt->access);
                    return false;
                }
            }
        } else {
            return false;
        }
    }
    return false;
}

void ModemDataCollector_ChekReadSimChips(tModemDataColl *env) {
    tVariableDescriptor *GSM_CCID;
    tVariableDescriptor *GSM_CCID_COMERS;

    GSM_CCID = VariablesTable_GetByNameStatic(&env->storage->publicVariablesTable, "GSM_CCID");
    GSM_CCID_COMERS = VariablesTable_GetByNameStatic(&env->storage->publicVariablesTable, "GSM_CCID_COMERS");

    if (
            (memcmp(GSM_CCID->addr, GSM_CCID_COMERS->addr, *(uint8_t *) GSM_CCID->len) == 0) &&
            (
                    (*(uint8_t *) GSM_CCID->len == *(uint8_t *) GSM_CCID_COMERS->len)
            )
            ) {
        uint8_t lenghtEra = sizeof("1111111111111111111");
        uint8_t lenghtComers = sizeof("1111111111111111111");

        memcpy(env->modemVersionRevision.ssidValue.data, "1111111111111111111", lenghtEra);
        env->modemVersionRevision.ssidValue.length = lenghtEra;

        memcpy(env->modemVersionRevision.ssidComersValue.data, "1111111111111111111", lenghtComers);
        env->modemVersionRevision.ssidComersValue.length = lenghtComers;

        memcpy(GSM_CCID->addr, "1111111111111111111", lenghtEra);
        memcpy(GSM_CCID_COMERS->addr, "1111111111111111111", lenghtComers);

        DeviceStorage_DelayedDump(env->storage);
        env->modemVersionRevision.valid_CCIDComer = MOD_ERROR;
        env->modemVersionRevision.valid_CCID = MOD_ERROR;
    }
}

void ModemDataCollector_GetCCIDS(tModemDataColl *env) {
    SystemDelayMs(500);
    ModemDataCollector_SelectionSimChip(env->systemSelector, CHIP_ERA);
    SystemDelayMs(500);
    ModemDataCollector_GeIds(env);
    SystemDelayMs(500);
    ModemDataCollector_SelectionSimChip(env->systemSelector, CHIP_COMERS);
    SystemDelayMs(500);
    ModemDataCollector_GeIds(env);

    ModemDataCollector_ChekReadSimChips(env);
}