#include "ut_dout.h"

#include "..\mock_mcu\mock_mcu_hal_r8.h"
#include "..\..\src\hw\board\halfbridge.h"

static const uint8_t NOT_ACCESED_GPIO_CH = 255;
static const uint8_t NOT_ACCESED_GPIO_LVL = MCU_GPIO_HIZ;

static int ut_bsp_hb_write_low(uint8_t state, int8_t exp_gpio_lvl, uint8_t exp_gpio_ch)
{
    printf("   Input: State:%d \n", state);

    mock_mcu_gpio_set_ch(NOT_ACCESED_GPIO_CH);
    mock_mcu_gpio_set_output_lvl(NOT_ACCESED_GPIO_LVL, exp_gpio_ch);

    bsp_hb_write_low(state);

    uint8_t gpio_ch = mock_mcu_gpio_read_ch();
    int8_t gpio_lvl = mock_mcu_gpio_read_output_lvl(gpio_ch);

    printf("  Output: GPIO-lvl:%d GPIO-Ch:%d \n", gpio_lvl, gpio_ch);
    printf("Expected: GPIO-lvl:%d GPIO-Ch:%d \n", exp_gpio_lvl, exp_gpio_ch);

    if((gpio_lvl==exp_gpio_lvl)&&(gpio_ch==exp_gpio_ch))
    {
        printf("PASS\n\n");
        return 1;
    }
    else
    {
        printf("FAIL\n\n");
        return 0;
    }
}

int ut_bsp_hb_write_low_test(void)
{
    printf("******************************************************\n");
    printf("void bsp_hb_write_low(uint8_t state) \n");

    int test_res;
    int pass = 1;

    uint8_t state;
    int8_t exp_gpio_lvl;
    uint8_t exp_gpio_ch;

    // Low
    state = 0;
    exp_gpio_lvl = MCU_GPIO_LOW;
    exp_gpio_ch = MCU_GPIO15;
    test_res = ut_bsp_hb_write_low(state, exp_gpio_lvl, exp_gpio_ch);
    if(!test_res) pass = 0;

    // High
    state = 1;
    exp_gpio_lvl = MCU_GPIO_HIGH;
    exp_gpio_ch = MCU_GPIO15;
    test_res = ut_bsp_hb_write_low(state, exp_gpio_lvl, exp_gpio_ch);
    if(!test_res) pass = 0;

    // High
    state = 255;
    exp_gpio_lvl = MCU_GPIO_HIGH;
    exp_gpio_ch = MCU_GPIO15;
    test_res = ut_bsp_hb_write_low(state, exp_gpio_lvl, exp_gpio_ch);
    if(!test_res) pass = 0;

    return pass;
}

static const uint8_t NOT_ACCESED_PWM_CH = 255;
static const uint8_t NOT_ACCESED_PWM_VAL = 0xFFFF;

static int ut_bsp_hb_write_pwm(uint16_t pwm, uint16_t exp_pwm, uint8_t exp_pwm_ch)
{
    printf("   Input: PWM:%d \n", pwm);

    mock_mcu_pwm_set_ch(NOT_ACCESED_PWM_CH);
    mock_mcu_pwm_set_raw(NOT_ACCESED_PWM_VAL, exp_pwm_ch);

    bsp_hb_write_pwm(pwm);

    uint8_t pwm_ch = mock_mcu_pwm_read_ch();
    uint16_t pwm_value = mock_mcu_pwm_read_raw(pwm_ch);

    printf("  Output: PWM:%d PWM-Ch:%d \n", pwm_value, pwm_ch);
    printf("Expected: PWM:%d PWM-Ch:%d \n", exp_pwm, exp_pwm_ch);

    if((pwm_value==exp_pwm)&&(pwm_ch==exp_pwm_ch))
    {
        printf("PASS\n\n");
        return 1;
    }
    else
    {
        printf("FAIL\n\n");
        return 0;
    }
}

int ut_bsp_hb_write_pwm_test(void)
{
    printf("******************************************************\n");
    printf("void bsp_hb_write_pwm(uint16_t pwm) \n");

    int test_res;
    int pass = 1;

    uint16_t pwm;
    uint16_t exp_pwm;
    uint8_t exp_pwm_ch;

    // 0
    pwm = 0;
    exp_pwm = 0;
    exp_pwm_ch = MCU_PWM0;
    test_res = ut_bsp_hb_write_pwm(pwm, exp_pwm, exp_pwm_ch);
    if(!test_res) pass = 0;

    // 100
    pwm = 100;
    exp_pwm = 100;
    exp_pwm_ch = MCU_PWM0;
    test_res = ut_bsp_hb_write_pwm(pwm, exp_pwm, exp_pwm_ch);
    if(!test_res) pass = 0;

    // 95%
    pwm = 0xFC00;
    exp_pwm = 0xFC00;
    exp_pwm_ch = MCU_PWM0;
    test_res = ut_bsp_hb_write_pwm(pwm, exp_pwm, exp_pwm_ch);
    if(!test_res) pass = 0;

    // MAX
    pwm = 0xFFFF;
    exp_pwm = 0xFC00;
    exp_pwm_ch = MCU_PWM0;
    test_res = ut_bsp_hb_write_pwm(pwm, exp_pwm, exp_pwm_ch);
    if(!test_res) pass = 0;

    return pass;
}

static const uint8_t NOT_ACCESED_ADC_CH = 255;
static const uint8_t NOT_ACCESED_ADC_VAL = 0xFFFF;

static int ut_bsp_hb_read_meas(uint16_t adc_sup_u, uint16_t adc_sup_i, uint16_t adc_out_u, uint16_t adc_out_i, uint8_t low_side_lvl, uint16_t act_pwm, hb_meas_t* exp_meas)
{
    printf("   Input: Out-U:%d Out-I:%d Sup-U:%d Sup-I:%d Low-Lvl:%d PWM:%d \n", adc_out_u, adc_out_i, adc_sup_u, adc_sup_i, low_side_lvl, act_pwm);

    mock_mcu_adc_set_ch(NOT_ACCESED_ADC_CH);
    mock_mcu_adc_set_raw(adc_sup_u, MCU_ADC2);
    mock_mcu_adc_set_raw(adc_sup_i, MCU_ADC3);
    mock_mcu_adc_set_raw(adc_out_u, MCU_ADC1);
    mock_mcu_adc_set_raw(adc_out_i, MCU_ADC0);

    mock_mcu_gpio_set_ch(NOT_ACCESED_GPIO_CH);
    mock_mcu_gpio_set_input_lvl(low_side_lvl, MCU_GPIO15);

    mock_mcu_pwm_set_ch(NOT_ACCESED_PWM_CH);
    mock_mcu_pwm_set_raw(act_pwm, MCU_PWM0);

    hb_meas_t out;

    bsp_hb_read_meas(&out);

    uint8_t adc_ch = mock_mcu_adc_read_ch();
    uint8_t gpio_ch = mock_mcu_gpio_read_ch();
    uint8_t pwm_ch = mock_mcu_pwm_read_ch();

    int equal = 1;

    if(out.out_voltage != exp_meas->out_voltage) equal = 0;
    if(out.out_current != exp_meas->out_current) equal = 0;
    if(out.sup_voltage != exp_meas->sup_voltage) equal = 0;
    if(out.sup_current != exp_meas->sup_current) equal = 0;
    if(out.out_power != exp_meas->out_power) equal = 0;
    if(out.sup_power != exp_meas->sup_power) equal = 0;
    if(out.out_impedance != exp_meas->out_impedance) equal = 0;
    if(out.low_side_ctrl != exp_meas->low_side_ctrl) equal = 0;
    if(out.pwm != exp_meas->pwm) equal = 0;

    printf("  Output: Out-U:%d Out-I:%d Bat-U:%d Bat-I:%d Out-P:%d Bat-P:%d Out-Z:%d Low:%d PWM:%d \n", out.out_voltage, out.out_current, out.sup_voltage, out.sup_current, out.out_power, out.sup_power, out.out_impedance, out.low_side_ctrl, out.pwm);
    printf("Expected: Out-U:%d Out-I:%d Bat-U:%d Bat-I:%d Out-P:%d Bat-P:%d Out-Z:%d Low:%d PWM:%d \n",  exp_meas->out_voltage,  exp_meas->out_current,  exp_meas->sup_voltage,  exp_meas->sup_current,  exp_meas->out_power,  exp_meas->sup_power,  exp_meas->out_impedance,  exp_meas->low_side_ctrl,  exp_meas->pwm);

    if((equal)&&(gpio_ch==MCU_GPIO15)&&(pwm_ch==MCU_PWM0)&&(adc_ch!=NOT_ACCESED_ADC_CH))
    {
        printf("PASS\n\n");
        return 1;
    }
    else
    {
        printf("FAIL\n\n");
        return 0;
    }
}

int ut_bsp_hb_read_meas_test(void)
{
    printf("******************************************************\n");
    printf("void bsp_hb_read_meas(hb_meas_t* measurements) \n");

    int test_res;
    int pass = 1;

    uint16_t adc_sup_u;
    uint16_t adc_sup_i;
    uint16_t adc_out_u;
    uint16_t adc_out_i;
    uint8_t low_side_lvl;
    uint16_t act_pwm;
    hb_meas_t exp_meas;

    // 0
    adc_sup_u = 0;
    adc_sup_i = 0;
    adc_out_u = 0;
    adc_out_i = 0;
    low_side_lvl = MCU_GPIO_LOW;
    act_pwm = 0x0000;
    exp_meas.out_voltage = 0;
    exp_meas.out_current = 0;
    exp_meas.sup_voltage = 0;
    exp_meas.sup_current = 0;
    exp_meas.out_power = 0;
    exp_meas.sup_power = 0;
    exp_meas.out_impedance = 0xFFFF;
    exp_meas.low_side_ctrl = 0;
    exp_meas.pwm = 0;
    test_res = ut_bsp_hb_read_meas(adc_sup_u, adc_sup_i, adc_out_u, adc_out_i, low_side_lvl, act_pwm, &exp_meas);
    if(!test_res) pass = 0;

    // Limits
    adc_sup_u = 1023;
    adc_sup_i = 1023;
    adc_out_u = 1023;
    adc_out_i = 1023;
    low_side_lvl = MCU_GPIO_HIGH;
    act_pwm = 457;
    exp_meas.out_voltage = 20460;
    exp_meas.out_current = 9997;
    exp_meas.sup_voltage = 20460;
    exp_meas.sup_current = 40067;
    exp_meas.out_power = 0xFFFF;
    exp_meas.sup_power = 0xFFFF;
    exp_meas.out_impedance = 2046;
    exp_meas.low_side_ctrl = 1;
    exp_meas.pwm = 457;
    test_res = ut_bsp_hb_read_meas(adc_sup_u, adc_sup_i, adc_out_u, adc_out_i, low_side_lvl, act_pwm, &exp_meas);
    if(!test_res) pass = 0;

    // Normal
    adc_sup_u = 600;
    adc_sup_i = 51;
    adc_out_u = 300;
    adc_out_i = 409;
    low_side_lvl = MCU_GPIO_HIGH;
    act_pwm = 0xAAAA;
    exp_meas.out_voltage = 6000;
    exp_meas.out_current = 3997;
    exp_meas.sup_voltage = 12000;
    exp_meas.sup_current = 1997;
    exp_meas.out_power = 23982;
    exp_meas.sup_power = 23964;
    exp_meas.out_impedance = 1501;
    exp_meas.low_side_ctrl = 1;
    exp_meas.pwm = 0xAAAA;
    test_res = ut_bsp_hb_read_meas(adc_sup_u, adc_sup_i, adc_out_u, adc_out_i, low_side_lvl, act_pwm, &exp_meas);
    if(!test_res) pass = 0;

    return pass;
}