//
// Created by xemon on 02.09.22.
//

//#include <Log.h>

#include <memory.h>
#include "SystemDelayInterface.h"
#include "AsciiStringAssmeblingUtils.h"
#include "GsmWithGnss.h"
#include "AtCmdCommonProtected.h"
#include "AtGsmSms_DeleteAll.h"
#include "AtGsmSimcomSim7600.h"
#include "Rtc.h"
#include "GsmSimComAudioCodec.h"

#define LOGGER env->logger
#define LOG_SIGN "GSM&GNSS"
tGsmWithGnss gnssEnv;
bool fl_rtcIsUsed = false;
#define GWG_IER(FUNC) {A}

AtCommandResult GsmWithGnssSimProfileSelect(tAtCmd *gsmAt, tStringLink profileExt) {
    if (osMutexAcquire(gsmAt->access, 1000) == osOK) {
        if (AtGsm_Gsnss_Simcom7600_SimProfileSelect(gsmAt, profileExt) != AT_OK) {
            osMutexRelease(gsmAt->access);
            return AT_ERROR;
        } else {
            osMutexRelease(gsmAt->access);
            return AT_OK;
        }
    } else {
        return AT_TIMEOUT;
    }
}

AtCommandResult GsmWithGnssSetModemManualPowerMode(tGsmWithGnss *env, bool *mode) {
    if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
        AtCommandResult result = AtGsm_Gsnss_Simcom7600_ManualPowerMode(&env->gsmAt, mode);
        if (result == AT_OK) {
            osMutexRelease(env->gsmAt.access);
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Мощность модема установлена у ручном режиме")
            return AT_ERROR;
        } else {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Не удалось установить мощность модема")
        }
        osMutexRelease(env->gsmAt.access);
        return AT_OK;
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата режима установки мощности модема")
        return AT_TIMEOUT;
    }
}

AtCommandResult GsmWithGnssSetModemGSMPowerMode(tGsmWithGnss *env, uint16_t *value) {
    if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
        if (AtGsm_Gsnss_Simcom7600_SetModemGSMPowerMode(&env->gsmAt, value) != AT_OK) {
            osMutexRelease(env->gsmAt.access);
            return AT_ERROR;
        } else {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Мощность модема по каналу GSM установлена")
        }
        osMutexRelease(env->gsmAt.access);
        return AT_OK;
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата режима установки мощности модема по каналу GSM")
        return AT_TIMEOUT;
    }
}

AtCommandResult GsmWithGnssSetModemWCDMAPowerMode(tGsmWithGnss *env, uint16_t *value) {
    if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
        if (AtGsm_Gsnss_Simcom7600_SetModemWCDMAPowerMode(&env->gsmAt, value) != AT_OK) {
            osMutexRelease(env->gsmAt.access);
            return AT_ERROR;
        } else {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Мощность модема по каналу WCDMA установлена")
        }
        osMutexRelease(env->gsmAt.access);
        return AT_OK;
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата режима установки мощности модема по каналу WCDMA")
        return AT_TIMEOUT;
    }
}

AtCommandResult GsmWithGnssSetModemLTEPowerMode(tGsmWithGnss *env, uint16_t *value) {
    if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
        if (AtGsm_Gsnss_Simcom7600_SetModemLTEPowerMode(&env->gsmAt, value) != AT_OK) {
            osMutexRelease(env->gsmAt.access);
            return AT_ERROR;
        } else {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Мощность модема по каналу LTE установлена")
        }
        osMutexRelease(env->gsmAt.access);
        return AT_OK;
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата режима установки мощности модема по каналу LTE")
        return AT_TIMEOUT;
    }
}

AtCommandResult GsmWithGnssSetEchoMode(tGsmWithGnss *env) {
    if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
        if (AtGsm_Gsnss_Simcom7600_EchoMode(&env->gsmAt, 1) != AT_OK) {
            osMutexRelease(env->gsmAt.access);
            return AT_ERROR;
        } else {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Эхо режим установлен")
        }
        osMutexRelease(env->gsmAt.access);
        return AT_OK;
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата установки конфигурации эхо режима")
        return AT_TIMEOUT;
    }
}

AtCommandResult GsmWithGnssSetADBConf(tGsmWithGnss *env) {
    SystemDelayMs(40);
    if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
        if (AtGsm_Gsnss_Simcom7600_OpenADB(&env->gsmAt) != AT_OK) {
            osMutexRelease(env->gsmAt.access);
            return AT_ERROR;
        } else {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "ADB порт сконфигурирован")
        }
        osMutexRelease(env->gsmAt.access);
        return AT_OK;
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата установки конфигурации ADB порта")
        return AT_TIMEOUT;
    }
}

AtCommandResult GsmWithGnssPDUClear(tGsmWithGnss *env) {
    SystemDelayMs(40);
    if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
        if (AtGsmSms_DeleteAll(&env->gsmAt) != AT_OK) {
            osMutexRelease(env->gsmAt.access);
            return AT_ERROR;
        } else {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "PDU пакеты очищены")
        }
        osMutexRelease(env->gsmAt.access);
        return AT_OK;
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата установки конфигурации очистки СМС")
        return AT_TIMEOUT;
    }
}

AtCommandResult GsmWithGnssSetEcallOnlyMode(tGsmWithGnss *env) {
    SystemDelayMs(40);
    if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
        if (AtGsm_Gsnss_Simcom7600_EcallOnlyMode(&env->gsmAt, 0) != AT_OK) {
            osMutexRelease(env->gsmAt.access);
            return AT_ERROR;
        } else {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Режим EcallOnlyMode сконфигурирован")
        }
        osMutexRelease(env->gsmAt.access);
        return AT_OK;
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата установки конфигурации EcallOnlyMode")
        return AT_TIMEOUT;
    }
}

AtCommandResult GsmWithGnssDeleteGpsInfo(tGsmWithGnss *env) {
    SystemDelayMs(40);
    if (osMutexAcquire(env->gsmAt.access, 2000) == osOK) {
        if (AtGsm_Gsnss_Simcom7600_DeleteGpsInfo(&env->gsmAt) != AT_OK) {
            osMutexRelease(env->gsmAt.access);
            return AT_ERROR;
        } else {
            osMutexRelease(env->gsmAt.access);
            return AT_OK;
        }
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата установки конфигурации очистки GNSS данных")
        return AT_TIMEOUT;
    }
}

AtCommandResult GsmWithGnssConfigureAudioProfile(tGsmWithGnss *env, tString32 *profileData) {
    if (osMutexAcquire(env->gsmAt.access, 3000) == osOK) {
        AtCommandResult res = AtGsm_Gsnss_Simcom7600_SetConfigureAudioProfile(&env->gsmAt, profileData);
        if (res!= AT_OK) {
            osMutexRelease(env->gsmAt.access);
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка выбора конфигурации аудио профиля в модеме, возможно профиль не загружен")
            return AT_ERROR;
        } else {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Конфигурация аудио профиля выбрана")
        }
        osMutexRelease(env->gsmAt.access);
        return AT_OK;
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата установки конфигурации аудио профиля")
        return AT_TIMEOUT;
    }
}

AtCommandResult GsmWithGnssConfigureRMCThread(tGsmWithGnss *env) {
    SystemDelayMs(40);
    if (osMutexAcquire(env->gsmAt.access, 2000) == osOK) {
        if (AtGsm_Gsnss_Simcom7600_SetConfigureStaticRMCThread(&env->gsmAt) != AT_OK) {
            osMutexRelease(env->gsmAt.access);
            return AT_ERROR;
        } else {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Подсистема GNSS сконфигурирована")
        }
        osMutexRelease(env->gsmAt.access);
        return AT_OK;
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата установки конфигурации установки GNSS параметров")
        return AT_TIMEOUT;
    }
}

AtCommandResult GsmWithGnssInitGnss(tGsmWithGnss *env) {
    AtCommandResult res;

    res = AT_ERROR;

    if(GsmWithGnssSetEchoMode(env) == AT_ERROR) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка установки эхо-режима")
        res = AT_ERROR;
    } else {
        res = AT_OK;
    }

    if(GsmWithGnssSetADBConf(env) == AT_ERROR) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка конфигурации ADB порта")
        if(res == AT_OK){
            res = AT_ERROR;
        }
    } else {
        res = AT_OK;
    }

    if(GsmWithGnssPDUClear(env) == AT_ERROR) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка очистки СМС сообщений")
        if(res == AT_OK){
            res = AT_ERROR;
        }
    } else {
        res = AT_OK;
    }

    if(GsmWithGnssSetEcallOnlyMode(env) == AT_ERROR) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка конфигурации установки режима EcallOnly")
        if(res == AT_OK){
            res = AT_ERROR;
        }
    } else {
        res = AT_OK;
    }

//    StopResiver(env);

    if(GsmWithGnssDeleteGpsInfo(env) == AT_ERROR) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка очистки навигационного буфера")
        if(res == AT_OK){
            res = AT_ERROR;
        }
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Навигационный буфер GNSS очищен")
        res = AT_OK;
    }

    if(GsmWithGnssConfigureRMCThread(env) == AT_ERROR) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка конфигурации и запуска навигационного потока")
        if(res == AT_OK){
            res = AT_ERROR;
        }
    } else {
        res = AT_OK;
    }

    StartResiver(env);
    return res;
}


AtCommandResult Gsm_SturtupCodec(tGsmWithGnss *env) {
    AtGsmSimCom_NAU_Codec_Full10w(&env->gsmAt);
    return AT_OK;
}

void AtGsm_Gsnss_NavData_Incorrect(tGsmWithGnss *env) {
    if (osMutexAcquire(env->gsmAt.access, 1000) == osOK) {
        env->gnss.currentRmc.status = 'V';
        osMutexRelease(env->gsmAt.access);
    }
}

char convertDecToMilliArcSec(double dec, int32_t *mArcs, double *gradus) {
    int deg = 0, min = 0;
    double sec = 0.0;
    double _dec = dec;

    deg = (int) (_dec / 100);
    min = (int) (_dec) - (deg * 100);

    sec = (double) (_dec - min - 100 * deg) * 60.0;

    if (gradus != NULL) *gradus = deg + min / 60.0 + sec / 3600.0;

    if (mArcs != NULL) *mArcs = (int) (deg * 3600 + min * 60) * 1000 + (int) (sec * 1000);

    return 0;
}

void NmeaRMCLocationToLocationRMC(tNmeaLocationRmc *nmea, EraGlonassUveosNavData *gnss) {
    convertDecToMilliArcSec(nmea->latitude, &gnss->latitude, NULL);
    convertDecToMilliArcSec(nmea->longitude, &gnss->longitude, NULL);
}

void GnssTaskGetTime(tGsmWithGnss *env, uint32_t *timestamp) {
    if (osMutexAcquire(env->gnss.rmcAccess, 1000) == osOK) {
        *timestamp = iNmea0183TimestampFromRmc(&env->gnss.currentRmc);
        osMutexRelease(env->gnss.rmcAccess);
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа (GnssTaskGetTime)")
    }
}

void GnssSetRTC(tGsmWithGnss *env) {
    if (env->gnss.currentRmc.time.second != 0) {
        if (!fl_rtcIsUsed) {
            time_t gnssTime;
            GnssTaskGetTime(env, (uint32_t *) &gnssTime);
            LoggerFormatInfo(LOGGER, LOG_SIGN, "Получено время с GNSS, временная метка: %u", gnssTime)

            time_t timestampLocal = 0;
            RtcGet(env->Rtc, &timestampLocal);

            if (timestampLocal < 1718359909) {
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Установка времени с GNSS")
                RtcSet(env->Rtc, &gnssTime);
            }

            fl_rtcIsUsed = true;
        }
    }
}

void AtGsm_Gsnss_NavData_Processing(tGsmWithGnss *env, tAtBuffer *buf) {
    if (osMutexAcquire(env->gnss.rmcAccess, 1000) == osOK) {
        if (bNmea0183IsRmcString(buf->data, buf->len)) {
            if (bNmea0183IsValidString(buf->data, buf->len)) {
                bNmea0183ParseRMC(buf->data + 7, buf->len - 7, &env->gnss.currentRmc);
                if (env->gnss.currentRmc.status == 'A') {
                    env->gnss.prevRmc = env->gnss.currentRmc;
                }
            }
        }
        osMutexRelease(env->gnss.rmcAccess);
        GnssSetRTC(env);
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа AtGsm_Gsnss_NavData_Processing")
    }
}

void AtGsm_Gsnss_GetLastActualNavData(tGsmWithGnss *env, EraGlonassUveosNavData *location, bool locSourse) {
    if (osMutexAcquire(env->gnss.rmcAccess, 1000) == osOK) {
        if (env->gnss.currentRmc.status == 'A') {
            env->gnss.prevRmc = env->gnss.currentRmc;
            location->valid = 2;
        } else {
            if (env->gnss.prevRmc.status == 'A') {
                env->gnss.currentRmc = env->gnss.prevRmc;
                env->gnss.currentRmc.status = 'V';
                location->valid = 1;
            } else if (env->gnss.prevRmc.location.latitude < 1) {
                env->gnss.currentRmc.status = 'V';
                location->valid = 0;
            }
        }
        osMutexRelease(env->gnss.rmcAccess);
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа AtGsm_Gsnss_GetLastActualNavData")
    }
}

void GnssGetNavData(tGsmWithGnss *env, EraGlonassUveosNavData *location, bool locSourse) {
    GnssSetRTC(env);
    AtGsm_Gsnss_GetLastActualNavData(env, location, locSourse);

    if (osMutexAcquire(env->gnss.rmcAccess, 1000) == osOK) {
        NmeaRMCLocationToLocationRMC(&env->gnss.currentRmc.location, location);
        location->direction = (uint16_t) env->gnss.currentRmc.headingAngle;
        osMutexRelease(env->gnss.rmcAccess);
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления GnssGetNavData")
    }
}