#ifndef STATE_UTILITIES_H
#define STATE_UTILITIES_H

// header files
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "Console_IO_Utility.h"
#include "File_Input_Utility.h"
#include "StandardConstants.h"

// global constants

// data structure
typedef struct StateDataStruct
   {
    char name[ STD_STR_LEN ];

    int population;

    double growth;

    char majority;
   } StateDataType;

// Prototypes

/*
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 );

/*
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 );

/*
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 );

/*
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 );

/*
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 );

/*
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 );

/*
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 );

/*
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 );

/*
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 );

/*
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 );

/*
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 );

/*
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 );

/*
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 );

/*
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();

/*
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 );

/*
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 );

#endif   // STATE_UTILITIES_H