//
// Created by cfif on 05.06.2024.
//
#ifdef UVEOS_ADD_TELEMATICA

#include <math.h>
#include "Network.h"
#include "EgtsOutputCommands.h"
#include "SystemDelayInterface.h"
#include "AtGsmQuerySignalQuality.h"
#include "AtGsmGNSS.h"
#include "n32g45x_can.h"

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

uint8_t QuerySignalQuality(tEgtsProcessing *env) {

    uint8_t rssi = 0;

    if (osMutexAcquire(env->gsm->gsmAt.access, 2000) == osOK) {

        AtGsm_QuerySignalQuality(
                &env->gsm->gsmAt,
                &rssi
        );

        osMutexRelease(env->gsm->gsmAt.access);
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа (QuerySignalQuality)")
    }

    return rssi;
}

void ResetGPS(tEgtsProcessing *env) {
    if (osMutexAcquire(env->gsm->gsmAt.access, 5000) == osOK) {
        AtGsm_ReceiverGnssResetColdstart(&env->gsm->gsmAt);
        osMutexRelease(env->gsm->gsmAt.access);
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа (ResetGPS)")
    }
}

void calc_driver_scoring(tCanMainAdditional *env, float new_speed) {

    if (!env->gnss_config.acc_calc_time)
        return;

    if ((env->EngineSpeed > 100) && (new_speed >= (float) env->gnss_config.gnss_course_speed) &&
        (env->calc_scoring.old_speed >= (float) env->gnss_config.gnss_course_speed)) {
        float acc_sum = 0;
        float coef_acc = 1.0f;

        if (env->gnss_config.reference_speed && new_speed > ((float) env->gnss_config.reference_speed))
            coef_acc = (float) sqrt((double) new_speed / ((double) env->gnss_config.reference_speed));

        env->calc_scoring.acc_last[env->calc_scoring.index] = ((new_speed - env->calc_scoring.old_speed) * coef_acc);

        for (uint32_t i = 0; i < env->gnss_config.acc_calc_time; i++) {
            acc_sum += env->calc_scoring.acc_last[i];
        }

        if ((float) env->gnss_config.diff_speed_up > 0.0f && acc_sum >= (float) env->gnss_config.diff_speed_up) {
            env->state_get.trip_acceleration++;
            env->bc_get.total_acceleration++;
            env->bc_get.acceleration++;
            for (int i = 0; i < NUM_ACC_COUNT_MAX; i++) {
                env->calc_scoring.acc_last[i] = 0.0f;
            }
        } else if ((float) env->gnss_config.diff_speed_down > 0.0f &&
                   acc_sum <= ((-1.0f) * (float) env->gnss_config.diff_speed_down)) {
            env->state_get.trip_braking++;
            env->bc_get.total_braking++;
            env->bc_get.braking++;
            for (int i = 0; i < NUM_ACC_COUNT_MAX; i++) {
                env->calc_scoring.acc_last[i] = 0.0f;
            }
        }

        if ((++env->calc_scoring.index) > (env->gnss_config.acc_calc_time - 1))
            env->calc_scoring.index = 0;

        env->calc_scoring.data_erase = false;
    } else if (!env->calc_scoring.data_erase) {
        for (int i = 0; i < NUM_ACC_COUNT_MAX; i++) {
            env->calc_scoring.acc_last[i] = 0.0f;
        }
        env->calc_scoring.index = 0;
        env->calc_scoring.data_erase = true;
    }
    env->calc_scoring.old_speed = new_speed;
}

void _Noreturn EgtsProcessing_InfoTask(tEgtsProcessing *env) {
//    env->state_get
    uint32_t timeOutCheckNetworkStatus = 0;
    uint32_t timeNavUpdate = 0;
    char status = 'V';
    uint32_t timeStampCheck = 0;
    uint32_t tm = 0;
    bool oneOn = true;
    bool oneOff = true;
    bool bl = false;
    double volatile EngineOXTemperature;
    float realSpeed = 0;
    uint8_t fuelLevel;
    while (1) {
        EngineOXTemperature = env->canData->engineOXTemperature * 0.75 - 48;

        if (onOffTelematica(env, &oneOn, &oneOff, "Задача информации"))
            continue;

        if (osMutexAcquire(env->gsm->gsmAt.access, 1000) == osOK) {
            AtGsm_Gsnss_GetNMEA_Pack(env->gsm, 400);
            osMutexRelease(env->gsm->gsmAt.access);

            ///---начало------------------------------------Проверка навигации на сбой приемника------------------------------------
            if (timeNavUpdate < SystemGetMs()) {
                timeNavUpdate = SystemGetMs() + 10000;

                tNmeaRmc nmeaRmc;
                Gnss_GetFullNavData(env->gsm, &nmeaRmc);

                uint32_t timestamp = iNmea0183TimestampFromRmc(&nmeaRmc);

                if (nmeaRmc.status == 'A') {

                    if (timeStampCheck == timestamp) {
                        ResetGPS(env);
                        LoggerInfoStatic(LOGGER, LOG_SIGN, "Обнаружена остановка времени навигации")
                        timeStampCheck = 0;
                    } else {
                        timeStampCheck = timestamp;
                    }

                }

            }
        } else {
            LoggerTraceStatic(LOGGER, LOG_SIGN, "Ошибка доступа (EgtsProcessing_InfoTask)")
        }


        if (tm < SystemGetMs()) {
            if (EngineOXTemperature < 100) {
                EngineOXTemperature++;
            } else {
                EngineOXTemperature = 0;
            }
            if (env->state_get.trip_acceleration < 10) {
                env->state_get.trip_acceleration++;
            } else {
                env->state_get.trip_acceleration = 0;
            }
            if (env->state_get.trip_braking < 20) {
                env->state_get.trip_braking++;
            } else {
                env->state_get.trip_braking = 0;
            }

            if (realSpeed < 300) {
                fuelLevel++;
                realSpeed = realSpeed * 0.01f;
            } else {
                fuelLevel = 0;
                realSpeed = realSpeed * 0.01f;
            }

            if (fuelLevel < 80) {
                fuelLevel++;
            } else {
                fuelLevel = 0;
            }

            if (env->canData->externalTemperature < 10) {
                env->canData->externalTemperature++;
            } else {
                env->canData->externalTemperature = 0;
            }

            if (env->canData->engineSpeed < 500) {
                env->canData->engineSpeed++;
            } else {
                env->canData->engineSpeed = 110;
            }

            tm = SystemGetMs() + 5000;
        }

        if (env->timeAbsSpeedOnSecond < SystemGetMs()) {
            env->timeAbsSpeedOnSecond = SystemGetMs() + 1000;

            double FuelLevel = fuelLevel * 0.5;
            env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_FuelLevel].value = (uint8_t) (FuelLevel /
                                                                                                            0.5);

            calc_driver_scoring(env->canMainAdditional, realSpeed);

            env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_ANS4].value = env->canData->engineSpeed;
            env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_ANS5].value = (uint32_t) realSpeed;
            env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_NumberAccelerations].value = env->state_get.trip_acceleration;
            env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_NumberBraking].value = env->state_get.trip_braking;

            if (env->canData->externalTemperature != 0xFF) {
                double ExternalTemperature = env->canData->externalTemperature * 1.0 - 40;
                env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_ExternalTemperature].value = (uint16_t) (
                        (ExternalTemperature + 40) / 0.5);

            }

            env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_Uptime].value =
                    SystemGetMs() / 60000; // Uptime

            if (EngineOXTemperature < -39.5) {
                env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_EngineOXTemperature].value = 0;
            } else {
                env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_EngineOXTemperature].value = (uint16_t) (
                        (EngineOXTemperature + 40) / 0.5);
            }

            // По умолчанию в SLEEP, до этого было в TS_STATUS_STANDBY
            eEgtsTsStatus SENSORS_AN_VehicleStatus_loc = TS_STATUS_SLEEP;

            // Поднят пин зажигания
            if (GpioPinGet(env->ignition)) {
                SENSORS_AN_VehicleStatus_loc = TS_STATUS_IGNITION;

            } else {
            }

            // Установка значения сенсора состояния
            env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_VehicleStatus].value = SENSORS_AN_VehicleStatus_loc;

            if (timeOutCheckNetworkStatus < SystemGetMs()) {
                timeOutCheckNetworkStatus = SystemGetMs() + AURUS_CHECK_NETWORK_STATUS;
                uint8_t rssi = QuerySignalQuality(env);
                env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_RSSI].value = rssi;
            }

        }
        SystemDelayMs(500);
    }
}

#endif