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

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

void CanSpamTransmitter_Init(tCanSpamTransmitter *env,
                             tSerialPortFrameIO *ioCanFrame,
                             tLoggerInterface *logger) {

    env->ioCanFrame = ioCanFrame;
    env->logger = logger;
    env->access = osMutexNew(NULL);

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


static void sendEventToCan(tCanSpamTransmitter *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 eTimeEventTransmit isEventTransmitter(tCanSpamTransmitter *env) {

#if (CCU_Stat1_SEND == 1)
    if (env->time_CCU_Stat1_CYC < env->timeMs) {
        env->time_CCU_Stat1_CYC = env->timeMs + CCU_Stat1_CYC;

        env->can_id = Pack_CCU_Stat1_candb(&ccu_candb_tx.CCU_Stat1, env->canFrame.data, &env->canFrame.dlc, &env->ide);

        return event_CCU_Stat1_CYC;
    }
#endif


#if (CCU_Stat2_SEND == 1)
    if (env->time_CCU_Stat2_CYC < env->timeMs) {
        env->time_CCU_Stat2_CYC = env->timeMs + CCU_Stat2_CYC;

        env->can_id = Pack_CCU_Stat2_candb(&ccu_candb_tx.CCU_Stat2, env->canFrame.data, &env->canFrame.dlc, &env->ide);

        return event_CCU_Stat2_CYC;
    }
#endif

#if (CCU_Stat3_SEND == 1)
    if (env->time_CCU_Stat3_CYC < env->timeMs) {
        env->time_CCU_Stat3_CYC = env->timeMs + CCU_Stat3_CYC;

        env->can_id = Pack_CCU_Stat3_candb(&ccu_candb_tx.CCU_Stat3, env->canFrame.data, &env->canFrame.dlc, &env->ide);

        return event_CCU_Stat3_CYC;
    }
#endif

#if (CCU_Errors_SEND == 1)
    if (env->time_CCU_Errors_CYC < env->timeMs) {
        env->time_CCU_Errors_CYC = env->timeMs + CCU_Errors_CYC;

        env->can_id = Pack_CCU_Errors_candb(&ccu_candb_tx.CCU_Errors, env->canFrame.data, &env->canFrame.dlc,
                                            &env->ide);


        return event_CCU_Errors_CYC;
    }
#endif


#if (CCU_Requests_SEND == 1)
    if (env->time_CCU_Requests < env->timeMs) {
        env->time_CCU_Requests = env->timeMs + CCU_Requests_CYC;

        env->can_id = Pack_CCU_Requests_candb(&ccu_candb_tx.CCU_Requests, env->canFrame.data, &env->canFrame.dlc,
                                              &env->ide);

        return event_CCU_Requests;
    }
#endif

    // начало--------------------------------------0x310 CCU_HVC_Req_Msg------------------------------------------------
    // начало--------------------------------------0x310 CCU_HVC_Req_Msg------------------------------------------------
    // начало--------------------------------------0x310 CCU_HVC_Req_Msg------------------------------------------------
#if (CCU_HVC_Req_Msg_SEND == 1)
    if (env->time_CCU_HVC_Req_Msg < env->timeMs) {
        env->time_CCU_HVC_Req_Msg = env->timeMs + CCU_HVC_Req_Msg_CYC;

        // Rolling Counter [0 - 15]
        if (ccu_candb_tx.CCU_HVC_Req_Msg.CCU_HVC_Req_RC > 15) {
            ccu_candb_tx.CCU_HVC_Req_Msg.CCU_HVC_Req_RC = 0;
        } else {
            ++ccu_candb_tx.CCU_HVC_Req_Msg.CCU_HVC_Req_RC;
        }

        // Checksum XOR8 of the data field this message
        // Checksum computed as per XOR algorithm:
        // Byte 1 XOR byte 2 .... XOR byte n-1. (n = packet length.)

        uint8_t d0 = (uint8_t) ((ccu_candb_tx.CCU_HVC_Req_Msg.CCU_eCompSpeedReq_Val_ro & (0xFFU)));
        uint8_t d1 = (uint8_t) ((ccu_candb_tx.CCU_HVC_Req_Msg.CCU_eCompReq_Stat & (0x01U)) |
                                ((ccu_candb_tx.CCU_HVC_Req_Msg.CCU_LowTempValve_Req & (0x03U)) << 1U) |
                                ((ccu_candb_tx.CCU_HVC_Req_Msg.CCU_HVC_Req_RC & (0x0FU)) << 4U));

        ccu_candb_tx.CCU_HVC_Req_Msg.CCU_HVC_Req_CS = d0 ^ d1;

        env->can_id = Pack_CCU_HVC_Req_Msg_candb(&ccu_candb_tx.CCU_HVC_Req_Msg, env->canFrame.data, &env->canFrame.dlc,
                                                 &env->ide);

        return event_CCU_HVC_Req_Msg;
    }
#endif
    // конец ---------------------------------------0x310 CCU_HVC_Req_Msg------------------------------------------------
    // конец ---------------------------------------0x310 CCU_HVC_Req_Msg------------------------------------------------
    // конец ---------------------------------------0x310 CCU_HVC_Req_Msg------------------------------------------------

    // начало РЕЗЕРВ--------------------------------------0x315 CCU_VCU_Msg1---------------------------------------------------
    // начало РЕЗЕРВ--------------------------------------0x315 CCU_VCU_Msg1---------------------------------------------------
    // начало РЕЗЕРВ--------------------------------------0x315 CCU_VCU_Msg1---------------------------------------------------
#if (CCU_VCU_Msg1_SEND == 1)
    if (env->time_CCU_VCU_Msg1 < env->timeMs) {
        env->time_CCU_VCU_Msg1 = env->timeMs + CCU_VCU_Msg1_CYC;

        env->can_id = Pack_CCU_VCU_Msg1_candb(&ccu_candb_tx.CCU_VCU_Msg1, env->canFrame.data, &env->canFrame.dlc,
                                              &env->ide);

        return event_CCU_VCU_Msg1;
    }
#endif
    // конец РЕЗЕРВ---------------------------------------0x315 CCU_VCU_Msg1---------------------------------------------------
    // конец РЕЗЕРВ---------------------------------------0x315 CCU_VCU_Msg1---------------------------------------------------
    // конец РЕЗЕРВ---------------------------------------0x315 CCU_VCU_Msg1---------------------------------------------------

    // начало РЕЗЕРВ--------------------------------------0x316 CCU_VCU_Msg2---------------------------------------------------
    // начало РЕЗЕРВ--------------------------------------0x316 CCU_VCU_Msg2---------------------------------------------------
    // начало РЕЗЕРВ--------------------------------------0x316 CCU_VCU_Msg2---------------------------------------------------
#if (CCU_VCU_Msg2_SEND == 1)
    if (env->time_CCU_VCU_Msg2 < env->timeMs) {
        env->time_CCU_VCU_Msg2 = env->timeMs + CCU_VCU_Msg2_CYC;

        env->can_id = Pack_CCU_VCU_Msg2_candb(&ccu_candb_tx.CCU_VCU_Msg2, env->canFrame.data, &env->canFrame.dlc,
                                              &env->ide);

        return event_CCU_VCU_Msg2;
    }
#endif
    // конец РЕЗЕРВ---------------------------------------0x316 CCU_VCU_Msg2---------------------------------------------------
    // конец РЕЗЕРВ---------------------------------------0x316 CCU_VCU_Msg2---------------------------------------------------
    // конец РЕЗЕРВ---------------------------------------0x316 CCU_VCU_Msg2---------------------------------------------------

    // начало--------------------------------------0x380 CCU_Msg1-------------------------------------------------------
    // начало--------------------------------------0x380 CCU_Msg1-------------------------------------------------------
    // начало--------------------------------------0x380 CCU_Msg1-------------------------------------------------------
#if (CCU_Msg1_SEND == 1)
    if (env->time_CCU_Msg1 < env->timeMs) {
        env->time_CCU_Msg1 = env->timeMs + CCU_Msg1_CYC;

        // Rolling Counter [0 - 15]
        if (ccu_candb_tx.CCU_Msg1.CCU_MSG1_RC > 15) {
            ccu_candb_tx.CCU_Msg1.CCU_MSG1_RC = 0;
        } else {
            ++ccu_candb_tx.CCU_Msg1.CCU_MSG1_RC;
        }

        // Checksum XOR8 of the data field this message
        // Checksum computed as per XOR algorithm:
        // Byte 1 XOR byte 2 .... XOR byte n-1. (n = packet length.)
        uint8_t d0 = (uint8_t) ((ccu_candb_tx.CCU_Msg1.CCU_MirrorHeating_Req & (0x03U)) |
                                ((ccu_candb_tx.CCU_Msg1.CCU_RecirculationLed_Cmd & (0x01U)) << 2U) |
                                ((ccu_candb_tx.CCU_Msg1.CCU_DefrostLed_Req & (0x01U)) << 3U) |
                                ((ccu_candb_tx.CCU_Msg1.CCU_SideWindowHeating_Req & (0x03U)) << 4U) |
                                ((ccu_candb_tx.CCU_Msg1.CCU_RearWindowHeating_Req & (0x03U)) << 6U));
        uint8_t d1 = (uint8_t) ((ccu_candb_tx.CCU_Msg1.CCU_FrontWindowHeating_Req & (0x03U)) |
                                ((ccu_candb_tx.CCU_Msg1.CCU_EmergAirCleaning_Stat & (0x01U)) << 2U) |
                                ((ccu_candb_tx.CCU_Msg1.CCU_FireExtinguishSys_Stat & (0x01U)) << 3U));
        uint8_t d3 = (uint8_t) ((ccu_candb_tx.CCU_Msg1.CCU_FLAutoPsngrLed_Cmd & (0x01U)) |
                                ((ccu_candb_tx.CCU_Msg1.CCU_FRAutoPsngrLed_Cmd & (0x01U)) << 1U) |
                                ((ccu_candb_tx.CCU_Msg1.CCU_RLAutoPsngrLed_Cmd & (0x01U)) << 2U) |
                                ((ccu_candb_tx.CCU_Msg1.CCU_RRAutoPsngrLed_Cmd & (0x01U)) << 3U) |
                                ((ccu_candb_tx.CCU_Msg1.CCU_AC_MaxLed_Cmd & (0x01U)) << 4U));
        uint8_t d6 = (uint8_t) (((ccu_candb_tx.CCU_Msg1.CCU_MSG1_RC & (0x0FU)) << 4U));

        ccu_candb_tx.CCU_Msg1.CCU_MSG1_CS = d0 ^ d1 ^ d3 ^ d6;

        env->can_id = Pack_CCU_Msg1_candb(&ccu_candb_tx.CCU_Msg1, env->canFrame.data, &env->canFrame.dlc, &env->ide);

        return event_CCU_Msg1;
    }
#endif
    // начало--------------------------------------0x380 CCU_Msg1-------------------------------------------------------
    // начало--------------------------------------0x380 CCU_Msg1-------------------------------------------------------
    // начало--------------------------------------0x380 CCU_Msg1-------------------------------------------------------

    // начало--------------------------------------0x501 CCU_Msg3-------------------------------------------------------
    // начало--------------------------------------0x501 CCU_Msg3-------------------------------------------------------
    // начало--------------------------------------0x501 CCU_Msg3-------------------------------------------------------
#if (CCU_Msg3_SEND == 1)
    if (env->time_CCU_Msg3 < env->timeMs) {
        env->time_CCU_Msg3 = env->timeMs + CCU_Msg3_CYC;

        // Rolling Counter [0 - 15]
        if (ccu_candb_tx.CCU_Msg3.CCU_MSG3_RC > 15) {
            ccu_candb_tx.CCU_Msg3.CCU_MSG3_RC = 0;
        } else {
            ++ccu_candb_tx.CCU_Msg3.CCU_MSG3_RC;
        }

        // Checksum XOR8 of the data field this message
        // Checksum computed as per XOR algorithm:
        // Byte 1 XOR byte 2 .... XOR byte n-1. (n = packet length.)

        uint8_t d0 = (uint8_t) ((ccu_candb_tx.CCU_Msg3.CCU_FAN_Req & (0x7FU)));
        uint8_t d1 = (uint8_t) ((ccu_candb_tx.CCU_Msg3.CCU_RestMode_Stat & (0x03U)));
        uint8_t d2 = (uint8_t) ((ccu_candb_tx.CCU_Msg3.CCU_IncarTempSum_Val_ro & (0xFFU)));
        uint8_t d3 = (uint8_t) ((ccu_candb_tx.CCU_Msg3.CCU_MSG3_RC & (0x0FU)));

        ccu_candb_tx.CCU_Msg3.CCU_MSG3_CS = d0 ^ d1 ^ d2 ^ d3;


        env->can_id = Pack_CCU_Msg3_candb(&ccu_candb_tx.CCU_Msg3, env->canFrame.data, &env->canFrame.dlc, &env->ide);

        return event_CCU_Msg3;
    }
#endif
    // конец--------------------------------------0x501 CCU_Msg3-------------------------------------------------------
    // конец--------------------------------------0x501 CCU_Msg3-------------------------------------------------------
    // конец--------------------------------------0x501 CCU_Msg3-------------------------------------------------------

    // начало РЕЗЕРВ--------------------------------------0x18FFF200 CCU_AC_Ctrl -------------------------------------------------------
    // начало РЕЗЕРВ--------------------------------------0x18FFF200 CCU_AC_Ctrl -------------------------------------------------------
    // начало РЕЗЕРВ--------------------------------------0x18FFF200 CCU_AC_Ctrl -------------------------------------------------------
#if (CU_AC_Ctrl_SEND == 1)
    if (env->time_CCU_AC_Ctrl < env->timeMs) {
        env->time_CCU_AC_Ctrl = env->timeMs + CCU_AC_Ctrl_CYC;

        env->can_id = Pack_CCU_AC_Ctrl_candb(&ccu_candb_tx.CCU_AC_Ctrl, env->canFrame.data, &env->canFrame.dlc,
                                             &env->ide);

        return event_CCU_AC_Ctrl;
    }
#endif
    // конец РЕЗЕРВ--------------------------------------0x18FFF200 CCU_AC_Ctrl -------------------------------------------------------
    // конец РЕЗЕРВ--------------------------------------0x18FFF200 CCU_AC_Ctrl -------------------------------------------------------
    // конец РЕЗЕРВ--------------------------------------0x18FFF200 CCU_AC_Ctrl -------------------------------------------------------

    return event_CCU_none;
}

void set_CanSpamTransmitter(tCanSpamTransmitter *env) {
    if (osMutexAcquire(env->access, 5000) == osOK) {
        memcpy(&ccu_candb_tx.CCU_Errors, &rtY.CCU_Errors_model, sizeof(ccu_candb_tx.CCU_Errors));
        memcpy(&ccu_candb_tx.CCU_Stat1, &rtY.CCU_Stat1_model, sizeof(ccu_candb_tx.CCU_Stat1));
        osMutexRelease(env->access);
    } else {
        LoggerErrorStatic(LOGGER, LOG_SIGN, "Access error set_CanSpamTransmitter");
    }
}

void set_CCU_Mute(tCanSpamTransmitter *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 CanSpamTransmitter_Thread(tCanSpamTransmitter *env) {
    for (;;) {
        if (osMutexAcquire(env->access, 5000) == osOK) {

            if (env->isMute == false) {

                env->timeMs = GetSystemTick();

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

            }

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

void CanSpamTransmitter_StartThread(tCanSpamTransmitter *env) {
    if (!env->thread.id) {
        env->thread.id = osThreadNew((osThreadFunc_t) (CanSpamTransmitter_Thread), (void *) (env), &env->thread.attr);
    }
}