//
// Created by cfif on 03.06.2024.
//
#include "ComIntAmplifier.h"
#include "string.h"
#include "Amplifier_AW87579.h"
#include "SystemDelayInterface.h"

uint16_t XfcArrayGetBytesFrontToSendAmpl(tXfcAmplifier *env, tAmplifierType amplifierType, tXfcArray *array, uint8_t length) {

    uint16_t available = XfcArrayGetDataSize(array);
    uint16_t toGet = available > length ? length : available;

    if (amplifierType == AMPLIFIER_LEVEL) {
        env->geinControl.level = *(uint16_t *)(array->data + array->begin);
    }

    if (amplifierType == AMPLIFIER_VOLTAGE) {
        env->geinControl.voltage = *(uint16_t *)(array->data + array->begin);
    }

    if (amplifierType == LOW_STEP) {
        env->adptBoostVTH.boost_step = *(uint16_t *)(array->data + array->begin);
    }

    if (amplifierType == AMPLIFIER_AMPER) {
        env->geinControl.amper = *(uint16_t *)(array->data + array->begin);
    }

    if (amplifierType == BOOST_VTH1) {
        env->adptBoostVTH.boost_vth1 = *(uint16_t *)(array->data + array->begin);
    }

    if (amplifierType == BOOST_VTH2) {
        env->adptBoostVTH.boost_vth2 = *(uint16_t *)(array->data + array->begin);
    }

    if (amplifierType == ADP_MODE) {
        env->adpMode.level = *(uint16_t *)(array->data + array->begin);
    }

    if (amplifierType == AGC1_ATT_TIMEA) {
        env->agc1.attackTime = *(uint16_t *)(array->data + array->begin);
    }

    if (amplifierType == EN_BOOST) {
        env->enBoost.state = *(uint16_t *)(array->data + array->begin);
    }

    if (amplifierType == PD_AGC1_STATE) {
        env->agc1.state = *(uint16_t *)(array->data + array->begin);
    }

    if (amplifierType == PD_AGC3_OPR_STATE) {
        env->agc3_opr.state = *(uint16_t *)(array->data + array->begin);
    }

    if (amplifierType == AGC3_OPR_OUTPUT_POWER_LEVEL) {
        env->agc3_opr.out_power = *(uint16_t *)(array->data + array->begin);
    }

    if (amplifierType == AGC2_OUTPUT_POWER_LEVEL) {
        env->agc2opr.out_power = *(uint16_t *)(array->data + array->begin);
    }

    if (amplifierType == AGC2_ATT_TIME_VALUE) {
        env->aAgc2.attTime = *(uint16_t *)(array->data + array->begin);
    }

    if (amplifierType == AGC3_REL_TIME) {
        env->aAgc3.relTime = *(uint16_t *)(array->data + array->begin);
    }

    if (amplifierType == AGC3_ATT_TIME) {
        env->aAgc3.attTime = *(uint16_t *)(array->data + array->begin);
    }

    if (amplifierType == POWER) {
        env->powerMode = *(uint16_t *)(array->data + array->begin);
    }

    array->begin += toGet;

    return toGet;
}

static uint8_t XfcProtMethod_AmplSetChange(tXfcArray *request, tXfcArray *response, tXfcAmplifier *env) {

    // Запись избранных параметров
    uint16_t paramCount = 0;
    uint8_t paramValueID_len = 0;
    uint8_t paramValueID_text[64];

    XFC_CMD_RX_GET_RAW(paramCount);

    if (!paramCount) {
        return XFC_TRANSPORT_PROTOCOL_RESPONSE_RESULT_OK;
    }

    for (uint16_t count = 0; count < paramCount; ++count) {

        // Получение текстового id параметра
        XFC_CMD_RX_GET_RAW(paramValueID_len);
        XFC_CMD_RX_GET_ARR(paramValueID_text, paramValueID_len);

        uint8_t dataLen;
        XFC_CMD_RX_GET_RAW(dataLen);

        ///================= CLASS D GAIN CONTROL REGISTER (ADDRESS: 0x06) =================
        if (memcmp(paramValueID_text, "LEVEL", sizeof("LEVEL") - 1) == 0) {
            uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, AMPLIFIER_LEVEL, request, dataLen);
            if(env->geinControl.level > 7){
                env->amplifier->confRegs.sysctr.RCV_MODE = false ;

            } else {
                env->amplifier->confRegs.sysctr.RCV_MODE = true;
            }

            tAW87579_PAGR geinControl;
            geinControl = env->amplifier->confRegs.pagr;//env->amplifier->confStr->data[def_pagr];
            geinControl.PA_GAIN = env->amplifier->levels[env->geinControl.level];
            env->amplifier->confRegs.pagr = geinControl;

            if (countLen != dataLen) {
                return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT;
            }

        }

        ///================= BOOST OUTPUT VOLTAGE (BSTVOUT) REGISTER (ADDRESS: 0x03) =================
        if (memcmp(paramValueID_text, "VOLTAGE", sizeof("VOLTAGE") - 1) == 0) {
            uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, AMPLIFIER_VOLTAGE, request, dataLen);
            env->amplifier->confRegs.bstvout.BST_VOUT = env->amplifier->voltages[env->geinControl.voltage];

            if (countLen != dataLen) {
                return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT;
            }
        }

        ///================= BOOSTBOOST CONTROL REGISTER (ADDRESS: 0x05) =================
        if (memcmp(paramValueID_text, "AMPER", sizeof("AMPER") - 1) == 0) {
            uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, AMPLIFIER_AMPER, request, dataLen);
            env->amplifier->confRegs.bstcpr2.BST_IPEAK = env->amplifier->ampers[env->geinControl.amper];

            if (countLen != dataLen) {
                return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT;
            }
        }

        ///================= ADP BOOST PARAMETER REGISTER REGISTER (ADDRESS: 0x0F) =================
        if (memcmp(paramValueID_text, "LOW_STEP", sizeof("LOW_STEP") - 1) == 0) {
            uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, LOW_STEP, request, dataLen);
            env->amplifier->confRegs.adpbstVth.ADP_LOW_STEP = env->amplifier->boost_steps[env->adptBoostVTH.boost_step];

            if (countLen != dataLen) {
                return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT;
            }
        }

        if (memcmp(paramValueID_text, "BOOST_VTH1", sizeof("BOOST_VTH1") - 1) == 0) {
            uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, BOOST_VTH1, request, dataLen);
            env->amplifier->confRegs.adpbstVth.SET_BOOST_VTH1 = env->amplifier->boost_vths1[env->adptBoostVTH.boost_vth1];

            if (countLen != dataLen) {
                return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT;
            }
        }

        if (memcmp(paramValueID_text, "BOOST_VTH2", sizeof("BOOST_VTH2") - 1) == 0) {
            uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, BOOST_VTH2, request, dataLen);
            env->amplifier->confRegs.adpbstVth.SET_BOOST_VTH2 = env->amplifier->boost_vths2[env->adptBoostVTH.boost_vth2];

            if (countLen != dataLen) {
                return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT;
            }
        }

        ///================= ADP MODE PARAMETER REGISTER (ADDRESS: 0x0c) =================
        if (memcmp(paramValueID_text, "ADP_MODE", sizeof("ADP_MODE") - 1) == 0) {
            uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, ADP_MODE, request, dataLen);
            env->amplifier->confRegs.adpMode.ADPBOOST_MODE = env->amplifier->adp_boostModes[env->adpMode.level];

            if (countLen != dataLen) {
                return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT;
            }
        }

        ///================= CLASS D AGC1 PARAMETER (AGC1) REGISTER (ADDRESS: 0x0B) =================
        if (memcmp(paramValueID_text, "AGC1_ATT_TIMEA", sizeof("AGC1_ATT_TIMEA") - 1) == 0) {
            uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, AGC1_ATT_TIMEA, request, dataLen);
            env->amplifier->confRegs.pagc1Pr.AGC1_ATT_TIME = env->amplifier->agc1_att_times[env->agc1.attackTime];

            if (countLen != dataLen) {
                return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT;
            }
        }

        if (memcmp(paramValueID_text, "PD_AGC1_STATE", sizeof("PD_AGC1_STATE") - 1) == 0) {
            uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, PD_AGC1_STATE, request, dataLen);
            env->amplifier->confRegs.pagc1Pr.PD_AGC1 = env->agc1.state;

            if (countLen != dataLen) {
                return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT;
            }
        }

        ///================= CLASS D AGC2 OUTPUT POWER (AGC2_Po) REGISTER (ADDRESS: 0x09 DEFAULT:0x03) =================
        if (memcmp(paramValueID_text, "AGC2_OUTPUT_POWER_LEVEL", sizeof("AGC2_OUTPUT_POWER_LEVEL") - 1) == 0) {
            uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, AGC2_OUTPUT_POWER_LEVEL, request, dataLen);
            env->amplifier->confRegs.pagc2Opr.AGC2_OUTPUT_POWER = env->amplifier->agc2Opr_out_powers[env->agc2opr.out_power];

            if (countLen != dataLen) {
                return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT;
            }
        }

        ///================= CLASS D AGC2 PARAMETER (AGC2) REGISTER (ADDRESS: 0x0A DEFAULT:0x08 =================
        if (memcmp(paramValueID_text, "AGC2_ATT_TIME_VALUE", sizeof("AGC2_ATT_TIME_VALUE") - 1) == 0) {
            uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, AGC2_ATT_TIME_VALUE, request, dataLen);
            env->amplifier->confRegs.pagc2Pr.AGC2_ATT_TIME = env->amplifier->agc2_attTimes[env->aAgc2.attTime];

            if (countLen != dataLen) {
                return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT;
            }
        }

        ///================= CLASS D AGC3 PARAMETER (AGC3) REGISTER (ADDRESS: 0x08 DEFAULT:0x4E) =================
        if (memcmp(paramValueID_text, "AGC3_REL_TIME", sizeof("AGC3_REL_TIME") - 1) == 0) {
            uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, AGC3_REL_TIME, request, dataLen);
            env->amplifier->confRegs.pagc3Pr.AGC3_REL_TIME = env->amplifier->agc3_relTimes[env->aAgc3.relTime];

            if (countLen != dataLen) {
                return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT;
            }
        }

        if (memcmp(paramValueID_text, "AGC3_ATT_TIME", sizeof("AGC3_ATT_TIME") - 1) == 0) {
            uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, AGC3_ATT_TIME, request, dataLen);
            env->amplifier->confRegs.pagc3Pr.AGC3_ATT_TIME = env->amplifier->agc3_attTimes[env->aAgc3.attTime];

            if (countLen != dataLen) {
                return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT;
            }
        }

        ///================= CLASS D AGC3 (AGC3) OUTPUT POWER REGISTER (ADDRESS: 0x07) =================
        if (memcmp(paramValueID_text, "AGC3_OPR_OUTPUT_POWER_LEVEL", sizeof("AGC3_OPR_OUTPUT_POWER_LEVEL") - 1) == 0) {
            uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, AGC3_OPR_OUTPUT_POWER_LEVEL, request, dataLen);
            env->amplifier->confRegs.pagc3Opr.AGC3_OUTPUT_POWER = env->amplifier->agc3_out_powers[env->agc3_opr.out_power];

            if (countLen != dataLen) {
                return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT;
            }
        }

        if (memcmp(paramValueID_text, "PD_AGC3_OPR_STATE", sizeof("PD_AGC3_OPR_STATE") - 1) == 0) {
            uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, PD_AGC3_OPR_STATE, request, dataLen);
            env->amplifier->confRegs.pagc3Opr.PD_AGC3  = env->agc3_opr.state;

            if (countLen != dataLen) {
                return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT;
            }
        }

        ///================= EN_BOOST =================
        if (memcmp(paramValueID_text, "EN_BOOST", sizeof("EN_BOOST") - 1) == 0) {
            uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, EN_BOOST, request, dataLen);
            env->amplifier->confRegs.sysctr.EN_BOOST = env->enBoost.state;

            if (countLen != dataLen) {
                return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT;
            }
        }

        ///================= CUSTOM COMMAND POWER MANAGMENT =================
        if (memcmp(paramValueID_text, "POWER", sizeof("POWER") - 1) == 0) {
            uint16_t countLen = XfcArrayGetBytesFrontToSendAmpl(env, POWER, request, dataLen);
            if(env->powerMode == true){
                Amplifier_PowerOn(env->amplifier);
            } else {
                Amplifier_PowerOff(env->amplifier);
            }
            if (countLen != dataLen) {
                return XFC_TRANSPORT_PROTOCOL_REQUEST_UNEXPECTEDLY_SHORT;
            }
        }

        Amplifier_ChangeConf(env->amplifier);

    }
    return XFC_TRANSPORT_PROTOCOL_RESPONSE_RESULT_OK;
}


uint8_t XfcProtMethod_AmplifierSetChange(tXfcArray *request, tXfcArray *response, tXfcAmplifier *env) {

    uint8_t result = XfcProtMethod_AmplSetChange(request, response, env);

    return result;
}