#define _GNU_SOURCE

#include "shared.c"
#include "encryption.c"
#include "threadpool.c"

void test_encryption(void) {
    // TODO: Figure out if I care about this test existing or not. Currently, this has just been
    // copied from ecryption.c & slapped

    // Example code for creating a temp file, writing to it, then linking it back into the fs
    const char *dir = ".", *testmsg = "we do a little testing\n";
    char *path = NULL;

    int fd = maketmp(dir);
    if(fd < 0)
        error(1, errno, "Couldn't make temp file at %s", dir);

    if(write(fd, testmsg, strlen(testmsg)) < 0)
        error(1, errno, "write broke");

    asprintf(&path, "/proc/self/fd/%d", fd);
    linkat(AT_FDCWD, path, AT_FDCWD, "./test", AT_SYMLINK_FOLLOW);
    free(path);

    // Apparently, I don't have the CAP_DAC_READ_SEARCH capibility. Thanks for the solution, linux man pages

    if(close(fd) < 0)
        error(1, errno, "close broke");
    //*///

    //*// Example code for getting a password using genpassword
    checksodium();

    char *password = NULL;
    genpassword(&password, 20);
    printf("%s\n", (password != NULL) ? password : "Couldn't get a password");
    free(password);
    /*///

    //*/// Example code for generating a password, derriving a secret key from it, and storing things properly

    // Initialization
    checksodium();
    char *pass = NULL, hpass[crypto_pwhash_STRBYTES];

    if(genpassword(&pass, 20) < 0) {
        error(1, 0, "Could not generate password, quitting...");
        abort(); // Makes gcc happy. Not sure why gcc randomly decides that error() isn't a proper exit, but hey whatever
    }
    sodium_mlock(pass, strlen(pass) + 1);
    printf("Password:%s\n", pass);

    // Store the password
    if(crypto_pwhash_str(hpass, pass, strlen(pass) + 1, crypto_pwhash_OPSLIMIT_MODERATE, crypto_pwhash_MEMLIMIT_MODERATE) != 0)
        error(1, errno, "Couldn't generate password, quitting...");
        // Don't know if I want to use MODERATE or SENSITIVE for this. SENSITIVE takes a little bit on my laptop, which honestly
        // shouldn't be a problem, but it annoys me. MODERATE is quick and snappy, or at least quick enough that the slowdown is
        // barely noticable. I might do MODERATE for testing and SENSITIVE for release

    sodium_munlock(pass, strlen(pass) + 1);
    free(pass);

    printf("Hashed password: %s\n", hpass);

    // Check if the password from the user is correct
    char *uin = NULL; int size = -1;
    if((size = rwbuf(&uin, 1, STDIN_FILENO)) < 0)
        error(1, errno, "Could not read from stdin");
    sodium_mlock(uin, size);

    printf("Valid password? %s\n", (crypto_pwhash_str_verify(hpass, uin, size) == 0) ? "True" : "False");


    sodium_munlock(uin, strlen(uin) + 1);
    free(uin);

    return;
}

int main(void) {
    test_encryption();
    return 0;
}