#include <iostream>

// Aufgabe 1
// Template für flexiblen Array Typ
template <typename T>
class Container {
public:
    // T-Pointer für Inhalt des Array
    T* data;
    // int für Größe des Array
    int arr_size;

    // Methode für Umkopieren in neues Array
    void updateSize(int new_arr_size) {
        // Reservierung von Speicher mit T-Pointer für Übergangsarray mit benötigter Größe
        T* new_data = new T[new_arr_size];
        // Füllen des Übergangsarray mit Array Inhalt
        for (int i = 0; i < arr_size; i++) {
            new_data[i] = data[i];
        }
        // Speicherfreigabe von altem Array
        delete[] data;
        // Array Inhalt von Objekt Instanz auf T-Pointer von Übergangsarray linken
        data = new_data;
        // Aktualisieren der Array Größe der Instanz
        arr_size = new_arr_size;
    }

    // Konstruktor mit Anfangsarraygröße als Parameter
    Container(int initial_arr_size){
        // Array Größe der Instanz initialisieren
        arr_size = initial_arr_size;
        // Speicherreservierung für Array Inhalt
        data = new T[initial_arr_size];
    }

    // Destruktor ?
    ~Container() {
        // Speicherfreigabe von Array Inhalt
        // delete[] data;
    }

    // Überladung des [] Operators
    T& operator[](int index) {
        // Aktualisierung auf neue Größe, falls nötig
        if (index >= arr_size) {
            updateSize(index + 1); 
        }
        // Eigentliche Rückgabe des Inhalt an Stelle des Index
        return data[index];
    }

    // Methode zur Rückgabe der Array Größe
    int getArraySize() {
        return arr_size;
    }
};

// Aufgabe 2
// Liest "test.wav" im Projektordner ein und gibt ein char Array mit dem Inhalt zurück
Container<char> wavFileToArr(){

    // Erstellen der Klasseninstanz mit Konstruktor
    Container<char> wavData(0);
    // Pointer auf test.wav
    FILE* input;
    // Variable zum Abspeichern von Byte Größe der wav Datei
    long num_bytes;
    
    // Öffnen der test.wav Datei in input mit Leserechten
    input = fopen("test.wav", "r");
    
    // Wenn test.wav Datei nicht existiert Abbruch
    if(input == NULL)
        return 1;
    
    // Setzen von FILE Pointer auf Ende der Datei
    fseek(input, 0, SEEK_END);
    // Abspeichern der Byte Größe mithilfe von input Pointer Position
    num_bytes = ftell(input);
    
    // Rücksetzen von FILE Pointer auf Anfang der Datei
    fseek(input, 0, SEEK_SET);	
    
    // Überladener [] Operator zur dynamischen Speicherreservierung
    wavData[num_bytes*sizeof(char)-1];
    
    // Einlesen der Datei mit num_bytes * sizeof(char) und Abspeichern in wavData Array
    fread(wavData.data, sizeof(char), num_bytes, input);
    
    // Freigabe des FILE Pointer
    fclose(input);

    return wavData;
};

// Aufgabe 3
// Transformiert "test.wav" im Projektordner zu einer Version mit 8000 Delay Echo
void wavFileEcho(){
    // FILE pointer output öffnet "output.wav" mit Schreibrechten
    FILE* output = fopen("output.wav","w");
    // Erstellung Array Instanz mit Methode zum Einlesen von Wav Dateien
    Container<char> sound_samples = wavFileToArr();
    // Erstellung Array Instanz für Ringbuffer
    Container<char> ringbuffer(0);
    // Übergangsvariable für später
    char mem;
    // Index für Ringbuffer
    int index = 0;

    // Füllen des dynamischen Array vom Ringbuffer mit 0en
    for(int i = 0; i<8000; i++){
        ringbuffer[i] = 0;
    }

    // Anfang bei i=44, weil ab da die Headerdatei fertig ist
    for(int i = 44; i<sound_samples.getArraySize(); i++){
        
        // Übergangsvariable zum merken von sound_samples[i]
        mem = sound_samples[i];
        // sound_samples[i] + Ringbuffer, der durch Index erst nach 8000 Durchläufen > 0 ist
        sound_samples[i] = sound_samples[i] + ringbuffer[index];
        // Ringbuffer bekommt Übergangsvariable übergeben
        ringbuffer[index] = mem;
        // Index erhöhen bis alle 8000stel
        index = (index+1)%8000;
        
    }

    // Schreiben der output.wav aus aktualisierten sound_samples.data 
    fwrite(sound_samples.data, sizeof(char), sound_samples.getArraySize(), output);
    // Freigabe des FILE Pointer 
    fclose(output);
}

int main() {

    wavFileEcho();

    std::cout << "wavFile Size: " << wavFileToArr().getArraySize() << std::endl;

    return 0;
};