#include "..\..\src\hw\board\mcu\mcu_hal.h"
#include "mock_mcu_hal_r8.h"

// Startup-Configuration functions
static startupCfg_t saved_hwCfg;

void mcu_startup(startupCfg_t* hwCfg)
{
    saved_hwCfg.adc_clk = hwCfg->adc_clk;
    saved_hwCfg.pwm_clk = hwCfg->pwm_clk;
	saved_hwCfg.pwm_top = hwCfg->pwm_top;
	saved_hwCfg.pwm_chb_en = hwCfg->pwm_chb_en;
}

void mock_mcu_startup_read_cfg(startupCfg_t* cfg_out)
{
    cfg_out->adc_clk = saved_hwCfg.adc_clk;
    cfg_out->pwm_clk = saved_hwCfg.pwm_clk;
	cfg_out->pwm_top = saved_hwCfg.pwm_top;
	cfg_out->pwm_chb_en = saved_hwCfg.pwm_chb_en;
}

void mock_mcu_startup_write_cfg(startupCfg_t* cfg_in)
{
   saved_hwCfg.adc_clk = cfg_in->adc_clk;
    saved_hwCfg.pwm_clk = cfg_in->pwm_clk;
	saved_hwCfg.pwm_top = cfg_in->pwm_top;
	saved_hwCfg.pwm_chb_en = cfg_in->pwm_chb_en;
}

// ADC Interface functions
#define ADC_CH_CNT 16
static uint8_t adc_ch = 0;
static uint16_t adc_raw[ADC_CH_CNT];

uint16_t mcu_adc_read(uint8_t ch)
{
    adc_ch = ch;

    //Safe guard mux
	if(ch > (ADC_CH_CNT-1)) return 0xFFFF;
	// Not available channels
	if((ch > 8) && (ch<14)) return 0xFFFF;

    return adc_raw[ch];
}

uint8_t mock_mcu_adc_read_ch(void)
{
    return adc_ch;
}

void mock_mcu_adc_set_ch(uint8_t new_ch)
{
    adc_ch = new_ch;
}

uint16_t mock_mcu_adc_read_raw(uint8_t ch)
{
    return adc_raw[ch];
}

void mock_mcu_adc_set_raw(uint16_t new_adc_out, uint8_t ch)
{
    adc_raw[ch] = new_adc_out;
}

// PWM Timer Interface functions
#define PWM_CH_CNT 2
static uint8_t pwm_ch = 0;
static uint16_t pwm_raw[PWM_CH_CNT];

void mcu_pwm_write(uint8_t ch, uint16_t dc)
{
    pwm_ch = ch;
    if(ch < PWM_CH_CNT) pwm_raw[ch] = dc;
}

uint16_t mcu_pwm_read(uint8_t ch)
{
    pwm_ch = ch;
    if(ch < PWM_CH_CNT) return pwm_raw[ch];
    else return 0;
}

uint8_t mock_mcu_pwm_read_ch(void)
{
    return pwm_ch;
}

void mock_mcu_pwm_set_ch(uint8_t new_ch)
{
    pwm_ch = new_ch;
}

uint16_t mock_mcu_pwm_read_raw(uint8_t ch)
{
    return pwm_raw[ch];
}

void mock_mcu_pwm_set_raw(uint16_t new_pwm, uint8_t ch)
{
    pwm_raw[ch] = new_pwm;
}

// GPIO Functions
#define GPIO_CH_CNT 18
static uint8_t gpio_ch = 0;
static uint8_t gpio_input_lvl[GPIO_CH_CNT];
static int8_t gpio_output_lvl[GPIO_CH_CNT];

uint8_t mcu_gpio_read(uint8_t ch)
{
    gpio_ch = ch;
    if(ch < GPIO_CH_CNT) return gpio_input_lvl[ch];
    else return 0;
}

void mcu_gpio_write(uint8_t ch, int8_t lvl)
{
    gpio_ch = ch;
    if(ch < GPIO_CH_CNT) gpio_output_lvl[ch] = lvl;
}

uint8_t mock_mcu_gpio_read_ch(void)
{
    return gpio_ch;
}

void mock_mcu_gpio_set_ch(uint8_t new_ch)
{
    gpio_ch = new_ch;
}

int8_t mock_mcu_gpio_read_output_lvl(uint8_t ch)
{
    return gpio_output_lvl[ch];
}

void mock_mcu_gpio_set_output_lvl(int8_t new_output_lvl, uint8_t ch)
{
    gpio_output_lvl[ch] = new_output_lvl;
}

void mock_mcu_gpio_set_input_lvl(uint8_t new_in_lvl, uint8_t ch)
{
    gpio_input_lvl[ch] = new_in_lvl;
}

// EEPROM functions
uint8_t mcu_ee_read8b(uint16_t address)
{
    return 0x00;
}

uint16_t mcu_ee_read16b(uint16_t address)
{
    return 0x0000;
}

uint32_t mcu_ee_read32b(uint16_t address)
{
    return 0x00000000;
}

void mcu_ee_write8b(uint16_t address, uint8_t value)
{

}

void mcu_ee_write16b(uint16_t address, uint16_t value)
{
}

void mcu_ee_write32b(uint16_t address, uint32_t value)
{

}