#include <iostream>
#include <iomanip>
#include <fstream>
#include <vector>
#include "Fourier.h"

using namespace std;

vector<CKomplex> werte_einlesen(string dateiname) {
    int i, N, idx;
    double re, im;
    vector<CKomplex> werte;
    ifstream fp;
    fp.open(dateiname);
    if (fp.is_open()) {
        fp >> N;
        werte.resize(N);
        CKomplex null(0, 0);
        for (i = 0; i < N; i++)
            werte[i] = null;
        while (!fp.eof()) {
            fp >> idx >> re >> im;
            CKomplex a(re, im);
            werte[idx] = a;
        }
        fp.close();
    }
    return werte;
}

void werte_ausgeben(string dateiname, vector<CKomplex> &werte, double epsilon = -1.0) {

    int i;
    int N = werte.size();
    ofstream fp;
    fp.open(dateiname);
    if (fp.is_open()) {
        fp << N << endl;
        for (i = 0; i < N; i++)
            if (werte[i].abs() > epsilon)
                fp << i << "\t" << setprecision(10) << werte[i].re() << "\t" << werte[i].im() << endl;
        fp.close();
    }
}

double abweichung(vector<CKomplex> &a, vector<CKomplex> &b) {
    double r;
    if (a.size() == b.size()) {
        for (size_t i(0U), sz(a.size()); i != sz; i++) {
            CKomplex a1(a[i]);
            CKomplex b1(b[i]);
            CKomplex difC = b1 - a1;
            double difAbs = difC.abs();
            if (r < difAbs)
                r = difAbs;
        }
    }
    return r;
}

void abweichungBestimmen(string dateinameTransformiert, vector<CKomplex> transformierteWerte, double epsilon,
                         string dateinameOriginal) {
    vector<CKomplex> originaleWerte(werte_einlesen(dateinameOriginal));
    werte_ausgeben(dateinameTransformiert, transformierteWerte, epsilon);

    vector<CKomplex> transformierteWerteEpsilon = werte_einlesen(dateinameTransformiert);
    vector<CKomplex> zurueckTransformiertWerte = Fourier::zurueck(transformierteWerteEpsilon);

    string nameZ = "Z" + dateinameTransformiert;
    werte_ausgeben(nameZ, zurueckTransformiertWerte, -1);

    cout << "Maximale Abweichung bei epsilon " << epsilon << " = " << abweichung(
        originaleWerte, zurueckTransformiertWerte) << endl;
}

int main() {
    string dateinameOriginal = "Daten_original2.txt";

    vector<CKomplex> originalWerte = werte_einlesen(dateinameOriginal);

    vector<CKomplex> transformierteWerte = Fourier::hin(originalWerte);

    /*
    werte_ausgeben("Daten_original_TEST.txt", originalWerte);


    werte_ausgeben("Daten_original1_trafo.txt", transformierteWerte, -1);

    vector<CKomplex> transformierteWerteA = werte_einlesen("Daten_original1_trafo.txt");
    vector<CKomplex> zurueckTransformiertWerte = Fourier::zurueck(transformierteWerteA);
    werte_ausgeben("Daten_original1_Rtrafo.txt", zurueckTransformiertWerte);

    cout << "Maximale Abweichung bei epsilon " << -1 << " = " << abweichung(
        zurueckTransformiertWerte, originalWerte) << endl;

    */

    abweichungBestimmen("Daten_transformiert_default.txt", transformierteWerte, -1, dateinameOriginal);
    abweichungBestimmen("Daten_transformiert_0_001.txt", transformierteWerte, 0.001, dateinameOriginal);
    abweichungBestimmen("Daten_transformiert_0_01.txt", transformierteWerte, 0.01, dateinameOriginal);
    abweichungBestimmen("Daten_transformiert_0_1.txt", transformierteWerte, 0.1, dateinameOriginal);
    abweichungBestimmen("Daten_transformiert_1_0.txt", transformierteWerte, 1.0, dateinameOriginal);


    return 0;
}