#pragma once

#include <iostream>


#define NUM_COMBS 4
#define NUM_ALLPASS 2


#define LOG_INFO(msg) std::cout<<"[INFO] "<<msg<<std::endl;
#define LOG_WARN(msg) std::cout<<"[WARN] "<<msg<<std::endl;
#define LOG_ERROR(msg) std::cout<<"[ERROR] "<<msg<<std::endl;

float db_to_vol(float db) {
    return pow(10, db / 20);
}

class Header {
public:
    uint8_t riff_label[4]; // (00) = {'R','I','F','F'}
    uint32_t riff_size; // (04) = 36 + data_size
    uint8_t file_tag[4]; // (08) = {'W','A','V','E'}
    uint8_t fmt_label[4]; // (12) = {'f','m','t',' '}
    uint32_t fmt_size; // (16) = 16
    uint16_t audio_format; // (20) = 1
    uint16_t channel_count; // (22) = 1 or 2
    uint32_t sampling_rate; // (24) = (anything)
    uint32_t bytes_per_second; // (28) = (see above)
    uint16_t bytes_per_sample; // (32) = (see above)
    uint16_t bits_per_sample; // (34) = 8 or 16
    uint8_t data_label[4]; // (36) = {'d','a','t','a'}
    uint32_t data_size; // (40) = # bytes of data
};

class Wave {
public:
    Header header;
    std::vector<std::vector<float>> samples;
    std::vector<float> max_amplitude;
    std::vector<float> min_amplitude;

    int num_samples = 0;
    int num_channels = 0;

    void read_header(std::string file_path) {
        FILE* in = fopen(file_path.c_str(), "rb");
        if (!in) {
            LOG_ERROR("read : file does not exsit");
            exit(-1);
        }
        fread(&header, sizeof(Header), 1, in);
        fclose(in);
        if (header.channel_count > 1) {
            LOG_ERROR("read : only mono tracks supported for now");
            exit(-1);
        }
    }

    void write_header(std::string file_path) {
        if (header.channel_count > 1) {
            LOG_ERROR("write : only mono tracks supported for now");
            exit(-1);
        }
        FILE* out = fopen(file_path.c_str(), "wb");
        if (!out) {
            LOG_ERROR("write : file does not exsit");
            exit(-1);
        }
        fseek(out, 0, SEEK_SET);
        fwrite(&header, sizeof(header), 1, out);
        fclose(out);
    }

    void print_header(int i) {
        printf("\n[HEADER]\n");
        if (i) printf("riff_label:       %c%c%c%c.\n", header.riff_label[0], header.riff_label[1], header.riff_label[2], header.riff_label[3]);
        printf("riff_size:        %u.\n", header.riff_size);
        if (i) printf("file_tag:         %c%c%c%c.\n", header.file_tag[0], header.file_tag[1], header.file_tag[2], header.file_tag[3]);
        if (i) printf("fmt_label:        %c%c%c%c.\n", header.fmt_label[0], header.fmt_label[1], header.fmt_label[2], header.fmt_label[3]);
        printf("fmt_size:         %u.\n", header.fmt_size);
        printf("audio_format:     %u.\n", header.audio_format);
        printf("channel_count:    %u.\n", header.channel_count);
        printf("sampling_rate:    %u.\n", header.sampling_rate);
        printf("bytes_per_second: %u.\n", header.bytes_per_second);
        printf("bytes_per_sample: %u.\n", header.bytes_per_sample);
        printf("bits_per_sample:  %u.\n", header.bits_per_sample);
        if (i) printf("data_label:       %c%c%c%c.\n", header.data_label[0], header.data_label[1], header.data_label[2], header.data_label[3]);
        printf("data_size:        %u.\n", header.data_size);
    }

    void read_data(std::string file_path) {
        FILE* in = fopen(file_path.c_str(), "rb");
        num_samples = header.data_size / (header.channel_count * header.bits_per_sample / 8);
        num_channels = header.channel_count;
        fseek(in, sizeof(Header), SEEK_SET);
        uint8_t* data = new uint8_t[header.data_size];
        fread(data, header.data_size, 1, in);
        int16_t* data16 = (int16_t*)(data);
        // clear all channels
        for (int channel = 0;channel < (int)samples.size();++channel) {
            samples[channel].clear();
        }
        samples.clear();
        // resize buffer and reserve samples
        samples.resize(num_channels);
        for (int channel = 0;channel < (int)samples.size();++channel) {
            samples[channel].reserve(num_samples);
        }
        // convert PCM data to float samples
        for (int i = 0;i < num_samples;++i) {
            for (int c = 0;c < num_channels;++c) {
                if (header.bits_per_sample == 16) {
                    float sample = data16[i * num_channels + c] / (float)((1 << 15));
                    samples[c].push_back(sample);
                }
                else {
                    LOG_ERROR("read : only 16 bit signed pcm supported");
                    exit(-1);
                }

            }
        }
        delete[] data;
        fclose(in);
    }

    void write_data(std::string file_path) {
        FILE* out = fopen(file_path.c_str(), "ab");
        fseek(out, sizeof(Header), SEEK_SET);
        for (int i = 0;i < num_samples;++i) {
            for (int c = 0;c < num_channels;++c) {
                float sample = samples[c][i];
                if (header.bits_per_sample == 16) {
                    int16_t bytes_2 = (sample * ((1 << 15)));
                    fwrite(&bytes_2, 2, 1, out);
                }
                else {
                    LOG_ERROR("write : only 16 bit signed pcm supported");
                    exit(-1);
                }
            }
        }
        fclose(out);
    }

    void read_wav(std::string file_path) {
        read_header(file_path);
        read_data(file_path);
    }

    void write_wav(std::string file_path) {
        write_header(file_path.c_str());
        write_data(file_path.c_str());
    }

    void init_channels_maxmin() {
        // clear it
        max_amplitude.clear();
        min_amplitude.clear();
        // initialize
        for (int i = 0;i < num_channels;++i) {
            max_amplitude.push_back(std::numeric_limits<float>::min());
            min_amplitude.push_back(std::numeric_limits<float>::max());
        }
    }

    void update_channel_maxmin() {
        for (int i = 0;i < num_samples;++i) {
            for (int c = 0;c < num_channels;++c) {
                float sample = samples[c][i];
                //track max min
                if (sample > max_amplitude[c]) {
                    max_amplitude[c] = sample;
                }
                if (sample < min_amplitude[c]) {
                    min_amplitude[c] = sample;
                }
            }
        }
    }

    void normalize(float min, float max) {
        std::vector<float> sum;
        sum.resize(2, 0.0f);
        for (int i = 0; i < num_samples; i++) {
            for (int c = 0; c < num_channels; c++) {
                float x = samples[c][i];
                sum[c] += x;
            }
        }

        for (int i = 0; i < num_samples; i++) {
            for (int c = 0; c < num_channels; c++) {
                samples[c][i] += sum[c] / num_samples;
                float x = samples[c][i];
                x = ((max - min) * (x - min_amplitude[c]) / (max_amplitude[c] - min_amplitude[c])) - (max - min) / 2;
                samples[c][i] = x;
            }
        }
    }

    void info_summary() {
        LOG_INFO("sample_rate : " << header.sampling_rate);
        LOG_INFO("bit_depth : " << header.bits_per_sample);
        LOG_INFO("num_channels : " << num_channels);
        LOG_INFO("num_samples : " << num_samples);
        LOG_INFO("num_seconds : " << num_samples / header.sampling_rate);
    }
};



/*
#include "iostream"
#include "fstream"
#include "vector"
#include "limits"
#include "math.h"

#define PI 3.14159265358979323846

#define LOG_INFO(msg) std::cout<<"[INFO] "<<msg<<std::endl;
#define LOG_WARN(msg) std::cout<<"[WARN] "<<msg<<std::endl;
#define LOG_ERROR(msg) std::cout<<"[ERROR] "<<msg<<std::endl;

float min(float a, float b){
    if(a<b){
        return a;
    }
    else{
        return b;
    }
}

float max(float a, float b){
    if(a>b){
        return a;
    }
    else{
        return b;
    }
}

float lerp(float l, float r, float t, float lo=0.0f, float hi=1.0f){

    if(hi == lo){
        return l;
    }

    t = (t-lo)/(hi-lo);

    // interpolate
    return l*(1-t) + r*(t);
}

class GainFilter{
public:
    float gain=1.0f;
public:
    void init(float g=1.0f){
        gain = g;
    }

    void set_gain(float g){
        gain = g;
    }

    float process(float n){
        return n*gain;
    }
};

class DelayFilter{
public:
    std::vector<float> delay_pipe;
    float delay_samples;
    float delay_ms;
    float delay_frac;
    float max_delay_ms;
    int max_delay_samples;
    int w_index;
    int r_index;
public:

    void init(float ms, float delay_ms_max, int sample_rate=48000){

        delay_samples = 0.0f;
        delay_ms = ms;
        max_delay_samples = ceil(sample_rate * delay_ms_max / 1000.0f);
        max_delay_ms = max_delay_samples * 1000.0f / sample_rate;

        // get the delay in sammples and separate out fractional parts
        float delay_raw = sample_rate * ms / 1000.0f;
        delay_samples = floor(delay_raw);
        delay_frac = delay_raw - delay_samples;

        // initialize the delay pipe with 0.0f data and set read write indexes
        r_index = 0;
        w_index = 0;

        delay_pipe.resize(max_delay_samples,0.0f);

    }

    float process(float n){

        float out=0.0f;
        if(delay_samples == 0){
            out = n;
        }
        else{
            out = read_delay();
        }
        write_delay(n);
        return out;
    }

    void set_delay_ms(float ms,int sample_rate=48000){
        
        if(ms > max_delay_ms){
            LOG_ERROR("Delay Filter : exceeded max_delay_ms");
            return;
        }
        // delay
        delay_ms = ms;

        // get the delay in sammples and separate out fractional parts
        float delay_raw = sample_rate * ms / 1000.0f;
        delay_samples = floor(delay_raw);
        delay_frac = delay_raw - delay_samples;

        // read position and wrap around the buffer max size
        r_index = w_index - delay_samples;
        r_index = r_index<0?r_index+max_delay_samples:r_index;
        
    }

    float read_delay(){
        float out = 0.0f;
        out = delay_pipe[r_index];

        int n_minus_one_r_index = r_index - 1;
        n_minus_one_r_index = n_minus_one_r_index < 0? max_delay_samples - 1: n_minus_one_r_index;

        float out_n_minus_one = delay_pipe[n_minus_one_r_index];

        return lerp(out,out_n_minus_one,delay_frac);
    }

    void write_delay(float n){
        
        delay_pipe[w_index++] = n;
        w_index = w_index >= max_delay_samples ? 0 : w_index;

        ++r_index;
        r_index = r_index >= max_delay_samples ? 0 : r_index;

    }

    void reset(){
        delay_pipe.clear();
        delay_pipe.resize(max_delay_samples,0.0f);
        r_index = 0;
        w_index = 0;
        set_delay_ms(delay_ms,48000);
    }

};

class LowPassFilter{
public:
    float coeff=0.0f;
    float n_minus_one=0.0f;
public:

    void init(float lp_coeff,int sample_rate=48000){
        set_coeff(lp_coeff);
    }

    float process(float n){
        n_minus_one = n * (1 - coeff) + (coeff * n_minus_one); // this was the correct one 
        return n_minus_one;
    }

    void set_coeff(float c){
        coeff = c;
    }
};

class CombFilter{
public:
    GainFilter gain_filter;
    DelayFilter delay_filter;
    LowPassFilter low_pass_filter;
public:
    void init(float ms, float delay_ms_max, float g, float lp_coeff, int sample_rate=48000){
        delay_filter.init(ms,delay_ms_max,sample_rate);
        low_pass_filter.init(lp_coeff,sample_rate);
        gain_filter.init(g);
    }
    float process(float n){
        // delay -> gain -> low pass -> feedback -> output
        float delayed_n = delay_filter.read_delay();
        float delayed_n_gain = gain_filter.process(delayed_n);
        float delayed_n_gain_low_pass = low_pass_filter.process(delayed_n_gain);
        float delayed_n_gain_low_pass_feedback = n + delayed_n_gain_low_pass;
        delay_filter.write_delay(delayed_n_gain_low_pass_feedback);
        float out = delayed_n;
        return out;
    }

};

class AllPassFilter{
public:
    float wet_dry_ratio=1.0f;
    DelayFilter delay_filter;
    GainFilter gain_filter;

public:
    void init(float ms, float delay_ms_max, float g, int sample_rate=48000){
        delay_filter.init(ms,delay_ms_max,sample_rate);
        gain_filter.init(g);
    }

    float process(float n){
        float delayed_n = delay_filter.read_delay();
        float delayed_n_gain = gain_filter.process(delayed_n);
        float delayed_n_gain_feedback = n + delayed_n_gain;
        float out = delayed_n + (-1.0f)*(gain_filter.process(delayed_n_gain_feedback));
        delay_filter.write_delay(delayed_n_gain_feedback);
        return out;
    }

};


class Header{
public:
	uint8_t riff_label[4]; // (00) = {'R','I','F','F'}
	uint32_t riff_size; // (04) = 36 + data_size
	uint8_t file_tag[4]; // (08) = {'W','A','V','E'}
	uint8_t fmt_label[4]; // (12) = {'f','m','t',' '}
	uint32_t fmt_size; // (16) = 16
	uint16_t audio_format; // (20) = 1
	uint16_t channel_count; // (22) = 1 or 2
	uint32_t sampling_rate; // (24) = (anything)
	uint32_t bytes_per_second; // (28) = (see above)
	uint16_t bytes_per_sample; // (32) = (see above)
	uint16_t bits_per_sample; // (34) = 8 or 16
	uint8_t data_label[4]; // (36) = {'d','a','t','a'}
	uint32_t data_size; // (40) = # bytes of data
};

class Wave{
public:
    Header header;
    std::vector<std::vector<float>> samples;
    std::vector<float> max_amplitude;
    std::vector<float> min_amplitude;

    int num_samples=0;
    int num_channels=0;

    void read_header(std::string file_path){
        FILE* in = fopen(file_path.c_str(),"rb");
        if(!in){
            LOG_ERROR("read : file does not exsit");
            exit(-1);
        }
        fread(&header,sizeof(Header),1,in);
        fclose(in);
        if(header.channel_count > 1){
            LOG_ERROR("read : only mono tracks supported for now");
            exit(-1);
        }
    }

    void write_header(std::string file_path){
        if(header.channel_count > 1){
            LOG_ERROR("write : only mono tracks supported for now");
            exit(-1);
        }
        FILE* out = fopen(file_path.c_str(),"wb");
        if(!out){
            LOG_ERROR("write : file does not exsit");
            exit(-1);
        }
        fseek(out,0,SEEK_SET);
        fwrite(&header,sizeof(header),1,out);
        fclose(out);
    }

    void print_header(int i){
         	  printf("\n[HEADER]\n");
        if(i) printf("riff_label:       %c%c%c%c.\n",header.riff_label[0],header.riff_label[1],header.riff_label[2],header.riff_label[3]);
        	  printf("riff_size:        %u.\n",header.riff_size);
        if(i) printf("file_tag:         %c%c%c%c.\n",header.file_tag[0],header.file_tag[1],header.file_tag[2],header.file_tag[3]);
        if(i) printf("fmt_label:        %c%c%c%c.\n",header.fmt_label[0],header.fmt_label[1],header.fmt_label[2],header.fmt_label[3]);	
        	  printf("fmt_size:         %u.\n",header.fmt_size);
        	  printf("audio_format:     %u.\n",header.audio_format);
        	  printf("channel_count:    %u.\n",header.channel_count);
        	  printf("sampling_rate:    %u.\n",header.sampling_rate);		  
        	  printf("bytes_per_second: %u.\n",header.bytes_per_second);
        	  printf("bytes_per_sample: %u.\n",header.bytes_per_sample);
        	  printf("bits_per_sample:  %u.\n",header.bits_per_sample);
        if(i) printf("data_label:       %c%c%c%c.\n",header.data_label[0],header.data_label[1],header.data_label[2],header.data_label[3]);
        	  printf("data_size:        %u.\n",header.data_size);
    }

    void read_data(std::string file_path){
        FILE* in = fopen(file_path.c_str(),"rb");
        num_samples = header.data_size/(header.channel_count*header.bits_per_sample/8);
        num_channels = header.channel_count;
        fseek(in,sizeof(Header),SEEK_SET);
        uint8_t* data = new uint8_t[header.data_size];
        fread(data,header.data_size,1,in);
        int16_t* data16 = (int16_t*)(data);
        // clear all channels
        for(int channel=0;channel<(int)samples.size();++channel){
            samples[channel].clear();
        }
        samples.clear();
        // resize buffer and reserve samples
        samples.resize(num_channels);
        for(int channel=0;channel<(int)samples.size();++channel){
            samples[channel].reserve(num_samples);
        }
        // convert PCM data to float samples
        for(int i=0;i<num_samples;++i){
            for(int c=0;c<num_channels;++c){
                if(header.bits_per_sample == 16){
                    float sample = data16[i*num_channels + c]/(float)((1<<15));
                    samples[c].push_back(sample);
                }
                else{
                    LOG_ERROR("read : only 16 bit signed pcm supported");
                    exit(-1);
                }

            }
        }   
        delete[] data;
        fclose(in);
    }

    void write_data(std::string file_path){
        FILE* out = fopen(file_path.c_str(),"ab");
        fseek(out,sizeof(Header),SEEK_SET);
        for(int i=0;i<num_samples;++i){
            for(int c=0;c<num_channels;++c){
                float sample = samples[c][i];
                if(header.bits_per_sample == 16){
                    int16_t bytes_2 = (sample * ((1<<15)));
                    fwrite(&bytes_2,2,1,out);
                }
                else{
                    LOG_ERROR("write : only 16 bit signed pcm supported");
                    exit(-1);
                }
            }
        }
        fclose(out);
    }

    void read_wav(std::string file_path){
        read_header(file_path);
        read_data(file_path);
    }

    void write_wav(std::string file_path){
        write_header(file_path.c_str());
        write_data(file_path.c_str());
    }

    void init_channels_maxmin(){
        // clear it
        max_amplitude.clear();
        min_amplitude.clear();
        // initialize
        for(int i=0;i<num_channels;++i){
            max_amplitude.push_back(std::numeric_limits<float>::min());
            min_amplitude.push_back(std::numeric_limits<float>::max());
        }
    }

    void update_channel_maxmin(){
        for(int i=0;i<num_samples;++i){
            for(int c=0;c<num_channels;++c){
                float sample = samples[c][i];
                //track max min
                if(sample > max_amplitude[c]){
                    max_amplitude[c] = sample;
                }
                if(sample < min_amplitude[c]){
                    min_amplitude[c] = sample;
                }
            }
        }
    }

    void normalize(float min, float max){
        std::vector<float> sum;
        sum.resize(2,0.0f);
        for (int i = 0; i < num_samples; i++){
            for (int c = 0; c < num_channels; c++){
                float x = samples[c][i];
                sum[c] += x;
            }
        }

        for (int i = 0; i < num_samples; i++){
            for (int c = 0; c < num_channels; c++){
                samples[c][i] += sum[c]/num_samples;
                float x = samples[c][i];
                x = ((max-min) * (x - min_amplitude[c]) / (max_amplitude[c] - min_amplitude[c])) - (max-min)/2;
                samples[c][i] = x;
            }
        }
    }

    void info_summary(){
        LOG_INFO("sample_rate : "<<header.sampling_rate);
        LOG_INFO("bit_depth : "<<header.bits_per_sample);
        LOG_INFO("num_channels : "<<num_channels);
        LOG_INFO("num_samples : "<<num_samples);
        LOG_INFO("num_seconds : "<<num_samples/header.sampling_rate);
    }
};

*/