//
// Created by ilya on 25.03.24.
//

#include "PowerManagment.h"
#include "SystemDelayInterface.h"
#include "Adc.h"
#include "PwmSim7600e.h"
#include "CmsisRtosThreadUtils.h"
#include "ext_telematica.h"
#include "CanPorts.h"
#include "Gpios.h"

#define LOG_SIGN "Главн."
#define LOGGER &env->slog->logger

void Pwm_GsmAndGnssStartup(tPowerManagement *env) {
    PwmSim7600e_Startup(&env->powerSusystem->sim7600);
}

bool Pwm_GsmAndGnssShutDown(tPowerManagement *env) {
    return PwmSim7600e_ShutDown(&env->powerSusystem->sim7600);
}

void Pwm_BatteryOn(tPowerManagement *env) {
    GpioPinEnable(&env->powerSusystem->battery.enable);
}

void Pwm_AmpOn(tPowerManagement *env) {
    env->powerSusystem->SpekTestPower.speakTestAcsess = false;
    GpioPinEnable(&env->powerSusystem->audio.resetAmp);
}

void Pwm_AmpOff(tPowerManagement *env) {
    env->powerSusystem->SpekTestPower.speakTestAcsess = true;
    GpioPinDisable(&env->powerSusystem->audio.resetAmp);
}

void Pwm_BatteryOff(tPowerManagement *env) {
    GpioPinDisable(&env->powerSusystem->battery.enable);
}

void Pwm_StandbyOn(tPowerManagement *env) {
    GpioPinEnable(&env->powerSusystem->main.standby);
    GpioPinDisable(&env->powerSusystem->main.Power12V);
}

void Pwm_StandbyOff(tPowerManagement *env) {
    GpioPinDisable(&env->powerSusystem->main.standby);
    GpioPinDisable(&env->powerSusystem->main.Power12V);
}

void Pwm_Rs485Enable(tPowerManagement *env) {
    GpioPinEnable(&env->powerSusystem->PowerRS485);
}

void Pwm_Rs485Disable(tPowerManagement *env) {
    GpioPinDisable(&env->powerSusystem->PowerRS485);
}

void Pwm_PowerSavingEnable(tPowerManagement *env) {
//    Pwm_GsmAndGnssShutdown(env);
//    Pwm_MuteAmpOn(env);
//    Pwm_BipShutdown(env);
    Pwm_ChargeDisable(env);
}

void Pwm_PowerSavingDisable(tPowerManagement *env) {
//    Pwm_GsmAndGnssStartup(env);
//    Pwm_MuteAmpOff(env);
//    Pwm_GsmAndBipStartUp(env);
//    Mma_AudioTestSetMode(&env->power,1);
    Pwm_ChargeEnable(env);
}

//void Pwm_MuteAmpOff(tPowerManagement *env) {
//    tAudioPower  *audio = &env->pins->audio;
//    env->pins->SpekTestPower.speakTestAcsess = false;
//
//    GpioPinDisable(&audio->mute);
//    LoggerTraceStatic(LOGGER, LOG_SIGN, "Сигнал MUTE усилитель отключен")
//}

void Pwm_MuteAmpOn(tPowerManagement *env) {
    tAudioPower *audio = &env->powerSusystem->audio;
    env->powerSusystem->SpekTestPower.speakTestAcsess = true;
//    GpioPinEnable(&audio->mute);
    LoggerTraceStatic(LOGGER, LOG_SIGN, "Сигнал MUTE усилитель поднят")
}

bool Pwm_GetMuteInCarState(tPowerManagement *env) {
    bool pos, neg;
    pos=GpioPinGet(&env->powerSusystem->main.muteP);
    neg=GpioPinGet(&env->powerSusystem->main.muteN);

    if (*env->positiveMute) {
        if((pos==true)&&(neg==false)){
            return true;
        } else{
            return false;
        }
    } else {
        if((pos==false)&&(neg==true)){
            return true;
        } else{
            return false;
        }
    }
}

void Pwm_Shutdown(tPowerManagement *env) {
    if (EXT_ENV_ADR_TELE.META_EXT_ENV_TELE) {
        EXT_ENV_ADR_TELE.tele_func(env, TELE_MODULE_SHUTDOWN);
    }

    Pwm_GsmAndGnssShutDown(env);
    LoggerInfoStatic(&env->slog->logger, LOG_SIGN, "Завершение работы")
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Отключение питания через 4 с")
    SystemDelayMs(4000);
    Pwm_Blackout(env);
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Питание осталось, обратите внимание!!")
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Возможно произошло повторное включение пользователем")
    SystemDelayMs(500);

    nvic_system_reset();
    //BootJumpToAddress(0x8000000);
    LoggerErrorStatic(LOGGER, LOG_SIGN, "Этой строчки не должно быть! Критическая ошибка!")
}

bool Pwm_GetSosButtonState(tPowerManagement *env) {
    return GpioPinGet(env->sosButtonPin);
}

bool Pwm_GetServiseButtonState(tPowerManagement *env) {
    return GpioPinGet(env->serviceButtonPin);
}

void Pwm_SetEcallSignalOutInCar(tPowerManagement *env, bool value) {
    if (value) {
        if (EXT_ENV_ADR_TELE.META_EXT_ENV_TELE)
            EXT_ENV_ADR_TELE.tele_func(NULL, TELE_MODULE_MUTE_ON);

        GpioPinEnable(&env->powerSusystem->main.ecallOut);
    } else {
        if (EXT_ENV_ADR_TELE.META_EXT_ENV_TELE)
            EXT_ENV_ADR_TELE.tele_func(NULL, TELE_MODULE_MUTE_OFF);

        GpioPinDisable(&env->powerSusystem->main.ecallOut);
    }
}

void Pwm_SetServiseSignalOutInCar(tPowerManagement *env, bool value) {
    if (value) {
        if (EXT_ENV_ADR_TELE.META_EXT_ENV_TELE)
            EXT_ENV_ADR_TELE.tele_func(NULL, TELE_MODULE_MUTE_ON);

        GpioPinEnable(&env->powerSusystem->main.garage);
    } else {
        if (EXT_ENV_ADR_TELE.META_EXT_ENV_TELE)
            EXT_ENV_ADR_TELE.tele_func(NULL, TELE_MODULE_MUTE_OFF);

        GpioPinDisable(&env->powerSusystem->main.garage);
    }
}

void Pwm_SetPMuteInCar(tPowerManagement *env, bool value) {
    if (value) {
        if (EXT_ENV_ADR_TELE.META_EXT_ENV_TELE)
            EXT_ENV_ADR_TELE.tele_func(NULL, TELE_MODULE_MUTE_ON);

        GpioPinEnable(&env->powerSusystem->main.muteP);
    } else {
        if (EXT_ENV_ADR_TELE.META_EXT_ENV_TELE)
            EXT_ENV_ADR_TELE.tele_func(NULL, TELE_MODULE_MUTE_OFF);

        GpioPinDisable(&env->powerSusystem->main.muteP);
    }
}

void Pwm_SetNMuteInCar(tPowerManagement *env, bool value) {
    if (value) {
        if (EXT_ENV_ADR_TELE.META_EXT_ENV_TELE)
            EXT_ENV_ADR_TELE.tele_func(NULL, TELE_MODULE_MUTE_ON);

        GpioPinEnable(&env->powerSusystem->main.muteN);
    } else {
        if (EXT_ENV_ADR_TELE.META_EXT_ENV_TELE)
            EXT_ENV_ADR_TELE.tele_func(NULL, TELE_MODULE_MUTE_OFF);

        GpioPinDisable(&env->powerSusystem->main.muteN);
    }
}
void Pwm_SetMuteInCar(tPowerManagement *env, bool value) {
        ///*Мьют переделан , теперь поднимаются линии muteN muteP не зависимо от настройки в стородже

        if (value) {
            if (EXT_ENV_ADR_TELE.META_EXT_ENV_TELE)
                EXT_ENV_ADR_TELE.tele_func(NULL, TELE_MODULE_MUTE_ON);

            GpioPinEnable(&env->powerSusystem->main.muteN);
            GpioPinEnable(&env->powerSusystem->main.muteP);
        } else {
            if (EXT_ENV_ADR_TELE.META_EXT_ENV_TELE)
                EXT_ENV_ADR_TELE.tele_func(NULL, TELE_MODULE_MUTE_OFF);

            GpioPinDisable(&env->powerSusystem->main.muteP);
            GpioPinDisable(&env->powerSusystem->main.muteN);
        }
}

void Pwm_ChargeEnable(tPowerManagement *env) {
    env->currentChargeState = true;
    GpioPinEnable(&env->powerSusystem->battery.charge);
}

void Pwm_ChargeDisable(tPowerManagement *env) {
    env->currentChargeState = false;
    GpioPinDisable(&env->powerSusystem->battery.charge);
}

void Pwm_LNA_setMode(tPowerManagement *env, bool state) {
//    if (state == true) {
//        GpioPinEnable(&env->pins->main.inAnt);
//    } else {
//        GpioPinDisable(&env->pins->main.inAnt);
//    }
}

void Pwm_CanStandby(tPowerManagement *env) {
    GpioPinSet(&env->powerSusystem->canStandby.can1_standby, false);
    GpioPinSet(&env->powerSusystem->canStandby.can2_standby, false);
}

void Pwm_OnDeviceInit(tPowerManagement *env) {
    Pwm_StandbyOn(env);
    Pwm_BatteryOn(env);
    Pwm_Rs485Enable(env);
//    Pwm_GsmAndGnssStartup(env);
    Pwm_SetMuteInCar(env, false);
    Pwm_AmpOn(env);
    Pwm_CanStandby(env);

    GpioPinDisable(&env->powerSusystem->main.garage);
    GpioPinDisable(&env->powerSusystem->main.ecallOut);
}

void Pwm_Blackout(tPowerManagement *env) {
    Pwm_ChargeDisable(env);
    Pwm_BatteryOff(env);
    Pwm_StandbyOff(env);
}

void Pwm_Init(
        tPowerManagement *env,
        tPowerSusystem *powerSusystem,
        tAdcIO *batteryIo,
        tAdc *boardVoltage,
        bool *positiveMute,
        tLoggerToSerialPort *slog,
        tGpioPin *sosButtonPin,
        tGpioPin *serviceButtonPin
) {
    env->sosButtonPin = sosButtonPin;
    env->serviceButtonPin = serviceButtonPin;
    env->slog = slog;
    env->powerSusystem = powerSusystem;

    env->powerSusystem->boardPower.boardVoltage = boardVoltage;
    env->powerSusystem->boardPower.boardVoltageTimer = 0;
    env->powerSusystem->boardPower.currentBoardVoltage = 0;

    env->powerSusystem->SpekTestPower.lastTestTime = 0;

    env->shutdownDelay = 60000;
    env->powerSusystem->battery.batteryIo = batteryIo;
    env->powerSusystem->battery.batTestTimer = 0;
    env->positiveMute = positiveMute;
    env->logger = NULL;
    env->interAntBufVal = true;
    //Инициализируем поток
    InitThreadAtrStatic(&env->threadPwr.attr, "Pwm", env->threadPwr.controlBlock, env->threadPwr.stack, osPriorityNormal);
    env->threadPwr.id = 0;
    env->currentIgnState = true;
    env->mux_accessPwrMan = osMutexNew(NULL);
}

static _Noreturn void Pwm_Thread(tPowerManagement *env) {
    Pwm_ChargeEnable(env);

    for (;;) {
        bool ignition = GpioPinGet(&env->powerSusystem->main.ignition);

        if (ignition) {
            env->lastIgnEnabled = SystemGetMs();
        }

        if (osMutexAcquire(env->mux_accessPwrMan, 100) == osOK) {
            env->powerSusystem->boardPower.currentBoardVoltage = AdcGet(&env->powerSusystem->boardPower.boardVoltage->vccIo, 1000);
            env->powerSusystem->boardPower.currentBoardVoltageOfSerbisePO = env->powerSusystem->boardPower.currentBoardVoltage;
            if (env->powerSusystem->battery.batTestTimer < SystemGetMs()) {
                GpioPinSet(&env->powerSusystem->battery.charge,false);
                SystemDelayMs(300);
                env->powerSusystem->battery.currentBatVoltage  =  AdcGet(env->powerSusystem->battery.batteryIo, 1000);
                SystemDelayMs(300);
                if (env->powerSusystem->battery.currentBatVoltage < 1000) {
                    env->powerSusystem->battery.currentBatVoltage = 0;
                }
                GpioPinSet(&env->powerSusystem->battery.charge,true);
                env->powerSusystem->battery.batTestTimer = SystemGetMs()+5000;
            }
            osMutexRelease(env->mux_accessPwrMan);
        }
        SystemDelayMs(100);
    }
}

void PowerManagement_StartThread(tPowerManagement *env) {
    if (!env->threadPwr.id) {
        env->threadPwr.id = osThreadNew((osThreadFunc_t) (Pwm_Thread), (void *) (env), &env->threadPwr.attr);
    } else {
        osThreadResume(env->threadPwr.id);
    }
}

bool Pwm_IsShutdownRequired(tPowerManagement *env) {
    uint32_t thisTime = SystemGetMs();
    uint32_t time = env->lastIgnEnabled + env->shutdownDelay;

    if(time < thisTime){
        return true;
    } else {
        return false;
    }
}