/**
 * TODO: this
 */

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


/* This function will read a line of text from the given file, returning it as a string stored in a dynamically allocated array. It will stop reading when it encounters a newline or the end-of-file. If it can't read anything before reaching the end-of-file, it will return NULL.

Internally, this funciton will use a resizable array. It will allocate a small array to hold the line of text. As it reads characters, it will grow the array as necessary to be able to hold the whole line. */
char *readLine( FILE *fp )
{
    char c = 0;

    int capacity = 5;
    char *line = malloc( capacity );

    //null terminating string
    for ( int i = 0; i < capacity; i++ ) {
        line[i] = '\0';
    }
    int index = 0;

    while ( fscanf( fp, "%c", &c ) == 1 ) {
        if ( c == EOF ) {
            return NULL;
        }
        if ( c == '\n' ) {
            return line + '\0';
        } else {
            line[index] = c;
            index++;
            if ( index == capacity ) {
                capacity *= 2;
                line = (char *)realloc(line, capacity);

                //getting those null terminators in
                for ( int i = index; i < capacity; i++ ) {
                    line[i] = '\0';
                }
            }
        }
    }

    return NULL;

}

/* This funciton will read the text of an entire file, storing it as a dynamically allocated array of pointers to dynamically allocated strings. The function will open the file with the given name, read all its lines, return a pointer to the array of char pointers holding the contents of the file's lines (thus the pointer-to-pointer-to-char return type) and fill in the pass-by-reference count parameter with the number of lines read from the file.

Internally, this function will use a resizable array of char pointers to store the contents of the file. As it reads additional lines from the file, it will need to be able to resize its array of pointers to be able to keep pointer to all the lines. It can use the readLine() function to read the text of each line of the file.*/
char **readLines( const char *fileName, int *count )
{

    FILE *dictionaryFile = fopen( fileName, "r" );
    char *c = readLine( dictionaryFile );

    int capacity = 5;
    char **lines = malloc( capacity * sizeof(char *) );
    int index = 0;

    while ( c != NULL || c[0] != EOF || !isspace( c[0] ) ) {
        c[ strlen( c ) ] = '\0';
        lines[index] = c;
        index++;
        ( *count )++;
        if ( index == capacity ) {
            capacity *= 2;
            lines = (char **)realloc(lines, capacity * sizeof(char *));
        }
        c = readLine( dictionaryFile );
        if ( c == NULL ) {
            break;
        }
        if ( c[0] == '\n' ) {
            return NULL;
        }
    }
    fclose( dictionaryFile );
    return lines;
}


/* This function will free the memory for the type of two-dimensional array returned from readLines(). Its parameters are an array of pointers to strings and a count of the number of strings in the array (just like what readLines gives you). It will need to free the memory for each string, then free the array of pointers. */
void freeLines( char **lines, int count )
{
    for ( int i = count; i >= 0; i-- ) {
        free( lines[i] );
    }
    free( lines );
}