#include "StateUtilities.h"

// local constants
const int NAME_BLOCK_SIZE = 16;
const int POPULATION_BLOCK_SIZE = 12;
const int GROWTH_BLOCK_SIZE = 10;
// missing constants from assignment file
const int ITEM_BLOCK_SIZE = 6;
const int MAJORITY_BLOCK_SIZE = 10;

// functions

/*
Name: addElementFromData
Process: adds all individual data values to StateDataType array 
         if capacity has not been exceeded,
         returns true upon success, false otherwise
Function input/parameters: data array (StateDataType *), 
                           size (int), capacity (int),
                           state name (const char *),
                           state population (int),
                           state growth (double),
                           state political majority (char)
Function output/parameters: updated data array (StateDataType *),
                            updated size (int *)
Function output/returned: Boolean result of operation as specified
Device input/---: none
Device output/---: none
Dependencies: as needed, including strcpy
*/
bool addElementFromData( StateDataType *stateArr, int *size, int capacity,
                      const char *stateName, int statePop, 
                                   double stateGrowth, char politicalMajority )
{
    // check to see if the size will go over the capacity
    // put in the data to the array
    // array[*size] = parameter
    // string is a little different.
    // use strcpy(array[*size].name, stateName)
    // increment size (*size = *size + 1)
    // return true
    // otherwise, return false.
    return false;
}

/*
Name: addElementFromElement
Process: adds data from element to StateDataType array,
         uses supporting function 
Function input/parameters: data array (StateDataType *), 
                           size and capacity (int),
                           source element (const StateDataType)
Function output/parameters: updated data array (StateDataType *),
                            updated size (int *)
Function output/returned: Boolean result of operation as specified
Device input/---: none
Device output/---: none
Dependencies: addElementFromData - function uses one code statement
*/
bool addElementFromElement( StateDataType *stateArr, int *size, int capacity,
                                                    const StateDataType state )
{
    return addElementFromData(stateArr, size, capacity, state.name,
                                state.population, state.growth, state.majority);
}

/*
Name: clearStateArray
Process: deallocates dynamically allocated array from memory
Function input/parameters: data array (StateDataType *)
Function output/parameters: none
Function output/returned: NULL
Device input/---: none
Device output/---: none
Dependencies: as needed, including free
*/
StateDataType *clearStateArray( StateDataType *array )
{
    // use free to deallocate the array
    return NULL;
}

/*
Name: copyArray
Process: copies state data elements from one array to another
Function input/parameters: source array (const StateDataType *), size (int)
Function output/parameters: pointer to destination array (StateDataType *)
Function output/returned: none
Device input/---: none
Device output/---: none
Dependencies: as needed
*/
void copyArray( StateDataType *dest, const StateDataType *src, int srcSize )
{
    // use a for loop to iterate through source array (start at zero, go to srcSize)
    // copy each element from the array to the new array.
    // uses deepCopy to do this.
    // no return, void
}

/* COMPLETE
Name: createStateArray
Process: dynamically allocates array memory
Function input/parameters: initial capacity (int)
Function output/parameters: none
Function output/returned: pointer to newly created array (StateDataType *)
Device input/---: none
Device output/---: none
Dependencies: as needed, including function malloc and keyword sizeof
*/
StateDataType *createStateArray( int initialCapacity )
{
    // define variables (integer, StateDataType)
    // use malloc to dynamically allocate the array, 
       // use the initialCapacity as the size to multiply by.
    // return the pointer to the array.
    return NULL;
}

/*
Name: deepCopy
Process: copies all individual values from StateDataType source
         to StateDataType destination
Function input/parameters: source element (const StateDataType)
Function output/parameters: pointer to destination value (StateDataType *)
Function output/returned: none
Device input/---: none
Device output/---: none
Dependencies: as needed, including strcpy
*/
void deepCopy( StateDataType *dest, const StateDataType src )
{
    // *dest.population = src.population (for each piece)
    // strcpy for the string
    // strcpy(*dest.name, src.name)
    // no return, void
}

/*
Name: displayData
Process: displays element data in array as table if array is not empty,
         otherwise displays "Data not found - Display aborted",
         allows for subtitle to be added to "Display Data - "
Function input/parameters: state data array (const StateDataType *),
                           size (int), subtitle (const char *)
Function output/parameters: none
Function output/returned: none
Device input/---: none
Device output/monitor: data displayed as specified
Dependencies: as needed
*/
void displayData( const StateDataType *array, int size, const char *subTitle )
{
    // no return, void
}

/*
Name: findStateByName
Process: finds element value in array by state name if it exists in the array,
         saves data in return parameter and returns true,
         otherwise sets data in return parameter to empty and returns false
Function input/parameters: state data array (const StateDataType *),
                           size (int), search value (const StateDataType)
Function output/parameters: value if found as return parameter, 
                                 otherwise, return parameter set to empty 
                                                               (StateDataType *)
Function output/returned: Boolean result of operation
Device input/---: none
Device output/---: none
Dependencies: as needed
*/
bool findStateByName( StateDataType *foundElement, 
        const StateDataType *array, int size, const StateDataType searchValue )
{
    //
    return NULL;
}

/*
Name: removeStateByName
Process: searches for element, if found, sets data into return parameter,
         shifts all remaining data down, and returns true,
         otherwise sets data in return parameter to empty and returns false
Function input/parameters: state data array (StateDataType *),
                           size (int), search value (const StateDataType)
Function output/parameters: updated state data array (StateDataType *),
                            value if found and removed, 
                            otherwise, value set to empty (StateDataType *),
                            updated size (int *)
Function output/returned: Boolean result of operation as specified
Device input/---: none
Device output/---: none
Dependencies: as needed
*/
bool removeStateByName( StateDataType *removedElement, 
               StateDataType *array, int *size, const StateDataType searchVal )
{
    //
    return NULL;
}

/*
Name: runBubbleSortByName
Process: sorts state data by name using bubble sort algorithm
Function input/parameters: state data array (StateDataType *), size (int)
Function output/parameters: updated state data array (StateDataType *)
Function output/returned: none
Device input/---: none
Device output/---: none
Dependencies: as needed
*/
void runBubbleSortByName( StateDataType *array, int size )
{
    // no return, void
    // bubble sort the data by name of state
}

/*
Name: runInsertionSortByPopulation
Process: sorts state data by population using insertion sort algorithm
Function input/parameters: state data array (StateDataType *), size (int)
Function output/parameters: updated state data array (StateDataType *)
Function output/returned: none
Device input/---: none
Device output/---: none
Dependencies: as needed, swap may not be used
*/
void runInsertionSortByPopulation( StateDataType *array, int size )
{
    // no return, void
}

/*
Name: runSelectionSortByGrowth
Process: sorts state data by growth using selection sort algorithm
Function input/parameters: state data array (StateDataType *), size (int)
Function output/parameters: updated state data array (StateDataType *)
Function output/returned: none
Device input/---: none
Device output/---: none
Dependencies: as needed
*/
void runSelectionSortByGrowth( StateDataType *array, int size )
{
    // no return, void
}

/*
Name: setEmptyElementData
Process: sets state data type to empty or default values,
         name to empty string, population and growth to zero,
         and majority to 'x'
Function input/parameters: none
Function output/parameters: state data value (StateDataType *)
Function output/returned: none
Device input/---: none
Device output/---: none
Dependencies: none
*/
void setEmptyElementData( StateDataType *element )
{
    // no return, void
}

/*
Name: showTitle
Process: displays program title with thick underline,
         "Data Management with N-Squared Sorting"
Function input/parameters: none
Function output/parameters: none
Function output/returned: none
Device input/---: none
Device output/monitor: displays title as specified
Dependencies: as needed
*/
void showTitle()
{
    // no return, void
}

/*
Name: swapElements
Process: swaps state data elements within an array
Function input/parameters: given array (StateDataType *),
                           left and right indices to be swapped (int)
Function output/parameters: updated array with swapped values (StateDataType *)
Function output/returned: none
Device input/---: none
Device output/---: none
Dependencies: as needed
*/
void swapElements( StateDataType *array, int leftIndex, int rightIndex )
{
    // create StateDataType temp to store swapped element
    // use deepCopy to copy out swapped element
    // use deepCopy to move the other element,
    // use deepCopy to copy the temp element to the other element
    // updated the array
    // no return, void
}

/*
Name: uploadStateData
Process: uploads data from given file to state data array,
         ignores first (title) line in .csv file,
         then captures comma-delimited state name, population, growth, 
         and political majority data on each row,
         returns number of items found;
         stops uploading process if array is full
Function input/parameters: capacity (int) and file name (const char *)
Function output/parameters: updated array with uploaded values (StateDataType *)
Function output/returned: number of items uploaded (int)
Device input/HD: data uploaded from text file as specified
Device output/---: none
Dependencies: as needed
*/
int uploadStateData( StateDataType *StateDataArray,
                                           int capacity, const char *fileName )
{
    //
    return 0;
}