//
// Created by cfif on 07.10.22.
//

#include <CmsisRtosThreadUtils.h>
#include <memory.h>
#include "DeviceStorage.h"
//#include "VersionRandID.h"
#include "DataNonVolatile.h"
#include "StorageOnFlashArtery.h"
#include "SystemDelayInterface.h"
//#include "DataRuntime.h"

#define LOGGER env->logger
#define LOG_SIGN "Хран."

#define VARIABLE_GROUP_UNTRACKED 0
#define VARIABLE_GROUP_FLASH (1 << 0)

void DeviceStorage_InitVariablesTable(tDeviceStorage *env) {

    VariablesTableInitStatic(&env->publicVariablesTable, env->mem.vartab);

    DeviceDataRuntime_InitDefaults(&env->runtime);

    DeviceDataNonVolatile_AddToVarTab(env->nvm, &env->publicVariablesTable, VARIABLE_GROUP_FLASH);
    DeviceDataRuntime_AddToVarTab(&env->runtime, &env->publicVariablesTable, VARIABLE_GROUP_UNTRACKED);
}

bool DeviceStorage_LoadNonVolatile(tDeviceStorage *env) {

    bool isLoad = VarsTabDumpObserver_Load(&env->dumpObserver);

    if (isLoad) {
        if (env->nvm->version == DEVICE_DATA_NO_VOLATILE_VERSION) {
            return true;
        }
    }

    LoggerInfoStatic(LOGGER, LOG_SIGN, "СБРОС НАСТРОЕК УВЭОС");

    DeviceDataNonVolatile_InitDefaults(env->nvm);

    if (!isLoad) {
        tStorageOnFlashArtery *storageOnFlashArtery = (tStorageOnFlashArtery *) (env->dumpObserver.interface->env);
        tDeviceDataNonVolatile *DeviceDataNonVolatile = (tDeviceDataNonVolatile *) (storageOnFlashArtery->mainFlashPageAddress);

        if ( (DeviceDataNonVolatile->gost.VIN.length == 17) && (env->nvm->device.ECUSerialNumber.length < 32) ) {

            memcpy(env->nvm->dataTeledata, DeviceDataNonVolatile->dataTeledata, sizeof(DeviceDataNonVolatile->dataTeledata));
            LoggerInfoStatic(LOGGER, LOG_SIGN, " ");
            LoggerInfoStatic(LOGGER, LOG_SIGN, "=================================================");
            LoggerInfoStatic(LOGGER, LOG_SIGN, " ");
            LoggerInfoStatic(LOGGER, LOG_SIGN, "НАЙДЕНЫ АКТУАЛЬНЫЕ ДАННЫЕ");

            LoggerFormatInfo(LOGGER, LOG_SIGN, "VIN: %s", DeviceDataNonVolatile->gost.VIN.data);
            env->nvm->gost.VIN.length = DeviceDataNonVolatile->gost.VIN.length;
            memcpy(&env->nvm->gost.VIN.data, DeviceDataNonVolatile->gost.VIN.data, 17);

            LoggerFormatInfo(LOGGER, LOG_SIGN, "VEHICLE_PROPULSION_STORAGE_TYPE: %d",
                             DeviceDataNonVolatile->gost.VEHICLE_PROPULSION_STORAGE_TYPE);
            env->nvm->gost.VEHICLE_PROPULSION_STORAGE_TYPE = DeviceDataNonVolatile->gost.VEHICLE_PROPULSION_STORAGE_TYPE;

            LoggerFormatInfo(LOGGER, LOG_SIGN, "VEHICLE_TYPE: %d",
                             DeviceDataNonVolatile->gost.VEHICLE_TYPE);
            env->nvm->gost.VEHICLE_TYPE = DeviceDataNonVolatile->gost.VEHICLE_TYPE;

            LoggerFormatInfo(LOGGER, LOG_SIGN, "ECUSerialNumber: %s", DeviceDataNonVolatile->device.ECUSerialNumber.data);
            env->nvm->device.ECUSerialNumber.length = DeviceDataNonVolatile->device.ECUSerialNumber.length;
            memcpy(&env->nvm->device.ECUSerialNumber.data, DeviceDataNonVolatile->device.ECUSerialNumber.data, env->nvm->device.ECUSerialNumber.length);

            LoggerFormatInfo(LOGGER, LOG_SIGN, "ASI15_TRESHOLD * 100 : %d", (uint32_t) (DeviceDataNonVolatile->gost.ASI15_TRESHOLD*100));
            env->nvm->gost.ASI15_TRESHOLD = DeviceDataNonVolatile->gost.ASI15_TRESHOLD;

            LoggerFormatInfo(LOGGER, LOG_SIGN, "AccelCalibrationX: %d",
                             DeviceDataNonVolatile->device.AccelCalibrationX);
            env->nvm->device.AccelCalibrationX = DeviceDataNonVolatile->device.AccelCalibrationX;

            LoggerFormatInfo(LOGGER, LOG_SIGN, "AccelCalibrationY: %d",
                             DeviceDataNonVolatile->device.AccelCalibrationY);
            env->nvm->device.AccelCalibrationY = DeviceDataNonVolatile->device.AccelCalibrationY;

            LoggerFormatInfo(LOGGER, LOG_SIGN, "AccelCalibrationZ: %d",
                             DeviceDataNonVolatile->device.AccelCalibrationZ);
            env->nvm->device.AccelCalibrationZ = DeviceDataNonVolatile->device.AccelCalibrationZ;

            LoggerFormatInfo(LOGGER, LOG_SIGN, "RolloverAngle: %d", DeviceDataNonVolatile->device.RolloverAngle);
            env->nvm->device.RolloverAngle = DeviceDataNonVolatile->device.RolloverAngle;

            LoggerFormatInfo(LOGGER, LOG_SIGN, "RolloverTime: %d", DeviceDataNonVolatile->device.RolloverTime);
            env->nvm->device.RolloverTime = DeviceDataNonVolatile->device.RolloverTime;

            LoggerFormatInfo(LOGGER, LOG_SIGN, "DirectionAngle: %d", DeviceDataNonVolatile->device.DirectionAngle);
            env->nvm->device.DirectionAngle = DeviceDataNonVolatile->device.DirectionAngle;

            LoggerFormatInfo(LOGGER, LOG_SIGN, "factoryMode: %d", DeviceDataNonVolatile->device.factoryMode);
            env->nvm->device.factoryMode = DeviceDataNonVolatile->device.factoryMode;

            LoggerFormatInfo(LOGGER, LOG_SIGN, "CRASH_SIGNAL_INTERNAL: %d", DeviceDataNonVolatile->gost.CRASH_SIGNAL_INTERNAL);
            env->nvm->gost.CRASH_SIGNAL_INTERNAL = DeviceDataNonVolatile->gost.CRASH_SIGNAL_INTERNAL;

            LoggerFormatInfo(LOGGER, LOG_SIGN, "telematicaIsActive: %d", DeviceDataNonVolatile->device.telematicaIsActive);
            env->nvm->device.telematicaIsActive = DeviceDataNonVolatile->device.telematicaIsActive;

            LoggerFormatInfo(LOGGER, LOG_SIGN, "GNSS_GENERAL: %d", DeviceDataNonVolatile->DataToCan.gnss_general_ToCan);
            env->nvm->DataToCan.gnss_general_ToCan = DeviceDataNonVolatile->DataToCan.gnss_general_ToCan;

            LoggerFormatInfo(LOGGER, LOG_SIGN, "NAV_DATA_TO_CAN: %d", DeviceDataNonVolatile->DataToCan.nav_data_ToCan);
            env->nvm->DataToCan.nav_data_ToCan = DeviceDataNonVolatile->DataToCan.nav_data_ToCan;

            LoggerFormatInfo(LOGGER, LOG_SIGN, "MODEM_SOFT_VERSION: %s", DeviceDataNonVolatile->device.modemSoftVers);
            env->nvm->device.modemSoftVers.length = DeviceDataNonVolatile->device.modemSoftVers.length;
            memcpy(env->nvm->device.modemSoftVers.data, DeviceDataNonVolatile->device.modemSoftVers.data, DeviceDataNonVolatile->device.modemSoftVers.length);

            LoggerInfoStatic(LOGGER, LOG_SIGN, " ");
            LoggerInfoStatic(LOGGER, LOG_SIGN, "=================================================");
            LoggerInfoStatic(LOGGER, LOG_SIGN, " ");
        }
    }

    return VarsTabDumpObserver_Dump(&env->dumpObserver);

}

void DeviceStorage_ForceDump(tDeviceStorage *env) {
    VarsTabDumpObserver_Dump(&env->dumpObserver);
}

void DeviceStorage_DelayedDump(tDeviceStorage *env) {
    env->publicVariablesTable.changes = 1;
}

void DeviceStorage_InitCommon(tDeviceStorage *env, tStorageInterface *storageInterface) {
    VarsTabDumpObserver_Init(
            &env->dumpObserver,
            storageInterface,
            5000,
            env->nvm,
//            sizeof(env->nvm),
        16000,
            &env->publicVariablesTable,
            VARIABLE_GROUP_FLASH
    );

    env->uveosDumper = (tEraGlonassUveosDumperInterface) {
            .env = env,
            .forceDump = (eraGlonassForceDumpCall) DeviceStorage_ForceDump
    };


    DeviceStorage_InitVariablesTable(env);
    bool t=0;
}

void DeviceStorage_InitDefaults(tDeviceStorage *env) {
    DeviceStorage_InitCommon(env, NULL);
    DeviceDataNonVolatile_InitDefaults(env->nvm);
}

uint8_t dataReservedStore[16000];

bool DeviceStorage_Init(tDeviceStorage *env, tStorageInterface *storageInterface) {
    env->nvm = (tDeviceDataNonVolatile *)dataReservedStore;


    DeviceStorage_InitCommon(env, storageInterface);
    return DeviceStorage_LoadNonVolatile(env);
}