//
// Created by cfif on 05.12.2025.
//
#include <SystemDelayInterface.h>
#include "CanSpamDebugTransmitter.h"
#include "CmsisRtosThreadUtils.h"
#include "CanPorts.h"
#include "memory.h"
#include "HVAC_model.h"
#include "candb_dbg_fixed.h"

#define LOG_SIGN "CAN_DEBUG_TRANSMITTER"
#define LOGGER env->logger

void CanSpamDebugTransmitter_Init(tCanSpamDebugTransmitter *env,
                                  tSerialPortFrameIO *ioCanFrame,
                                  tCanSpamDebugReceiver *canSpamDebugReceiver,
                                  osMutexId_t modelTaskAccess,
                                  tLoggerInterface *logger) {

    env->ioCanFrame = ioCanFrame;
    env->modelTaskAccess = modelTaskAccess;
    env->logger = logger;
    env->canSpamDebugReceiver = canSpamDebugReceiver;
    env->access = osMutexNew(NULL);
    env->dbg_Sen_Duct_MultMsg_Idx = 0;
    env->dbg_Sen_Incar_MultMsg_Idx = 0;
    env->dbg_DiffBlr_ValveOpen_MultMsg_Idx = 0;
    env->dbg_CCU_Info_MultMsg_Idx = 0;
    env->dbg_Auto_Duct_MultMsg_Idx = 0;
    env->dbg_Auto_AF_MultMsg_Idx = 0;

    InitThreadAtrStatic(&env->thread.attr, "CanSpamDebugTrans", env->thread.controlBlock, env->thread.stack,
                        osPriorityNormal);
}


static void sendEventToCan(tCanSpamDebugTransmitter *env) {

    if (env->ide) {
        env->canFrame.id_type = FLEXCAN_ID_EXT;
        env->canFrame.extended_id = env->can_id;
    } else {
        env->canFrame.id_type = FLEXCAN_ID_STD;
        env->canFrame.standard_id = env->can_id;
    }

    env->ioCanFrame->transmit(env->ioCanFrame->env, (uint8_t * ) & env->canFrame.data, env->canFrame.dlc,
                              env->can_id, env->canFrame.id_type, 100);
}


static eTimeEventDbgTransmit isEventTransmitter(tCanSpamDebugTransmitter *env) {

#if (dbg_Act0_SEND == 1)
    if (env->time_dbg_Act0_CYC <= env->timeMs) {
        env->time_dbg_Act0_CYC = env->timeMs + dbg_Act0_CYC;

        env->can_id = Pack_dbg_Act0_candb_dbg(&ccu_candb_dbg_tx.dbg_Act0, env->canFrame.data, &env->canFrame.dlc,
                                              &env->ide);

        return event_dbg_Act0_CYC;
    }
#endif

#if (dbg_Act1_SEND == 1)
    if (env->time_dbg_Act1_CYC <= env->timeMs) {
        env->time_dbg_Act1_CYC = env->timeMs + dbg_Act1_CYC;

        env->can_id = Pack_dbg_Act1_candb_dbg(&ccu_candb_dbg_tx.dbg_Act1, env->canFrame.data, &env->canFrame.dlc,
                                              &env->ide);

        return event_dbg_Act1_CYC;
    }
#endif

#if (dbg_Act2_SEND == 1)
    if (env->time_dbg_Act2_CYC <= env->timeMs) {
        env->time_dbg_Act2_CYC = env->timeMs + dbg_Act2_CYC;

        env->can_id = Pack_dbg_Act2_candb_dbg(&ccu_candb_dbg_tx.dbg_Act2, env->canFrame.data, &env->canFrame.dlc,
                                              &env->ide);

        return event_dbg_Act2_CYC;
    }
#endif


#if (dbg_Auto_AF_SEND == 1)
    if (env->time_dbg_Auto_AF_CYC <= env->timeMs) {
        env->time_dbg_Auto_AF_CYC = env->timeMs + dbg_Auto_AF_CYC;

        ccu_candb_dbg_tx.dbg_Auto_AF.dbg_Auto_AF_MultMsg_Idx = env->dbg_Auto_AF_MultMsg_Idx;

        env->can_id = Pack_dbg_Auto_AF_candb_dbg2(&ccu_candb_dbg_tx.dbg_Auto_AF, env->canFrame.data,
                                                  &env->canFrame.dlc, &env->ide);

        ++env->dbg_Auto_AF_MultMsg_Idx;
        if (env->dbg_Auto_AF_MultMsg_Idx > 3) {
            env->dbg_Auto_AF_MultMsg_Idx = 0;
        }

        return event_dbg_Auto_AF_CYC;
    }
#endif

#if (dbg_Auto_Duct_SEND == 1)
    if (env->time_dbg_Auto_Duct_CYC <= env->timeMs) {
        env->time_dbg_Auto_Duct_CYC = env->timeMs + dbg_Auto_Duct_CYC;

        ccu_candb_dbg_tx.dbg_Auto_Duct.dbg_Auto_Duct_MultMsg_Idx = env->dbg_Auto_Duct_MultMsg_Idx;

        env->can_id = Pack_dbg_Auto_Duct_candb_dbg2(&ccu_candb_dbg_tx.dbg_Auto_Duct, env->canFrame.data,
                                                    &env->canFrame.dlc, &env->ide);

        ++env->dbg_Auto_Duct_MultMsg_Idx;
        if (env->dbg_Auto_Duct_MultMsg_Idx > 5) {
            env->dbg_Auto_Duct_MultMsg_Idx = 0;
        }

        return event_dbg_Auto_Duct_CYC;
    }
#endif

#if (dbg_Auto_Valve_Plus_SEND == 1)
    if (env->time_dbg_Auto_Valve_Plus_CYC <= env->timeMs) {
        env->time_dbg_Auto_Valve_Plus_CYC = env->timeMs + dbg_Auto_Valve_Plus_CYC;

        env->can_id = Pack_dbg_Auto_Valve_Plus_candb_dbg(&ccu_candb_dbg_tx.dbg_Auto_Valve_Plus, env->canFrame.data,
                                                         &env->canFrame.dlc, &env->ide);

        return event_dbg_Auto_Valve_Plus_CYC;
    }
#endif

#if (dbg_CCU_Info_SEND == 1)
    if (env->time_dbg_CCU_Info_CYC <= env->timeMs) {
        env->time_dbg_CCU_Info_CYC = env->timeMs + dbg_CCU_Info_CYC;

        ccu_candb_dbg_tx.dbg_CCU_Info.dbg_Info_MultMsg_Idx = env->dbg_CCU_Info_MultMsg_Idx;

        env->can_id = Pack_dbg_CCU_Info_candb_dbg2(&ccu_candb_dbg_tx.dbg_CCU_Info, env->canFrame.data,
                                                   &env->canFrame.dlc, &env->ide);

        ++env->dbg_CCU_Info_MultMsg_Idx;
        if (env->dbg_CCU_Info_MultMsg_Idx > 3) {
            env->dbg_CCU_Info_MultMsg_Idx = 0;
        }

        return event_dbg_CCU_Info_CYC;
    }
#endif

#if (dbg_CCU_IO_SEND == 1)
    if (env->time_dbg_CCU_IO_CYC <= env->timeMs) {
        env->time_dbg_CCU_IO_CYC = env->timeMs + dbg_CCU_IO_CYC;

        env->can_id = Pack_dbg_CCU_IO_candb_dbg(&ccu_candb_dbg_tx.dbg_CCU_IO, env->canFrame.data,
                                                &env->canFrame.dlc, &env->ide);

        return event_dbg_CCU_IO_CYC;
    }
#endif

#if (dbg_DiffBlr_ValveOpen_SEND == 1)
    if (env->time_dbg_DiffBlr_ValveOpen_CYC <= env->timeMs) {
        env->time_dbg_DiffBlr_ValveOpen_CYC = env->timeMs + dbg_DiffBlr_ValveOpen_CYC;

        ccu_candb_dbg_tx.dbg_DiffBlr_ValveOpen.Logic_ValveOpen_MultMsg_Idx = env->dbg_DiffBlr_ValveOpen_MultMsg_Idx;

        env->can_id = Pack_dbg_DiffBlr_ValveOpen_candb_dbg2(&ccu_candb_dbg_tx.dbg_DiffBlr_ValveOpen, env->canFrame.data,
                                                            &env->canFrame.dlc, &env->ide);

        ++env->dbg_DiffBlr_ValveOpen_MultMsg_Idx;
        if (env->dbg_DiffBlr_ValveOpen_MultMsg_Idx > 3) {
            env->dbg_DiffBlr_ValveOpen_MultMsg_Idx = 0;
        }

        return event_dbg_DiffBlr_ValveOpen_CYC;
    }
#endif


#if (dbg_Drs_SEND == 1)
    if (env->time_dbg_Drs_CYC <= env->timeMs) {
        env->time_dbg_Drs_CYC = env->timeMs + dbg_Drs_CYC;

        env->can_id = Pack_dbg_Drs_candb_dbg(&ccu_candb_dbg_tx.dbg_Drs, env->canFrame.data,
                                             &env->canFrame.dlc, &env->ide);

        return event_dbg_Drs_CYC;
    }
#endif

#if (dbg_Info_Act1_SEND == 1)
    if (env->time_dbg_Info_Act1_CYC <= env->timeMs) {
        env->time_dbg_Info_Act1_CYC = env->timeMs + dbg_Info_Act1_CYC;

        env->can_id = Pack_dbg_Info_Act1_candb_dbg(&ccu_candb_dbg_tx.dbg_Info_Act1, env->canFrame.data,
                                                   &env->canFrame.dlc, &env->ide);

        return event_dbg_Info_Act1_CYC;
    }
#endif

#if (dbg_Info_Act2_SEND == 1)
    if (env->time_dbg_Info_Act2_CYC <= env->timeMs) {
        env->time_dbg_Info_Act2_CYC = env->timeMs + dbg_Info_Act2_CYC;

        env->can_id = Pack_dbg_Info_Act2_candb_dbg(&ccu_candb_dbg_tx.dbg_Info_Act2, env->canFrame.data,
                                                   &env->canFrame.dlc, &env->ide);

        return event_dbg_Info_Act2_CYC;
    }
#endif

#if (dbg_LIN_AirQS_Stat_SEND == 1)
    if (env->time_dbg_LIN_AirQS_Stat_CYC <= env->timeMs) {
        env->time_dbg_LIN_AirQS_Stat_CYC = env->timeMs + dbg_LIN_AirQS_Stat_CYC;

        env->can_id = Pack_dbg_LIN_AirQS_Stat_candb_dbg(&ccu_candb_dbg_tx.dbg_LIN_AirQS_Stat, env->canFrame.data,
                                                        &env->canFrame.dlc, &env->ide);

        return event_dbg_LIN_AirQS_Stat_CYC;
    }
#endif

#if (dbg_LIN_Aroma_Stat_SEND == 1)
    if (env->time_dbg_LIN_Aroma_Stat_CYC <= env->timeMs) {
        env->time_dbg_LIN_Aroma_Stat_CYC = env->timeMs + dbg_LIN_Aroma_Stat_CYC;

        env->can_id = Pack_dbg_LIN_Aroma_Stat_candb_dbg(&ccu_candb_dbg_tx.dbg_LIN_Aroma_Stat, env->canFrame.data,
                                                        &env->canFrame.dlc, &env->ide);

        return event_dbg_LIN_Aroma_Stat_CYC;
    }
#endif

#if (dbg_LIN_DRS_Stat_SEND == 1)
    if (env->time_dbg_LIN_DRS_Stat_CYC <= env->timeMs) {
        env->time_dbg_LIN_DRS_Stat_CYC = env->timeMs + dbg_LIN_DRS_Stat_CYC;

        env->can_id = Pack_dbg_LIN_DRS_Stat_candb_dbg(&ccu_candb_dbg_tx.dbg_LIN_DRS_Stat, env->canFrame.data,
                                                      &env->canFrame.dlc, &env->ide);

        return event_dbg_LIN_DRS_Stat_CYC;
    }
#endif

#if (dbg_LIN_eTXV_Stat_SEND == 1)
    if (env->time_dbg_LIN_eTXV_Stat_CYC <= env->timeMs) {
        env->time_dbg_LIN_eTXV_Stat_CYC = env->timeMs + dbg_LIN_eTXV_Stat_CYC;

        env->can_id = Pack_dbg_LIN_eTXV_Stat_candb_dbg(&ccu_candb_dbg_tx.dbg_LIN_eTXV_Stat, env->canFrame.data,
                                                       &env->canFrame.dlc, &env->ide);

        return event_dbg_LIN_eTXV_Stat_CYC;
    }
#endif

#if (dbg_LIN_Ionizer_Stat_SEND == 1)
    if (env->time_dbg_LIN_Ionizer_Stat_CYC <= env->timeMs) {
        env->time_dbg_LIN_Ionizer_Stat_CYC = env->timeMs + dbg_LIN_Ionizer_Stat_CYC;

        env->can_id = Pack_dbg_LIN_Ionizer_Stat_candb_dbg(&ccu_candb_dbg_tx.dbg_LIN_Ionizer_Stat, env->canFrame.data,
                                                          &env->canFrame.dlc, &env->ide);

        return event_dbg_LIN_Ionizer_Stat_CYC;
    }
#endif

#if (dbg_Logic_Ac_SEND == 1)
    if (env->time_dbg_Logic_Ac_CYC <= env->timeMs) {
        env->time_dbg_Logic_Ac_CYC = env->timeMs + dbg_Logic_Ac_CYC;

        env->can_id = Pack_dbg_Logic_Ac_candb_dbg(&ccu_candb_dbg_tx.dbg_Logic_Ac, env->canFrame.data,
                                                  &env->canFrame.dlc, &env->ide);

        return event_dbg_Logic_Ac_CYC;
    }
#endif

#if (dbg_Logic_Blower_SEND == 1)
    if (env->time_dbg_Logic_Blower_CYC <= env->timeMs) {
        env->time_dbg_Logic_Blower_CYC = env->timeMs + dbg_Logic_Blower_CYC;

        env->can_id = Pack_dbg_Logic_Blower_candb_dbg(&ccu_candb_dbg_tx.dbg_Logic_Blower, env->canFrame.data,
                                                      &env->canFrame.dlc, &env->ide);

        return event_dbg_Logic_Blower_CYC;
    }
#endif

#if (dbg_Logic_KM_Status_SEND == 1)
    if (env->time_dbg_Logic_KM_Status_CYC <= env->timeMs) {
        env->time_dbg_Logic_KM_Status_CYC = env->timeMs + dbg_Logic_KM_Status_CYC;

        env->can_id = Pack_dbg_Logic_KM_Status_candb_dbg(&ccu_candb_dbg_tx.dbg_Logic_KM_Status, env->canFrame.data,
                                                         &env->canFrame.dlc, &env->ide);

        return event_dbg_Logic_KM_Status_CYC;
    }
#endif

#if (dbg_Logic_Rec_SEND == 1)
    if (env->time_dbg_Logic_Rec_CYC <= env->timeMs) {
        env->time_dbg_Logic_Rec_CYC = env->timeMs + dbg_Logic_Rec_CYC;

        env->can_id = Pack_dbg_Logic_Rec_candb_dbg(&ccu_candb_dbg_tx.dbg_Logic_Rec, env->canFrame.data,
                                                   &env->canFrame.dlc, &env->ide);

        return event_dbg_Logic_Rec_CYC;
    }
#endif

#if (dbg_Logic_State_SEND == 1)
    if (env->time_dbg_Logic_State_CYC <= env->timeMs) {
        env->time_dbg_Logic_State_CYC = env->timeMs + dbg_Logic_State_CYC;

        env->can_id = Pack_dbg_Logic_State_candb_dbg(&ccu_candb_dbg_tx.dbg_Logic_State, env->canFrame.data,
                                                     &env->canFrame.dlc, &env->ide);

        return event_dbg_Logic_State_CYC;
    }
#endif

#if (dbg_Logic_Valve_SEND == 1)
    if (env->time_dbg_Logic_Valve_CYC <= env->timeMs) {
        env->time_dbg_Logic_Valve_CYC = env->timeMs + dbg_Logic_Valve_CYC;

        env->can_id = Pack_dbg_Logic_Valve_candb_dbg(&ccu_candb_dbg_tx.dbg_Logic_Valve, env->canFrame.data,
                                                     &env->canFrame.dlc, &env->ide);

        return event_dbg_Logic_Valve_CYC;
    }
#endif

#if (dbg_Sen_0_SEND == 1)
    if (env->time_dbg_Sen_0_CYC <= env->timeMs) {
        env->time_dbg_Sen_0_CYC = env->timeMs + dbg_Sen_0_CYC;

        env->can_id = Pack_dbg_Sen_0_candb_dbg(&ccu_candb_dbg_tx.dbg_Sen_0, env->canFrame.data,
                                               &env->canFrame.dlc, &env->ide);

        return event_dbg_Sen_0_CYC;
    }
#endif

#if (dbg_Sen_Amb_SEND == 1)
    if (env->time_dbg_Sen_Amb_CYC <= env->timeMs) {
        env->time_dbg_Sen_Amb_CYC = env->timeMs + dbg_Sen_Amb_CYC;

        env->can_id = Pack_dbg_Sen_Amb_candb_dbg(&ccu_candb_dbg_tx.dbg_Sen_Amb, env->canFrame.data,
                                                 &env->canFrame.dlc, &env->ide);

        return event_dbg_Sen_Amb_CYC;
    }
#endif

#if (dbg_Sen_Demist_SEND == 1)
    if (env->time_dbg_Sen_Demist_CYC <= env->timeMs) {
        env->time_dbg_Sen_Demist_CYC = env->timeMs + dbg_Sen_Demist_CYC;

        env->can_id = Pack_dbg_Sen_Demist_candb_dbg(&ccu_candb_dbg_tx.dbg_Sen_Demist, env->canFrame.data,
                                                    &env->canFrame.dlc, &env->ide);

        return event_dbg_Sen_Demist_CYC;
    }
#endif

#if (dbg_Sen_Duct_SEND == 1)
    if (env->time_dbg_Sen_Duct_CYC <= env->timeMs) {
        env->time_dbg_Sen_Duct_CYC = env->timeMs + dbg_Sen_Duct_CYC;

        if (env->dbg_Sen_Duct_MultMsg_Idx >= 3) {
            env->dbg_Sen_Duct_MultMsg_Idx = 0;
        } else {
            ++env->dbg_Sen_Duct_MultMsg_Idx;
        }

        ccu_candb_dbg_tx.dbg_Sen_Duct.dbg_Sen_Duct_MultMsg_Idx = env->dbg_Sen_Duct_MultMsg_Idx;

        env->can_id = Pack_dbg_Sen_Duct_candb_dbg2(&ccu_candb_dbg_tx.dbg_Sen_Duct, env->canFrame.data,
                                                   &env->canFrame.dlc, &env->ide);

        return event_dbg_Sen_Duct_CYC;
    }
#endif

#if (dbg_Sen_Eva_SEND == 1)
    if (env->time_dbg_Sen_Eva_CYC <= env->timeMs) {
        env->time_dbg_Sen_Eva_CYC = env->timeMs + dbg_Sen_Eva_CYC;

        env->can_id = Pack_dbg_Sen_Eva_candb_dbg(&ccu_candb_dbg_tx.dbg_Sen_Eva, env->canFrame.data, &env->canFrame.dlc,
                                                 &env->ide);

        return event_dbg_Sen_Eva_CYC;
    }
#endif

#if (dbg_Sen_Incar_SEND == 1)
    if (env->time_dbg_Sen_Incar_CYC <= env->timeMs) {
        env->time_dbg_Sen_Incar_CYC = env->timeMs + dbg_Sen_Incar_CYC;

        if (env->dbg_Sen_Incar_MultMsg_Idx >= 1) {
            env->dbg_Sen_Incar_MultMsg_Idx = 0;
        } else {
            ++env->dbg_Sen_Incar_MultMsg_Idx;
        }

        ccu_candb_dbg_tx.dbg_Sen_Incar.dbg_Sen_Incar_MultMsg_Idx = env->dbg_Sen_Incar_MultMsg_Idx;

        env->can_id = Pack_dbg_Sen_Incar_candb_dbg2(&ccu_candb_dbg_tx.dbg_Sen_Incar, env->canFrame.data,
                                                    &env->canFrame.dlc, &env->ide);


        return event_dbg_Sen_Incar_CYC;
    }
#endif

    return event_dbg_none;
}

void set_CanDebugSpamTransmitter(tCanSpamDebugTransmitter *env) {
    if (osMutexAcquire(env->access, 5000) == osOK) {
        memcpy(&ccu_candb_dbg_tx.dbg_Act0, &rtY.dbgCAN_dbg_Act0_model, sizeof(ccu_candb_dbg_tx.dbg_Act0));
        memcpy(&ccu_candb_dbg_tx.dbg_Act1, &rtY.dbgCAN_dbg_Act1_model, sizeof(ccu_candb_dbg_tx.dbg_Act1));
        memcpy(&ccu_candb_dbg_tx.dbg_Act2, &rtY.dbgCAN_dbg_Act2_model, sizeof(ccu_candb_dbg_tx.dbg_Act2));
        memcpy(&ccu_candb_dbg_tx.dbg_Sen_Duct, &rtY.dbgCAN_dbg_Sen_Duct_model, sizeof(ccu_candb_dbg_tx.dbg_Sen_Duct));
        memcpy(&ccu_candb_dbg_tx.dbg_Sen_Eva, &rtY.dbgCAN_dbg_Sen_Eva_model, sizeof(ccu_candb_dbg_tx.dbg_Sen_Eva));
        memcpy(&ccu_candb_dbg_tx.dbg_Logic_Blower, &rtY.dbgCAN_dbg_Logic_Blower_model,
               sizeof(ccu_candb_dbg_tx.dbg_Logic_Blower));
        memcpy(&ccu_candb_dbg_tx.dbg_Sen_Amb, &rtY.dbgCAN_dbg_Sen_Amb_model, sizeof(ccu_candb_dbg_tx.dbg_Sen_Amb));
        memcpy(&ccu_candb_dbg_tx.dbg_Sen_Incar, &rtY.dbgCAN_dbg_Sen_Incar_model,
               sizeof(ccu_candb_dbg_tx.dbg_Sen_Incar));
        memcpy(&ccu_candb_dbg_tx.dbg_Sen_0, &rtY.dbgCAN_dbg_Sen_0_model, sizeof(ccu_candb_dbg_tx.dbg_Sen_0));

        memcpy(&ccu_candb_dbg_tx.dbg_Logic_Ac, &rtY.dbg_Logic_Ac_model, sizeof(ccu_candb_dbg_tx.dbg_Logic_Ac));
        memcpy(&ccu_candb_dbg_tx.dbg_CCU_IO, &rtY.dbgCAN_CCU_IO_model, sizeof(ccu_candb_dbg_tx.dbg_CCU_IO));

        osMutexRelease(env->access);
    } else {
        LoggerErrorStatic(LOGGER, LOG_SIGN, "Access error set_CanDebugSpamTransmitter");
    }
}

void set_DBG_CCU_Mute(tCanSpamDebugTransmitter *env, bool mute) {
    if (osMutexAcquire(env->access, 5000) == osOK) {
        env->isMute = mute;
        osMutexRelease(env->access);
    } else {
        LoggerErrorStatic(LOGGER, LOG_SIGN, "Access error set_CCU_Mute");
    }
}

static _Noreturn void CanSpamDebugTransmitter_Thread(tCanSpamDebugTransmitter *env) {
    for (;;) {
        SystemDelayMs(50);

        if (env->isMute == false) {

            if (osMutexAcquire(env->access, 5000) == osOK) {

                env->timeMs += 50;

                while (isEventTransmitter(env) != event_dbg_none) {
                    sendEventToCan(env);
                }


                osMutexRelease(env->access);

            } else {
                LoggerErrorStatic(LOGGER, LOG_SIGN, "Access error CanSpamDebugTransmitter_Thread");
            }

        }
    }
}

void CanSpamDebugTransmitter_StartThread(tCanSpamDebugTransmitter *env) {
    if (!env->thread.id) {
        env->thread.id = osThreadNew((osThreadFunc_t) (CanSpamDebugTransmitter_Thread), (void *) (env),
                                     &env->thread.attr);
    }
}