#include <cstdlib>
#include <fstream>
#include <iostream>
#include "guttersynth.hpp"

using namespace std;


class Wavefile {
private:
    std::ofstream output;
    size_t data_chunk_pos;
    
    template <typename Word>
    void write_word(Word value, unsigned size=sizeof(Word)) {
        for (; size; --size, value >>= 8)
        output.put( static_cast <char> (value & 0xFF) );
    }
    
public:
    Wavefile(string path, int samplerate) : output(path.c_str(), ios::binary) {
    
        int bitdepth = 16;
        // Write the file headers
        output << "RIFF----WAVEfmt ";       // (chunk size to be filled in later)
        write_word(16, 4);                  // no extension data
        write_word(1, 2);                   // PCM - integer samples
        write_word(1, 2);                   // one channel (mono file)
        write_word(samplerate, 4);          // samples per second (Hz)
        write_word(samplerate * (bitdepth / 8), 4); // byte rate
        write_word(2, 2);        // data block size ; was bitdepth / 8
        write_word(bitdepth, 2);            // number of bits per sample (use a multiple of 8)
        
        data_chunk_pos = output.tellp();
        output << "data----";               // (chunk size to be filled in later)
    }
    
    ~Wavefile() {
        std::cout << "closing\n";
        size_t file_length = output.tellp();
        
        // Fix the data chunk header to contain the data size
        output.seekp(data_chunk_pos + 4);
        write_word(file_length - (data_chunk_pos + 8), 4);

        // Fix the file header to contain the proper RIFF chunk size, which is (file size - 8) bytes
        output.seekp(0 + 4);
        write_word(file_length - 8, 4);
        output.close();
    }
    
    void write(double value) {
        write_word((short) (value * SHRT_MAX * 0.5), 2);
    }
    
    
};


class Example2 {
private:
    GutterSynth* gs;
    Wavefile* wav;
    int samplerate;
    
public:
    
    Example2(std::string path, int samplerate) {
        this->samplerate = samplerate;
        gs = new GutterSynth(2, 24, samplerate);
        wav = new Wavefile(path, samplerate);
    }
    
    double rangerandom(double min, double max) {
        double random = ((double) rand()) / (double) RAND_MAX;
        double diff = max - min;
        double r = random * diff;
        return min + r;
    }
    
    void run() {
        int total_samples = 30 * samplerate;
        int sample = 0;
        FLT data;
        gs->filtersOn(true);
        gs->smoothing(true);
        gs->distortionMethod(2);
        gs->randomiseFilters();

        for (int sample = 0; sample < total_samples; sample ++) {
            data = gs->process();
            wav->write(data);

            if (sample % samplerate == 0) { // randomise every second
                gs->randomiseFilters();
                gs->gamma(rangerandom(2, 10));
                gs->omega(rangerandom(0.3, 0.9));
                gs->c(rangerandom(0.5, 0.9));
                gs->dt(rangerandom(100, 500));
                gs->singleGain(rangerandom(0.2, 0.7));
            }
        }
        delete wav;
    }
};


/*
 * 
 */
int main(int argc, char** argv) {
    Example2* e = new Example2("guttersynth-example2.wav", 44100);
    e->run();
    return 0;
}