#include <main.h>
#include <math.h>
#include <stdio.h>
#include <stm32g4xx_hal_conf.h>

#include "si5351.h"
#include "squeow.h"
#include "squeow_ui.h"

/* SQUEOW

TIM3 eventi 98304000/(49152×200) 10hz
TIM2 PWM 98304000/2048 48khz

risoluzione PWM 4*2048 -> 8192 (13bit)

*/

// SYS
uint8_t sys_tick, sys_tick_prescale, pwm_tick;

// UART
uint8_t UART_RX_buf[UART_RX_BUF_SIZE];

// SYNTH
uint32_t freq;

// ADC1
uint16_t adc1_valore;

// ADC2
uint16_t adc2_valori[4];
uint8_t adc2_done, adc_blocco, adc_allarmi[4];

// audio
uint16_t sample_value;
uint8_t stato_audio;
double sine_increment;
uint16_t samples_ringbuf[SAMPLES_BUFFER_SIZE]; ///< buffer ad anello dei dati RX
uint32_t samples_ringbuf_input_index, samples_ringbuf_output_index;
uint8_t usb_audio_tick;

// VU
uint8_t analog_wd_status;

// MOD
uint16_t pwm_value1, pwm_value2, pwm_value3, pwm_value4;
uint8_t rails_number;

// ###################################

void squeow_init(void) {
    seriow_log(2, "squeow init");
    sine_increment = 0.4;
    samples_ringbuf_input_index = 0;
    samples_ringbuf_output_index = 0;
    freq = DEFAULT_SYNTH_FREQUENCY;
    adc2_valori[0] = 10;
    adc2_valori[1] = 20;
    adc2_valori[2] = 30;
    adc2_valori[3] = 40;
}

uint32_t sat_sub(uint16_t x, uint16_t y) {
    uint16_t res = x - y;
    res &= -(res <= x);
    return res;
}

uint16_t u12_sine(void) {
    static double angle;
    angle += sine_increment;
    if (angle >= 6.28)
        angle = 0;
    return (uint16_t)((sin(angle) * 0x7ff) + 0x7ff);
}

/*
uint16_t get_adc_sample(void) {
    uint16_t adc_sample_value;
    // stato_audio == STATO_AUDIO_ADC;
    HAL_ADC_Start(&hadc1);
    if (HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK) {
        //                              store_sample(HAL_ADC_GetValue(&hadc1) << 4);
        adc_sample_value = HAL_ADC_GetValue(&hadc1);
    }
    HAL_ADC_Stop(&hadc1);
    return adc_sample_value;
}
*/


void store_samples(uint16_t *data, uint32_t size) {
    for (uint32_t i = 0; i < size; ++i) {
        store_sample(data[i]);
    }
}

void store_sample(uint16_t sample) {
    samples_ringbuf[samples_ringbuf_input_index] = sample;
    ringbuf_increment(&samples_ringbuf_input_index, SAMPLES_BUFFER_SIZE_MASK);
}

uint16_t get_sample(void) {
    ringbuf_increment(&samples_ringbuf_output_index, SAMPLES_BUFFER_SIZE_MASK);
    return samples_ringbuf[samples_ringbuf_output_index];
}

uint32_t ringbuf_increment(uint32_t *index, uint32_t buff_size_mask) {
    (*index)++;
    *index &= buff_size_mask;
    return *index;
}

void store_buffer(uint8_t *buf, uint32_t size) {
    for (uint32_t s = 0; s < size / 4; s++) {
        uint16_t LL = buf[s * 2];
        uint16_t RR = buf[(s * 2) + 1];
        store_sample(RR);
    }
}

int vu_meter(uint16_t sample) {
    uint16_t abs_sample, scaled_abs_sample;
    uint16_t zero = 0x7FF;
    abs_sample = (sample > zero) ? sample - zero : zero - sample;
    scaled_abs_sample = abs_sample >> 3;

    if (scaled_abs_sample >= vu_tmp_value)
        return scaled_abs_sample;
    else {
        return vu_tmp_value;
    }
}

// adc

void adc_rileva_soglie(uint16_t *adc_valori) {
    if (adc_valori[0] > SOGLIA_TEMPERATURA) {
        seriow_log(1, "ADC0 threshold detect");
        HAL_GPIO_WritePin(TEMP_OL_GPIO_Port, TEMP_OL_Pin, 1);
        adc_allarmi[0] = 1;
        adc_blocco = 1;
    }
    if (adc_valori[1] > SOGLIA_CORRENTE) {
        seriow_log(1, "ADC1 threshold detect");
        adc_allarmi[1] = 1;
        adc_blocco = 1;
    }
    if (adc_valori[3] > SOGLIA_RIFLESSA) {
        seriow_log(1, "ADC3 threshold detect");
        HAL_GPIO_WritePin(REFL_OL_GPIO_Port, REFL_OL_Pin, 1);
        adc_allarmi[3] = 1;
        adc_blocco = 1;
    }
}

// synth

void squeow_synth_init(void) {
    // occhio che blocca!
    seriow_log(2, "synth init");
    si5351_initialize();
}

void squeow_synth_set(freq) {
    seriow_log(2, "synth set freq");
    si5351_set_frequency(freq, 0);
    si5351_set_frequency(freq, 1);
}

void squeow_synth_on(void) {
    seriow_log(2, "synth on");
    si5351_on_clk(0);
    si5351_on_clk(1);
}

void squeow_synth_off(void) {
    seriow_log(2, "synth off");
    si5351_off_clk(0);
    si5351_off_clk(1);
}