//
// Created by cfif on 20.06.2024.
//
#include "GsmWithGnss.h"
#include <AtCmdCommonProtected.h>
#include "string.h"
#include "AsciiStringParsingUtils.h"
#include "Gsm_SockInt.h"
#include "SystemMutexCmsis.h"
#include "ext_telematica.h"
#include "Gsm_SSL_SockInt.h"

extern tGsmWithGnss gsmWithGnss;

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

static void rxGsm(tGsmWithGnss *env, osMessageQueueId_t rxDataQueue) {
    if (AtCmdReceiveNextLine(env->gsmAt, 2000) == AT_OK) {
        if (AtCmdRxBeginWithStatic(env->gsmAt, "+IPD")) {
            uint16_t len = iAsciiStringParseUnsignedLongDecimalNumber(
                    env->gsmAt->rxBuffer.data + 4, env->gsmAt->rxBuffer.data + env->gsmAt->rxBuffer.len - 1
            );

            uint16_t bufferLen = SerialPortReceive(env->gsmAt->io, env->bufLog, len, 2000);

            memset(env->bufLogHexString, 0, sizeof(env->bufLogHexString));
            size_t lenLog = 0;
            vAsciiStringAddBytesAsHex(env->bufLogHexString, &lenLog, (uint8_t *) env->bufLog, bufferLen);
            LoggerFormatInfo(LOGGER, LOG_SIGN, "FROM (%d): %s", bufferLen, env->bufLogHexString);

            if (bufferLen == len) {
                for (uint16_t i = 0; i < bufferLen; ++i) {
                    osMessageQueuePut(rxDataQueue, &env->bufLog[i], 0x0, 0U);
                }
            } else {
                LoggerFormatInfo(LOGGER, LOG_SIGN, "NO_FROM %d != %d", bufferLen, len);
            }

        } else {
            LoggerFormatTrace(LOGGER, LOG_SIGN, "Не получен +IPD")
        }
    }
}

static void rxGsmSSL(tGsmWithGnss *env, osMessageQueueId_t rxDataQueue) {

    uint16_t len = iAsciiStringParseUnsignedLongDecimalNumber(
            env->gsmAt->rxBuffer.data + sizeof("+CCHRECV: DATA,X"),
            env->gsmAt->rxBuffer.data + env->gsmAt->rxBuffer.len - 1
    );


    uint16_t bufferLen = SerialPortReceive(env->gsmAt->io, env->bufLog, len, 2000);

//    memset(env->bufLogHexString, 0, sizeof(env->bufLogHexString));
//    size_t lenLog = 0;

//    if (bufferLen < 100) {
//        vAsciiStringAddBytesAsHex(env->bufLogHexString, &lenLog, (uint8_t *) env->bufLog, bufferLen);
//        LoggerFormatInfo(LOGGER, LOG_SIGN, "FROM (%d): %s", bufferLen, env->bufLogHexString);
//    } else {
//        vAsciiStringAddBytesAsHex(env->bufLogHexString, &lenLog, (uint8_t *) env->bufLog, 100);
//        LoggerFormatInfo(LOGGER, LOG_SIGN, "FROM CUTE (%d): %s ...", bufferLen, env->bufLogHexString);
//    }

    if (bufferLen == len) {
        for (uint16_t i = 0; i < bufferLen; ++i) {
            osStatus_t status = osMessageQueuePut(rxDataQueue, &env->bufLog[i], 0x0, 0U);

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

        }
    } else {
        LoggerFormatInfo(LOGGER, LOG_SIGN, "NO_FROM %d != %d", bufferLen, len);
    }

}

void GsmWithGnssTelematica_Urc(tAtBuffer *buff) {

    if (AtBufferBeginWithStatic(buff, "+CCH_PEER_CLOSED")) {
        LoggerInfoStatic(&gsmWithGnss.slog->logger, LOG_SIGN, "Обнаружен разрыв соединения")
        gsmWithGnss.isDisconnect = true;
    }

    if (AtBufferBeginWithStatic(buff, "$GPGGA,")) {
        gsmWithGnss.isNav = true;

        if (osMutexAcquire(gsmWithGnss.gnssRmcGga.rmcAccess, 2000) == osOK) {
            bNmea0183ParseGGA(buff->data + 7, buff->len - 7, &gsmWithGnss.gnssRmcGga.currentGgaRmc);
            gsmWithGnss.gnssRmcGga.isGGA_Active = true;
            osMutexRelease(gsmWithGnss.gnssRmcGga.rmcAccess);
        }

        return;
    }

    if (AtBufferBeginWithStatic(buff, "$GPRMC,")) {

        if (osMutexAcquire(gsmWithGnss.gnssRmcGga.rmcAccess, 2000) == osOK) {

            if (bNmea0183IsRmcString(buff->data, buff->len)) {
                if (bNmea0183IsValidString(buff->data, buff->len)) {
                    bNmea0183ParseRMC(buff->data + 7, buff->len - 7, &gsmWithGnss.gnssRmcGga.currentRmc);
                    gsmWithGnss.gnssRmcGga.isRMC_Active = true;

                    gsmWithGnss.gnssRmcGga.gsmWithGnssTimeStamp.status = gsmWithGnss.gnssRmcGga.currentRmc.status;
                    memcpy(&gsmWithGnss.gnssRmcGga.gsmWithGnssTimeStamp.date, &gsmWithGnss.gnssRmcGga.currentRmc.date,
                           sizeof(tNmeaDateRmc));
                    memcpy(&gsmWithGnss.gnssRmcGga.gsmWithGnssTimeStamp.time, &gsmWithGnss.gnssRmcGga.currentRmc.time,
                           sizeof(tNmeaTimeRmc));

                }
            }

            osMutexRelease(gsmWithGnss.gnssRmcGga.rmcAccess);
        }

        return;
    }


    if (AtBufferBeginWithStatic(buff, "+CCHRECV: DATA")) {
        uint8_t linkNum = iAsciiStringParseUnsignedLongDecimalNumber(
                gsmWithGnss.gsmAt->rxBuffer.data + sizeof("+CCHRECV: DATA"),
                gsmWithGnss.gsmAt->rxBuffer.data + sizeof("+CCHRECV: DATA") + 1
        );

        tGsmSocketSlot *slot = gsmWithGnss.slots + linkNum;

        if (!GsmSocketSlot_IsClear(slot)) {
            rxGsmSSL(&gsmWithGnss, slot->rxDataQueue);
            return;
        } else {
//            LoggerInfoStatic(LOGGER, LOG_SIGN, "Соединение не создано")
        }

        return;
    }

    if (AtBufferBeginWithStatic(buff, "RECV FROM:")) {

        for (uint8_t i = 0; i < GSM_SLOTS_COUNT; ++i) {
            tGsmSocketSlot *slot = gsmWithGnss.slots + i;
            if (!GsmSocketSlot_IsClear(slot)) {
                if (memcmp(slot->addr.data, buff->data + sizeof("RECV FROM:") - 1, slot->addr.length) == 0) {
                    rxGsm(&gsmWithGnss, slot->rxDataQueue);
                    return;
                } else {
//                    LoggerInfoStatic(LOGGER, LOG_SIGN, "Не совпадает адрес получателя")
                }
            }
        }

        return;
    }

}

int32_t GnssGgaGetAlt(tGsmWithGnss *env) {
    int32_t Alt = 0;

    if (osMutexAcquire(env->gnssRmcGga.rmcAccess, 2000) == osOK) {
        Alt = (int32_t) env->gnssRmcGga.currentGgaRmc.altitude;
        osMutexRelease(env->gnssRmcGga.rmcAccess);
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата доступа GnssGgaGetAlt")
    }

    return Alt;
}

uint8_t GnssGgaGetSat(tGsmWithGnss *env) {
    uint8_t countSats = 0;

    if (osMutexAcquire(env->gnssRmcGga.rmcAccess, 2000) == osOK) {
        countSats = env->gnssRmcGga.currentGgaRmc.sats;
        osMutexRelease(env->gnssRmcGga.rmcAccess);
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата доступа GnssGgaGetSat")
    }

    return countSats;
}


void Gnss_GetFullNavData(tGsmWithGnss *env, tNmeaRmc *nmeaRmc) {

    if (osMutexAcquire(env->gnssRmcGga.rmcAccess, 2000) == osOK) {

        memcpy(nmeaRmc, &env->gnssRmcGga.currentRmc, sizeof(tNmeaRmc));

        osMutexRelease(env->gnssRmcGga.rmcAccess);
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата доступа Gnss_GetFullNavData")
    }

}

/*
void Gnss_GetFullNavData(tGsmWithGnss *env, tNmeaRmc *nmeaRmc) {

    if (osMutexAcquire(EXT_ENV_TELE.gnss.rmcAccess, 2000) == osOK) {

        memcpy(nmeaRmc, EXT_ENV_TELE.gnss.currentRmc, sizeof(tNmeaRmc));

        osMutexRelease(EXT_ENV_TELE.gnss.rmcAccess);
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа (Gnss_GetFullNavData)")
    }

}
*/


void GsmWithGnssInit(tGsmWithGnss *env) {

    env->slog = EXT_ENV_TELE.loggerToSerialPort;
    env->gsmAt = EXT_ENV_TELE.gsmAt;
    env->Rtc = EXT_ENV_TELE.rtcIO;

    env->gnssRmcGga.isRMC_Active = true;
    env->gnssRmcGga.isGGA_Active = true;

    env->gnssRmcGga.rmcAccess = osMutexNew(NULL);

    Gsm_SSL_InitSocket(env,1024*12);
    Gsm_InitIO(env);
}