/* voronoi.c
*
* Created by Rory Healy (healyr@student.unimelb.edu.au)
* 12th August 2021
* 
*/

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

#define OPEN_FILE_ERROR "Error: Unable to open file %s\n"
#define NUM_FILE_ERROR "Error: Incorrect number of inputs (3 required).\n"
#define MALLOC_ERROR "Error: Cannot allocate memory.\n"

#define ARGC_CORRECT_LEN 4
#define NUM_CSV_FIELDS 6
#define MAX_FIELD_LEN 128
#define MAX_CSV_ENTRY_LEN 512

int main(int argc, char **argv) {
    /* Input and output files */
    FILE *dataset = NULL, *polygonData = NULL, *output = NULL;
    checkInputArgs(argc, argv, &dataset, &polygonData, &output);

    /* Stores information about the watchtowers given in dataset file */
    watchtower_t *watchtowers = (watchtower_t *) malloc(sizeof(watchtower_t));
    if (watchtowers == NULL) {
        fputs(MALLOC_ERROR, stderr);
        exit(EXIT_FAILURE);
    }

    readWatchtowers(watchtowers, dataset);

    /* Cleaning up data */
    free(watchtowers);
    fclose(dataset);
    fclose(polygonData);
    fclose(output);
    return 0;
}

/* Checks the validity of the command line input arguments */
void checkInputArgs(int argc, char **argv, FILE **datasetFile, \
    FILE **polygonFile, FILE **outputFile) {
    if (argc != ARGC_CORRECT_LEN) {
        fputs(NUM_FILE_ERROR, stderr);
        exit(EXIT_FAILURE);
    }

    *datasetFile = fopen(argv[1], "r");
    if (*datasetFile == NULL) {
        fprintf(stderr, OPEN_FILE_ERROR, argv[1]);
        exit(EXIT_FAILURE);
    }
    
    *polygonFile = fopen(argv[2], "r");
    if (*polygonFile == NULL) {
        fprintf(stderr, OPEN_FILE_ERROR, argv[2]);
        exit(EXIT_FAILURE);
    }

    *outputFile = fopen(argv[3], "w");
    if (*outputFile == NULL) {
        fprintf(stderr, OPEN_FILE_ERROR, argv[3]);
        exit(EXIT_FAILURE);
    }
}

/* Reads the CSV file and stores the information in the watchtowers array */
void readWatchtowers(watchtower_t *watchtowers, FILE* datasetFile) {
    /* Maximum length of a single CSV line */
    size_t lineBufferSize = MAX_CSV_ENTRY_LEN;

    /* Stores the current line from the CSV */
    char *lineBuffer = (char *) malloc(lineBufferSize * sizeof(char));
    if (lineBuffer == NULL) {
        fprintf(stderr, MALLOC_ERROR);
        exit(EXIT_FAILURE);
    }

    int numWatchtowers = 1;

    /* Discard the header line, then read the rest of the CSV */
    getline(&lineBuffer, &lineBufferSize, datasetFile);
    while (getline(&lineBuffer, &lineBufferSize, datasetFile) > 0) {
        /* The current tower being filled in with information */
        watchtower_t *currTower = (watchtower_t *) malloc(sizeof(watchtower_t));

        /* Stores the current CSV field for the current line */
        char *token = strtok(lineBuffer, ",");
        size_t tokenLength;

        /* Read the line in to currTower */
        for (int i = 0; i < NUM_CSV_FIELDS; i++) {
            tokenLength = strlen(token);
            switch(i) {
                /* Case 0, 1, and 3 deal with strings in the CSV
                 * Case 2 deals with an integer
                 * Case 4 and 5 deal with doubles
                 * Each case is handled seperately to fill in the
                 * watchtower with no space wasted.
                 */
                case 0:
                    currTower->id = (char *) malloc(sizeof(char) * \
                        tokenLength + 1);
                    strcpy(currTower->id, token);
                    currTower->id[tokenLength] = '\0';
                    break;
                case 1:
                    currTower->postcode = (char *) malloc(sizeof(char) * \
                        tokenLength + 1);
                    strcpy(currTower->postcode, token);
                    currTower->postcode[tokenLength] = '\0';
                    break;
                case 3:
                    currTower->manager = (char *) malloc(sizeof(char) * \
                        tokenLength + 1);
                    strcpy(currTower->manager, token);
                    currTower->manager[tokenLength] = '\0';
                    break;
                case 2:
                    currTower->population = strtol(token, NULL, 10);
                    break;
                case 4:
                    currTower->x = strtod(token, NULL);
                    break;
                case 5:
                    currTower->y = strtod(token, NULL);
                    break;
            }
            token = strtok(NULL, ",");
        }
        // printf("ID: %s\nPostcode: %s\nManager: %s\n", \
        //     currTower->id, currTower->postcode, currTower->manager);
        // printf("Population: %d\nx: %f\ny: %f\n", \
        //     currTower->population, currTower->x, currTower->y);

        /* Add currTower to the watchtowers array */
        

        /* Clean up currTower before reading next CSV line */
        free(currTower->id);
        free(currTower->manager);
        free(currTower->postcode);
        free(currTower);
    }
    free(lineBuffer);
}