/*
* This file defines "vfc_probes", a hashtable-based structure which can be used
* to place "probes" in a code and store the different values of test variables.
* These test results can then be exported in a CSV file, and used to generate a
* Verificarlo test report.
*/


#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#include "vfc_hashmap.h"

#define VAR_NAME(var) #var  // Simply returns the name of var into a string


/*
* A probe containing a double value as well as its key, which is needed when
* dumping the probes
*/

struct vfc_probe_node {
    char * key;
    double value;
};

typedef struct vfc_probe_node vfc_probe_node;



/*
* The probes structure. It simply acts as a wrapper for a Verificarlo hashmap.
*/

struct vfc_probes {
    vfc_hashmap_t map;
};

typedef struct vfc_probes vfc_probes;


/*
* Initialize an empty vfc_probes instance
*/

vfc_probes vfc_init_probes() {
    vfc_probes probes;
    probes.map = vfc_hashmap_create();

    return probes;
}



/*
* Free all probes
*/

void vfc_free_probes(vfc_probes * probes) {

    // Before freeing the map, iterate manually over all items to free the keys
    vfc_probe_node * probe = NULL;
    for(int i = 0; i < probes->map->capacity; i++) {
        probe = (vfc_probe_node*) get_value_at(probes->map->items, i);
        if(probe != NULL) {
            if(probe->key != NULL) {
                free(probe->key);
            }
        }
    }

    vfc_hashmap_free(probes->map);
}



/*
* Helper function to generate the key from test and variable name
*/

char * gen_probe_key(char * testName, char * varName) {
    char * key = (char *) malloc(strlen(testName) + strlen(varName) + 2);
    strcpy(key, testName);
    strcat(key, ",");
    strcat(key, varName);

    return key;
}



/*
* Helper function to detect forbidden character ',' in the keys
*/

void validate_probe_key(char * str) {
    unsigned int len = strlen(str);

    for(unsigned int i=0; i<len; i++) {
        if(str[i] == ',') {
            fprintf(
                stderr,
                "Error [verificarlo]: One of your probes has a ',' in its test \
                or variable name (\"%s\"), which is forbidden\n",
                str
            );
            exit(1);
        }
    }
}



/*
* Add a new probe. If an issue with the key is detected (forbidden characters or
* a duplicate key), an error will be thrown.
*/

int vfc_put_probe(
    vfc_probes * probes,
    char * testName, char * varName,
    double val
) {

    if(probes == NULL) {
        return 1;
    }

    // Make sure testName and varName don't contain any ',', which would
    // interfere with the key/CSV encoding
    validate_probe_key(testName);
    validate_probe_key(varName);

    // Get the key, which is : testName + "," + varName
    char * key = gen_probe_key(testName, varName);

    // Look for a duplicate key
    vfc_probe_node * oldProbe = (vfc_probe_node*) vfc_hashmap_get(
        probes->map, vfc_hashmap_str_function(key)
    );

    if(oldProbe != NULL) {
        if(strcmp(key, oldProbe->key) == 0) {
            fprintf(
                stderr,
                "Error [verificarlo]: you have a duplicate error with one of \
                your probes (\"%s\"). Please make sure to use different names.\n",
                key
            );
            exit(1);
        }
    }

    // Insert the element in the hashmap
    vfc_probe_node * newProbe = (vfc_probe_node*) malloc(sizeof(vfc_probe_node));
    newProbe->key = key;
    newProbe->value = val;

    vfc_hashmap_insert(
        probes->map, vfc_hashmap_str_function(key), newProbe
    );

    return 0;
}



/*
* Remove (free) an element from the hash table
*/

int vfc_remove_probe(vfc_probes * probes, char * testName, char * varName) {

    if(probes == NULL) {
        return 1;
    }

    // Get the key, which is : testName + "," + varName
    char * key = gen_probe_key(testName, varName);

    vfc_hashmap_remove(probes->map, vfc_hashmap_str_function(key));

    return 0;
}



/*
* Return the number of probes stored in the hashmap
*/

unsigned int vfc_num_probes(vfc_probes * probes) {
    return vfc_hashmap_num_items(probes->map);
}



/*
* Dump probes in a .csv file (the double values are converted to hex), then
* free it.
*/

int vfc_dump_probes(vfc_probes * probes) {

    if(probes == NULL) {
        return 1;
    }

    // Get export path from the VFC_PROBES_OUTPUT env variable
    char* exportPath = getenv("VFC_PROBES_OUTPUT");
    if(!exportPath) {
        printf(
            "Warning [verificarlo]: VFC_PROBES_OUTPUT is not set, probes will \
            not be dumped\n"
        );
        vfc_free_probes(probes);
        return 0;
    }

    FILE * fp = fopen(exportPath, "w");

    if(fp == NULL) {
        fprintf(
            stderr,
            "Error [verificarlo]: impossible to open the CSV file to save your \
            probes (\"%s\")\n",
            exportPath
        );
        exit(1);
    }

    // First line gives the column names
    fprintf(fp, "test,variable,value\n");

    // Iterate over all table elements
    vfc_probe_node * probe = NULL;
    for(int i = 0; i < probes->map->capacity; i++) {
        probe = (vfc_probe_node*) get_value_at(probes->map->items, i);
        if(probe != NULL) {
            fprintf(
                fp, "%s,%a\n",
                probe->key,
                probe->value
            );
        }
    }

    fclose(fp);

    vfc_free_probes(probes);

    return 0;
}