/*
 * crypt.cpp
 *
 *
 */

#include "crypt.h"

#ifndef DEBUG
#define DEBUG
#endif

/* forward declaration of variables from crypt_args.h */
extern char *fname;
extern char *keyfname;
extern char *outfname;

struct rsakey_t
{
    unsigned long e, d, n;
    bool valid_rsa_tag;
};

/* parse pubkey xml file */
struct rsakey_t parse_key(FILE *file)
{
    struct rsakey_t key = { 0, 0, 0};
    key.valid_rsa_tag = false;

    /* used for line reading */
    size_t line_sz = 0;
    char *line = NULL;

    bool rsa_opening_tag = false;
    bool rsa_closing_tag = false;

    while (getline(&line, &line_sz, file) != -1)
    {
        if (strcmp(line, "<rsakey>\n") == 0)
            rsa_opening_tag = true;
        sscanf(line, "\t<dvalue>%lu</dvalue>\n", &key.d);
        sscanf(line, "\t<evalue>%lu</evalue>\n", &key.e);
        sscanf(line, "\t<nvalue>%lu</nvalue>\n", &key.n);
        if (strcmp(line, "</rsakey>\n") == 0)
            rsa_closing_tag = true;
    }

    if (rsa_opening_tag && rsa_closing_tag)
        key.valid_rsa_tag = true;

    if (line)
        free(line);

    return key;
}

int main(int argc, char **argv)
{
    if (crypt_args(argc, argv) == 0)
        cout << "read arguments successfully" << endl;

#ifdef DEBUG
    printf("debug: filename        = \"%s\"\n"
           "       key filename    = \"%s\"\n"
           "       result filename = \"%s\"\n",
           fname, keyfname, outfname);
#endif

    /* open file for reading and writing */
    FILE *fname_fl =  fopen(fname, "r");
    FILE *keyfname_fl = fopen(keyfname, "r");
    FILE *outfname_fl = fopen(outfname, "w");
    if (fname_fl == NULL) {
        fprintf(stderr, "fopen: \"%s\", %s\n", fname, strerror(errno));
        exit(EXIT_FAILURE);
    }
    if (keyfname_fl == NULL) {
        fprintf(stderr, "fopen: \"%s\", %s\n", keyfname, strerror(errno));
        exit(EXIT_FAILURE);
    }
    if (outfname_fl == NULL) {
        perror("fopen");
        exit(EXIT_FAILURE);
    }

    int mode = -1;
    struct rsakey_t key = parse_key(keyfname_fl);

    if (!key.valid_rsa_tag)
    {
        fprintf(stderr, "invalid key or invalid xml\n");
        exit(EXIT_FAILURE);
    }

    else if (key.d == 0 && key.e && key.n)
    {
        cout << "public key (" << key.e << ", " << key.n
             << ") detected, will perform encryption" << endl;
        mode = 0;
    }
    else if (key.e == 0 && key.d && key.n)
    {
        cout << "private key (" << key.d << ", " << key.n
             << ") detected, will perform decryption" << endl;
        mode = 1;
    }
    else
    {
        fprintf(stderr, "could not determine mode (encryption/decryption)\n");
        exit(EXIT_FAILURE);
    }

    if (mode == 0) /* encrypt */
    {
        char *line = NULL;
        size_t len = 0;
        ssize_t read;

        unsigned int readin = 0;
        BigUnsigned calc = 0;
        string writeout;
        const char *outstr = NULL;
        while ((read = getline(&line, &len, fname_fl)) != -1)
        {
            sscanf(line, "%u\n", &readin);
            printf("read in: \"%u\"", readin);
            calc = modexp(BigUnsigned(readin), key.e, key.n);
            writeout = bigIntegerToString(calc);
            cout << ", encrypted: " << writeout << endl;
            outstr = writeout.c_str();
            fprintf(outfname_fl, "%s\n", outstr);
        }

        free(line);
    }
    else /* decrypt */
    {
        char *line = NULL;
        size_t len = 0;
        ssize_t read;

        char readin[100];
        BigUnsigned calc = 0;
        BigInteger tmpbig = 0;
        string writeout;
        string tmpstr;
        const char *outstr = NULL;
        while ((read = getline(&line, &len, fname_fl)) != -1)
        {
            sscanf(line, "%s\n", readin);
            printf("read in: \"%s\"", readin);
            string tmpstr(readin);
            tmpbig = stringToBigInteger(tmpstr);
            calc = modexp(tmpbig, key.d, key.n);
            writeout = bigIntegerToString(calc);
            cout << ", decrypted: " << writeout << endl;
            outstr = writeout.c_str();
            fprintf(outfname_fl, "%s\n", outstr);
        }

        free(line);
    }

    fclose(fname_fl);
    fclose(keyfname_fl);
    fclose(outfname_fl);

    return 0;
}