/* Implementiert in dieser Datei und in otp.c die Teilaufgabe (a) */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>

#include "generate_otp.h"
#include "vorgabe.h"

extern int exitcode;    /* diesen Wert gibt die main()-Funktion als Exit-
                           Code zurueck (in otp.c definiert) */



/* praktische Fehlermeldungen fuer eure Fehlerbehandlungen */
#define ERRMSG_OTPENC_EXISTS "Die .otpenc-Datei existiert bereits!"
#define ERRMSG_OTPDEC_EXISTS "Die .otpdec-Datei existiert bereits!"
#define ERRMSG_OTPENC_CREATE "Kann die .otpenc-Datei nicht erzeugen!"
#define ERRMSG_OTPENC_WRITE "Die .otpenc-Datei laesst sich nicht schreiben!"
#define ERRMSG_OTPENC_CLOSE "Kann die .otpenc-Datei nicht schliessen!"
#define ERRMSG_OTPDEC_CREATE "Kann die .otpdec-Datei nicht erzeugen!"
#define ERRMSG_OTPDEC_WRITE "Die .otpdec-Datei laesst sich nicht schreiben!"
#define ERRMSG_OTPDEC_CLOSE "Kann die .otpdec-Datei nicht schliessen!"



void generate_otp(char *otpenc, char *otpdec, int otplen)
{
    /*
       Hier sollen zwei Schluessel-Dateien angelegt werden (die beide
       dieselben Zufallszahlen enthalten):
         - eine Datei, um genau einmal zu verschluesseln (und dann beliebig
           oft zu entschluesseln). "otpenc" enthaelt den (bereits vervoll-
           staendigten) Dateinamen.
         - eine weitere Datei, um beliebig oft zu entschluesseln, aber
           niemals zu verschluesseln. "otpdec" enthaelt den Dateinamen.

       Wichtig: denkt auch immer an die Fehlerbehandlung.
    */

    FILE *otpenc_file = NULL, *otpdec_file = NULL;
    char buf[BUF_SIZE];


    struct stat fileinfo = {0};
    int val1;
    int val2;
    size_t val3;
    size_t val4;
    int mnr1 = bigendian(MAGIC_OTPENC_NEW);
    int mnr2 = bigendian(MAGIC_OTPDEC);
    int i = 0;
    int count = 0;
    size_t fill;


    /* Makro zur Erleichterung der Fehlerbehandlung */
#define cancel(failedcall, errmsg) {        \
        perror(failedcall);         \
        fprintf(stderr, "%s\n", errmsg);    \
                                                \
        /* Schliesst beide Dateien, falls sie   \
           erfolgreich geoeffnet wurden         \
           (fclose(3)). Man sollte eigentlich   \
           auch die unfertigen Dateien          \
           loeschen, aber setzt remove(3) sehr  \
           umsichtig ein! */                    \
/* HIER MUESST IHR EUREN CODE EINFUEGEN! */     \
    if (otpenc_file != NULL) {              \
        fclose(otpenc_file);        \
        remove(otpenc);         \
    }                   \
    if (otpdec_file != NULL) {      \
        fclose(otpdec_file);        \
        remove(otpdec);         \
    }                   \
        exitcode = EXIT_FAILURE;        \
        return;                 \
    }  /* cancel() */


    /* Wenn ihr das parametrisierte Makro cancel() vervollstaendigt, dann
       koennt ihr euch jede Menge Tipparbeit bei der Fehlerbehandlung
       von Systemaufrufen ersparen. Ruft einfach im Fehlerfall cancel() mit
       geeigneten Parametern auf:

           if (firgendwas() == ffehler)
               cancel("firgendwas", ERRMSG_FEHLGESCHLAGEN);

       Andernfalls muesst ihr bei jedem Aufruf viel Code fuer die
       Fehlermeldung und zum Schliessen (und vorsichtigen Loeschen) neu
       schreiben!
    */


    /* (passt diesen printf() geringfuegig an) */
    printf("Es werden zwei Dateien erzeugt, die dasselbe One-Time Pad "
           "(also den\n"
           "Schluessel) enthalten.\n\n"
           "zum Verschluesseln: %s\n"
           "zum Entschluesseln: %s\n"
           "Schluessellaenge: %d Bytes\n\n",
           otpenc, otpdec, otplen);


    /* HINWEIS: Ihr habt schon ein paar Variablen vorgegeben, die ihr
       verwenden koennt:
       otpenc und otpdec mit den gegebenen Dateinamen,
       otplen mit der gewuenschten Laenge des One-Time-Pads,
       otpenc_file und otpdec_file fuer die geoeffneten Dateien,
       und buf[BUF_SIZE] fuer den Puffer. */


    /* Stellt zuerst mit stat(2) sicher, dass keine der beiden Dateien
       bereits existiert (stat() soll fehlschlagen). Hier braucht ihr
       cancel() noch nicht. */
/* HIER MUESST IHR EUREN CODE EINFUEGEN! */

    /* Das die Dateien, falls sie schon existieren, gelöscht werden, sollte uns nur das Testen vereinfachen, also bitte nicht
    dran stören, uns ist bewusst, dass das nicht unbedingt so schön ist ;-) */


    val1 = stat(otpenc, &fileinfo);
    if (val1 != -1) {
        perror("Datei zum kodieren existiert bereits und wird nun gelöscht.");
        remove(otpenc);
    }

    val2 = stat(otpdec, &fileinfo);
    if (val2 != -1) {
        perror("Datei zum dekodieren existiert bereits und wird nun gelöscht.");
        remove(otpdec);
    }

    /* Frage: Wieso sorgt "perror("Datei %s existiert bereits.", otpdec);" für den fehler "to many arguments"?
    Normalerweise müsste das doch richtig interpretiert werden?? */


    /* Erzeugt die beiden Dateien durch oeffnen mit fopen(3). Achtet auf
       die Fehlerbehandlung und benutzt ab hier am besten cancel(). */
/* HIER MUESST IHR EUREN CODE EINFUEGEN! */


    otpenc_file = fopen(otpenc, "w+");
    if (otpenc_file == NULL) {
        cancel("fopen", ERRMSG_OTPENC_CREATE);
    }

    otpdec_file = fopen(otpdec, "w+");
    if (otpdec_file == NULL) {
        cancel("fopen", ERRMSG_OTPDEC_CREATE);
    }


    /* Schreibt die passenden magic numbers (MAGIC_OTPENC_NEW und
       MAGIC_OTPDEC) mit fwrite(3). */
/* HIER MUESST IHR EUREN CODE EINFUEGEN! */

    val3 = fwrite(&mnr1, sizeof(int), 1, otpenc_file);
    if (val3 != 1) {
        cancel("fwrite", ERRMSG_OTPENC_WRITE);
    }
    val4 = fwrite(&mnr2, sizeof(int), 1, otpdec_file);
    if(val4 != 1) {
        cancel("fwrite", ERRMSG_OTPDEC_WRITE);
    }


    /* Schreibt das eigentliche One-Time Pad (den Schluessel) der Laenge
       "otplen" in beide Dateien. Benutzt dazu die vorgegebene Funktion
       pseudorandom() und fwrite(3). Da der Schluessel sehr lang sein kann,
       muesst ihr ihn in einer Schleife blockweise (BUF_SIZE) schreiben. */
    while (i < otplen) {  /* Ersetzt die 0 durch eine sinnvolle Bedingung. */

/* HIER MUESST IHR EUREN CODE EINFUEGEN! */
    if (otplen-(count*BUF_SIZE) < BUF_SIZE) {
        fill = (size_t)(otplen-(count*BUF_SIZE));
    }
    else {
        fill = BUF_SIZE;
    }
    pseudorandom(&buf, fill);
    fwrite(&buf, sizeof(char), fill, otpenc_file);
    if (ferror(otpenc_file)) {
        cancel("fwrite", ERRMSG_OTPENC_WRITE);
    }
    fwrite(&buf, sizeof(char), fill, otpdec_file);
    if (ferror(otpdec_file)) {
        cancel("fwrite", ERRMSG_OTPDEC_WRITE);
    }
    i+= BUF_SIZE;
    count++;
    }

    /* Schliesst die Dateien wieder mit fclose(3). */
/* HIER MUESST IHR EUREN CODE EINFUEGEN! */
    val1 = fclose(otpenc_file);
    if (val1 != 0)
        cancel("fclose", ERRMSG_OTPENC_CLOSE);
    val2 = fclose(otpdec_file);
    if (val2 != 0)
        cancel("fclose", ERRMSG_OTPDEC_CLOSE);

    /* Gebt abschliessend eine Erfolgsmeldung aus. */
/* HIER MUESST IHR EUREN CODE EINFUEGEN! */

    printf("Beide Schlüsseldateien wurdern erfolgreich erstellt und befüllt.\n\n");

#undef cancel
}