//********************************************************
//
// Assignment 9 - Linked Lists
//
// Name: <Damian Uhomoibhi>
//
// Class: C Programming, <Fall 2024>
//
// Date: <17 November 2024>
//
// Description: Program which determines overtime and 
// gross pay for a set of employees with outputs sent 
// to standard output (the screen).
//
// This assignment also adds the employee name, their tax state,
// and calculates the state tax, federal tax, and net pay.   It
// also calculates totals, averages, minimum, and maximum values.
//
// Array and Structure references have all been replaced with
// pointer references to speed up the processing of this code.
// A linked list has been created and deployed to dynamically
// allocate and process employees as needed.
//
// Call by Reference design (using pointers)
//
//********************************************************

// necessary header files
#include <stdio.h>
#include <string.h>
#include <ctype.h>   // for char functions
#include <stdlib.h>  // for malloc

// define constants
#define STD_HOURS 40.0
#define OT_RATE 1.5
#define MA_TAX_RATE 0.05
#define NH_TAX_RATE 0.0
#define VT_TAX_RATE 0.06
#define CA_TAX_RATE 0.07
#define DEFAULT_TAX_RATE 0.08
#define NAME_SIZE 20
#define TAX_STATE_SIZE 3
#define FED_TAX_RATE 0.25
#define FIRST_NAME_SIZE 10
#define LAST_NAME_SIZE 10

// Define a global structure type to store an employee name
struct name
{
    char firstName[FIRST_NAME_SIZE];
    char lastName [LAST_NAME_SIZE];
};

// Define a global structure type to pass employee data between functions
struct employee
{
    struct name empName;
    char taxState [TAX_STATE_SIZE];
    long int clockNumber;
    float wageRate;
    float hours;
    float overtimeHrs;
    float grossPay;
    float stateTax;
    float fedTax;
    float netPay;
    struct employee * next;
};

// this structure type defines the totals of all floating point items
struct totals
{
    float total_wageRate;
    float total_hours;
    float total_overtimeHrs;
    float total_grossPay;
    float total_stateTax;
    float total_fedTax;
    float total_netPay;
};

// this structure type defines the min and max values of all floating
// point items so they can be displayed in our final report
struct min_max
{
    float min_wageRate;
    float min_hours;
    float min_overtimeHrs;
    float min_grossPay;
    float min_stateTax;
    float min_fedTax;
    float min_netPay;
    float max_wageRate;
    float max_hours;
    float max_overtimeHrs;
    float max_grossPay;
    float max_stateTax;
    float max_fedTax;
    float max_netPay;
};

// define prototypes here for each function except main
struct employee * getEmpData (void);
int isEmployeeSize (struct employee * head_ptr);
void calcOvertimeHrs (struct employee * head_ptr);
void calcGrossPay (struct employee * head_ptr);
void printHeader (void);
void printEmp (struct employee * head_ptr);
void calcStateTax (struct employee * head_ptr);
void calcFedTax (struct employee * head_ptr);
void calcNetPay (struct employee * head_ptr);
void calcEmployeeTotals (struct employee * head_ptr,
                         struct totals * emp_totals_ptr);
void calcEmployeeMinMax (struct employee * head_ptr,
                         struct min_max * emp_minMax_ptr);
void printEmpStatistics (struct totals * emp_totals_ptr,
                         struct min_max * emp_minMax_ptr,
                         int theSize);

int main ()
{

    // set up head pointer in the main function to point to the
    // start of the dynamically allocated linked list nodes
    struct employee * head_ptr; // always points to first linked list node

    int theSize; // number of employees processed

    // set up structure to store totals and initialize all to zero
    struct totals employeeTotals  = {0,0,0,0,0,0,0};

    // pointer to the employeeTotals structure
    struct totals * emp_totals_ptr = &employeeTotals;

    // set up structure to store min and max values and initialize all to zero
    struct min_max employeeMinMax = {0,0,0,0,0,0,0,0,0,0,0,0,0,0};

    // pointer to the employeeMinMax structure
    struct min_max * emp_minMax_ptr = &employeeMinMax;

    // Read the employee input and dynamically allocate the linked list
    head_ptr = getEmpData ();

    // determine how many employees are in our linked list
    theSize = isEmployeeSize (head_ptr);

    // Skip all the function calls if there was no employee information
    if (theSize <= 0)
    {
        // print a user friendly message and skip the rest of the processing
        printf("\n\n**** There was no employee input to process ***\n");
    }
    else // there are employees to be processed
    {

        // Perform calculations and print out information as needed

        // Calculate the overtime hours
        calcOvertimeHrs (head_ptr);

        // Calculate the weekly gross pay
        calcGrossPay (head_ptr);

        // Calculate the state tax
        calcStateTax (head_ptr);

        // Calculate the federal tax
        calcFedTax (head_ptr);

        // Calculate the net pay after taxes
        calcNetPay (head_ptr);

        // Keep a running sum of the employee totals
        calcEmployeeTotals (head_ptr,
                            &employeeTotals);

        // Keep a running update of the employee minimum and maximum values
        calcEmployeeMinMax (head_ptr,
                            &employeeMinMax);

        // Print the column headers
        printHeader();

        // print out final information on each employee
        printEmp (head_ptr);

        // print the totals and averages for all float items
        printEmpStatistics (&employeeTotals,
                            &employeeMinMax,
                            theSize);
    }

    // indicate that the program completed all processing
    printf ("\n\n *** End of Program *** \n");

    return (0); // success

} // main

//**************************************************************
// Function: getEmpData
//
// Purpose: Obtains input from user: employee name (first and last),
//          tax state, clock number, hourly wage, and hours worked
//          in a given week.
//
//          Information is stored in a dynamically created linked
//          list for all employees.
//
// Parameters: void
//
// Returns:
//
//    head_ptr - a pointer to the beginning of the dynamically
//               created linked list that contains the initial
//               input for each employee.
//
//**************************************************************

struct employee * getEmpData (void)
{

    char   answer[80];    // user prompt response
    int    more_data = 1; // a flag to indicate if another employee
                          // needs to be processed
    char   value;         // the first char of the user prompt response

    struct employee *current_ptr,   // pointer to current node
                    *head_ptr;      // always points to first node

    // Set up storage for first node
    head_ptr = (struct employee *) malloc (sizeof(struct employee));
    current_ptr = head_ptr;

    // process while there is still input
    while (more_data)
    {

        // read in employee first and last name
        printf ("\nEnter employee first name: ");
        scanf ("%s", current_ptr->empName.firstName);
        printf ("\nEnter employee last name: ");
        scanf ("%s", current_ptr->empName.lastName);

        // read in employee tax state
        printf ("\nEnter employee two character tax state: ");
        scanf ("%s", current_ptr->taxState);

        // read in employee clock number
        printf("\nEnter employee clock number: ");
        scanf("%li", & current_ptr -> clockNumber);

        // read in employee wage rate
        printf("\nEnter employee hourly wage: ");
        scanf("%f", & current_ptr -> wageRate);

        // read in employee hours worked
        printf("\nEnter hours worked this week: ");
        scanf("%f", & current_ptr -> hours);

        // ask user if they would like to add another employee
        printf("\nWould you like to add another employee? (y/n): ");
        scanf("%s", answer);

        // check first character for a 'Y' for yes
        if ((value = toupper(answer[0])) != 'Y')
        {
           // no more employees to process
           current_ptr->next = (struct employee *) NULL;
           more_data = 0;
        }
        else // Yes, another employee
        {
           // set the next pointer of the current node to point to the new node
           current_ptr->next = (struct employee *) malloc (sizeof(struct employee));
           // move the current node pointer to the new node
           current_ptr = current_ptr->next;
        }

    } // while

    return(head_ptr);
}

//*************************************************************
// Function: isEmployeeSize
//
// Purpose: Traverses the linked list and keeps a running count
//          on how many employees are currently in our list.
//
// Parameters:
//
//   head_ptr - pointer to the initial node in our linked list
//
// Returns:
//
//   theSize - the number of employees in our linked list
//
//**************************************************************

int isEmployeeSize (struct employee * head_ptr)
{

    struct employee * current_ptr; // pointer to current node
    int theSize;                   // number of link list nodes

    theSize = 0; // initialize

    // assume there is data if the first node has an employee name
    if (head_ptr->empName.firstName[0] != '\0')
    {

        // traverse through the linked list, keep a running count of nodes
        for (current_ptr = head_ptr; current_ptr; current_ptr = current_ptr->next)
        {

            ++theSize;  // employee node found, increment

        } // for
    }

    return (theSize);  // number of nodes (i.e., employees)

} // isEmployeeSize

//**************************************************************
// Function: printHeader
//
// Purpose: Prints the initial table header information.
//
// Parameters: none
//
// Returns: void
//
//**************************************************************

void printHeader (void)
{

    printf ("\n\n*** Pay Calculator ***\n");

    // print the table header
    printf("\n---------------------------------------------------------------------------------");
    printf("\nName                Tax  Clock#  Wage   Hours  OT   Gross   State  Fed      Net");
    printf("\n                   State                            Pay     Tax    Tax      Pay");
    printf("\n---------------------------------------------------------------------------------");

} // printHeader

//*************************************************************
// Function: printEmp
//
// Purpose: Prints out all the information for each employee
//          in a nice and orderly table format.
//
// Parameters:
//
//   head_ptr - pointer to the beginning of our linked list
//
// Returns: void
//
//**************************************************************

void printEmp (struct employee * head_ptr)
{


    // Used to format the employee name
    char name [FIRST_NAME_SIZE + LAST_NAME_SIZE + 1];

    struct employee * current_ptr; // pointer to current node

    // traverse through the linked list to process each employee
    for (current_ptr = head_ptr; current_ptr; current_ptr = current_ptr->next)
    {
        // Format the name
        strcpy (name, current_ptr->empName.firstName);
        strcat (name, " "); // add a space between first and last names
        strcat (name, current_ptr->empName.lastName);

        // Print out current employee in the current linked list node
        printf("\n%-20.20s %-2.2s  %06li %6.2f %6.1f %5.1f %8.2f %7.2f %8.2f %9.2f",
               name, current_ptr->taxState, current_ptr->clockNumber,
               current_ptr->wageRate, current_ptr->hours,
               current_ptr->overtimeHrs, current_ptr->grossPay,
               current_ptr->stateTax, current_ptr->fedTax,
               current_ptr->netPay);

    } // for

} // printEmp

//*************************************************************
// Function: printEmpStatistics
//
// Purpose: Prints out the summary totals and averages of all
//          floating point value items for all employees
//          that have been processed.  It also prints
//          out the min and max values.
//
// Parameters:
//
//   emp_totals_ptr - pointer to a structure containing a running total
//                    of all employee floating point items
//
//   emp_minMax_ptr - pointer to a structure containing
//                    the minimum and maximum values of all
//                    employee floating point items
//
//   theSize - the total number of employees processed
//
// Returns: void
//
//**************************************************************

void printEmpStatistics (struct totals   * emp_totals_ptr,
                         struct min_max  * emp_minMax_ptr,
                         int theSize)
{

    // print a separator line
    printf("\n---------------------------------------------------------------------------------");

    // print the totals for all the floating point items
    printf("\nTotals:                          %5.2f %5.1f %5.1f %8.2f %7.2f %8.2f %9.2f",
           emp_totals_ptr->total_wageRate,
           emp_totals_ptr->total_hours,
           emp_totals_ptr->total_overtimeHrs,
           emp_totals_ptr->total_grossPay,
           emp_totals_ptr->total_stateTax,
           emp_totals_ptr->total_fedTax,
           emp_totals_ptr->total_netPay);

    // make sure you don't divide by zero or a negative number
    if (theSize > 0)
    {
        // print the averages for all the floating point items
        printf("\nAverages:                        %5.2f %5.1f %5.1f %8.2f %7.2f %8.2f %9.2f",
               emp_totals_ptr->total_wageRate/theSize,
               emp_totals_ptr->total_hours/theSize,
               emp_totals_ptr->total_overtimeHrs/theSize,
               emp_totals_ptr->total_grossPay/theSize,
               emp_totals_ptr->total_stateTax/theSize,
               emp_totals_ptr->total_fedTax/theSize,
               emp_totals_ptr->total_netPay/theSize);

    } // if

    // print the min and max values for each item

    printf("\nMinimum:                         %5.2f %5.1f %5.1f %8.2f %7.2f %8.2f %9.2f",
           emp_minMax_ptr->min_wageRate,
           emp_minMax_ptr->min_hours,
           emp_minMax_ptr->min_overtimeHrs,
           emp_minMax_ptr->min_grossPay,
           emp_minMax_ptr->min_stateTax,
           emp_minMax_ptr->min_fedTax,
           emp_minMax_ptr->min_netPay);

    printf("\nMaximum:                         %5.2f %5.1f %5.1f %8.2f %7.2f %8.2f %9.2f",
           emp_minMax_ptr->max_wageRate,
           emp_minMax_ptr->max_hours,
           emp_minMax_ptr->max_overtimeHrs,
           emp_minMax_ptr->max_grossPay,
           emp_minMax_ptr->max_stateTax,
           emp_minMax_ptr->max_fedTax,
           emp_minMax_ptr->max_netPay);

    // print out the total employees processed
    printf ("\n\nThe total employees processed was: %i\n", theSize);

}  // printEmpStatistics

//*************************************************************
// Function: calcOvertimeHrs
//
// Purpose: Calculates the overtime hours worked by an employee
//          in a given week for each employee.
//
// Parameters:
//
//   head_ptr - pointer to the beginning of our linked list
//
// Returns: void (the overtime hours gets updated by reference)
//
//**************************************************************

void calcOvertimeHrs (struct employee * head_ptr)
{

    struct employee * current_ptr; // pointer to current node

    // traverse through the linked list to calculate overtime hours
    for (current_ptr = head_ptr; current_ptr; current_ptr = current_ptr->next)
    {
        // Any overtime?
        if (current_ptr->hours > STD_HOURS)
        {
            current_ptr->overtimeHrs = current_ptr->hours - STD_HOURS;
        }
        else // no overtime
        {
            current_ptr->overtimeHrs = 0;
        }

    } // for

} // calcOvertimeHrs

//*************************************************************
// Function: calcGrossPay
//
// Purpose: Calculates the gross pay based on the normal pay
//          and any overtime pay for a given week for each
//          employee.
//
// Parameters:
//
//   head_ptr - pointer to the beginning of our linked list
//
// Returns: void (the gross pay gets updated by reference)
//
//**************************************************************

void calcGrossPay (struct employee * head_ptr)
{

    float theNormalPay;   // normal pay without any overtime hours
    float theOvertimePay; // overtime pay

    struct employee * current_ptr; // pointer to current node

    // traverse through the linked list to calculate gross pay
    for (current_ptr = head_ptr; current_ptr; current_ptr = current_ptr->next)
    {
        // calculate normal pay and any overtime pay
        theNormalPay = current_ptr->wageRate *
                       (current_ptr->hours - current_ptr->overtimeHrs);
        theOvertimePay = current_ptr->overtimeHrs *
                         (OT_RATE * current_ptr->wageRate);

        // calculate gross pay for employee as normalPay + any overtime pay
        current_ptr->grossPay = theNormalPay + theOvertimePay;

    }

} // calcGrossPay

//*************************************************************
// Function: calcStateTax
//
// Purpose: Calculates the State Tax owed based on gross pay
//          for each employee. State tax rate is based on the
//          designated tax state.
//
// Parameters:
//
//   head_ptr - pointer to the beginning of our linked list
//
// Returns: void (the state tax gets updated by reference)
//
//**************************************************************

void calcStateTax (struct employee * head_ptr)
{

    struct employee * current_ptr; // pointer to current node

    // traverse through the linked list to calculate the state tax
    for (current_ptr = head_ptr; current_ptr; current_ptr = current_ptr->next)
    {
        // Make sure tax state is all uppercase
        if (islower(current_ptr->taxState[0]))
            current_ptr->taxState[0] = toupper(current_ptr->taxState[0]);
        if (islower(current_ptr->taxState[1]))
            current_ptr->taxState[1] = toupper(current_ptr->taxState[1]);

        // Calculate state tax based on taxState
        if (strcmp(current_ptr->taxState, "MA") == 0)
            current_ptr->stateTax = current_ptr->grossPay * MA_TAX_RATE;
        else if (strcmp(current_ptr->taxState, "NH") == 0)
            current_ptr->stateTax = current_ptr->grossPay * NH_TAX_RATE;
        else if (strcmp(current_ptr->taxState, "VT") == 0)
            current_ptr->stateTax = current_ptr->grossPay * VT_TAX_RATE;
        else if (strcmp(current_ptr->taxState, "CA") == 0)
            current_ptr->stateTax = current_ptr->grossPay * CA_TAX_RATE;
        else
            current_ptr->stateTax = current_ptr->grossPay * DEFAULT_TAX_RATE;

    } // for

} // calcStateTax

//*************************************************************
// Function: calcFedTax
//
// Purpose: Calculates the Federal Tax owed based on the gross
//          pay for each employee
//
// Parameters:
//
//   head_ptr - pointer to the beginning of our linked list
//
// Returns: void (the federal tax gets updated by reference)
//
//**************************************************************

void calcFedTax (struct employee * head_ptr)
{

    struct employee * current_ptr; // pointer to current node

    // traverse through the linked list to calculate the federal tax
    for (current_ptr = head_ptr; current_ptr; current_ptr = current_ptr->next)
    {
        // Calculate federal tax
        current_ptr->fedTax = current_ptr->grossPay * FED_TAX_RATE;
    }

} // calcFedTax

//*************************************************************
// Function: calcNetPay
//
// Purpose: Calculates the net pay as the gross pay minus any
//          state and federal taxes owed for each employee.
//
// Parameters:
//
//   head_ptr - pointer to the beginning of our linked list
//
// Returns: void (the net pay gets updated by reference)
//
//**************************************************************

void calcNetPay (struct employee * head_ptr)
{
    float theTotalTaxes; // the total state and federal tax

    struct employee * current_ptr; // pointer to current node

    // traverse through the linked list to calculate the net pay
    for (current_ptr = head_ptr; current_ptr; current_ptr = current_ptr->next)
    {
        // calculate the total state and federal taxes
        theTotalTaxes = current_ptr->stateTax + current_ptr->fedTax;

        // calculate the net pay
        current_ptr->netPay = current_ptr->grossPay - theTotalTaxes;

    } // for

} // calcNetPay

//*************************************************************
// Function: calcEmployeeTotals
//
// Purpose: Performs a running total (sum) of each employee
//          floating point member item stored in our linked list
//
// Parameters:
//
//   head_ptr - pointer to the beginning of our linked list
//   emp_totals_ptr - pointer to a structure containing the
//                    running totals of each floating point
//                    member for all employees in our linked
//                    list
//
// Returns:
//
//   void (the employeeTotals structure gets updated by reference)
//
//**************************************************************

void calcEmployeeTotals (struct employee * head_ptr,
                         struct totals * emp_totals_ptr)
{

    struct employee * current_ptr; // pointer to current node

    // traverse through the linked list to calculate a running
    // sum of each employee floating point member item
    for (current_ptr = head_ptr; current_ptr; current_ptr = current_ptr->next)
    {
        // add current employee data to our running totals
        emp_totals_ptr->total_wageRate += current_ptr->wageRate;
        emp_totals_ptr->total_hours += current_ptr->hours;
        emp_totals_ptr->total_overtimeHrs += current_ptr->overtimeHrs;
        emp_totals_ptr->total_grossPay += current_ptr->grossPay;
        emp_totals_ptr->total_stateTax += current_ptr->stateTax;
        emp_totals_ptr->total_fedTax += current_ptr->fedTax;
        emp_totals_ptr->total_netPay += current_ptr->netPay;

    } // for

} // calcEmployeeTotals

//*************************************************************
// Function: calcEmployeeMinMax
//
// Purpose: Accepts various floating point values from an
//          employee and adds to a running update of min
//          and max values
//
// Parameters:
//
//   head_ptr - pointer to the beginning of our linked list
//   emp_minMax_ptr - pointer to the min/max structure
//
// Returns:
//
//   void (employeeMinMax structure updated by reference)
//
//**************************************************************

void calcEmployeeMinMax (struct employee * head_ptr,
                         struct min_max * emp_minMax_ptr)
{

    struct employee * current_ptr; // pointer to current node

    // Initialize min and max values with the first employee
    current_ptr = head_ptr;

    // set the min to the first employee members
    emp_minMax_ptr->min_wageRate = current_ptr->wageRate;
    emp_minMax_ptr->min_hours = current_ptr->hours;
    emp_minMax_ptr->min_overtimeHrs = current_ptr->overtimeHrs;
    emp_minMax_ptr->min_grossPay = current_ptr->grossPay;
    emp_minMax_ptr->min_stateTax = current_ptr->stateTax;
    emp_minMax_ptr->min_fedTax = current_ptr->fedTax;
    emp_minMax_ptr->min_netPay = current_ptr->netPay;

    // set the max to the first employee members
    emp_minMax_ptr->max_wageRate = current_ptr->wageRate;
    emp_minMax_ptr->max_hours = current_ptr->hours;
    emp_minMax_ptr->max_overtimeHrs = current_ptr->overtimeHrs;
    emp_minMax_ptr->max_grossPay = current_ptr->grossPay;
    emp_minMax_ptr->max_stateTax = current_ptr->stateTax;
    emp_minMax_ptr->max_fedTax = current_ptr->fedTax;
    emp_minMax_ptr->max_netPay = current_ptr->netPay;

    // move to the next employee
    current_ptr = current_ptr->next;

    // traverse the linked list
    for (; current_ptr; current_ptr = current_ptr->next)
    {
        // Wage Rate
        if (current_ptr->wageRate < emp_minMax_ptr->min_wageRate)
            emp_minMax_ptr->min_wageRate = current_ptr->wageRate;
        if (current_ptr->wageRate > emp_minMax_ptr->max_wageRate)
            emp_minMax_ptr->max_wageRate = current_ptr->wageRate;

        // Hours
        if (current_ptr->hours < emp_minMax_ptr->min_hours)
            emp_minMax_ptr->min_hours = current_ptr->hours;
        if (current_ptr->hours > emp_minMax_ptr->max_hours)
            emp_minMax_ptr->max_hours = current_ptr->hours;

        // Overtime Hours
        if (current_ptr->overtimeHrs < emp_minMax_ptr->min_overtimeHrs)
            emp_minMax_ptr->min_overtimeHrs = current_ptr->overtimeHrs;
        if (current_ptr->overtimeHrs > emp_minMax_ptr->max_overtimeHrs)
            emp_minMax_ptr->max_overtimeHrs = current_ptr->overtimeHrs;

        // Gross Pay
        if (current_ptr->grossPay < emp_minMax_ptr->min_grossPay)
            emp_minMax_ptr->min_grossPay = current_ptr->grossPay;
        if (current_ptr->grossPay > emp_minMax_ptr->max_grossPay)
            emp_minMax_ptr->max_grossPay = current_ptr->grossPay;

        // State Tax
        if (current_ptr->stateTax < emp_minMax_ptr->min_stateTax)
            emp_minMax_ptr->min_stateTax = current_ptr->stateTax;
        if (current_ptr->stateTax > emp_minMax_ptr->max_stateTax)
            emp_minMax_ptr->max_stateTax = current_ptr->stateTax;

        // Federal Tax
        if (current_ptr->fedTax < emp_minMax_ptr->min_fedTax)
            emp_minMax_ptr->min_fedTax = current_ptr->fedTax;
        if (current_ptr->fedTax > emp_minMax_ptr->max_fedTax)
            emp_minMax_ptr->max_fedTax = current_ptr->fedTax;

        // Net Pay
        if (current_ptr->netPay < emp_minMax_ptr->min_netPay)
            emp_minMax_ptr->min_netPay = current_ptr->netPay;
        if (current_ptr->netPay > emp_minMax_ptr->max_netPay)
            emp_minMax_ptr->max_netPay = current_ptr->netPay;

    } // for

} // calcEmployeeMinMax