// Linked Lists, Typedef, and Macros
// 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.
//
// It will also take advantage of the C Preprocessor features,
// in particular with using macros, and will replace all 
// struct type references in the code with a typedef alias
// reference.
//
// 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_STATE_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 macros
#define CALC_OT_HOURS(theHours) ((theHours > STD_HOURS) ? theHours - STD_HOURS : 0)
#define CALC_STATE_TAX(thePay,theStateTaxRate) (thePay * theStateTaxRate)
#define CALC_FED_TAX(thePay) (thePay * FED_TAX_RATE)
#define CALC_NET_PAY(thePay,theStateTax,theFedTax) (thePay - (theStateTax + theFedTax))
#define CALC_NORMAL_PAY(theWageRate,theHours,theOvertimeHrs) \
(theWageRate * (theHours - theOvertimeHrs))
#define CALC_OT_PAY(theWageRate,theOvertimeHrs) (theOvertimeHrs * (OT_RATE * theWageRate))
#define CALC_MIN(theValue, currentMin) ((theValue < currentMin) ? theValue : currentMin)
#define CALC_MAX(theValue, currentMax) ((theValue > currentMax) ? theValue : currentMax)

// 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
typedef 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;
} EMPLOYEE;

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

// This structure type defines the min and max values
typedef 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;
} MIN_MAX;

// Function prototypes
EMPLOYEE * getEmpData (void);
int isEmployeeSize (EMPLOYEE * head_ptr);
void calcOvertimeHrs (EMPLOYEE * head_ptr);
void calcGrossPay (EMPLOYEE * head_ptr);
void printHeader (void);
void printEmp (EMPLOYEE * head_ptr);
void calcStateTax (EMPLOYEE * head_ptr);
void calcFedTax (EMPLOYEE * head_ptr);
void calcNetPay (EMPLOYEE * head_ptr);
void calcEmployeeTotals (EMPLOYEE * head_ptr, TOTALS * emp_totals_ptr);
void calcEmployeeMinMax (EMPLOYEE * head_ptr, MIN_MAX * emp_minMax_ptr);
void printEmpStatistics (TOTALS * emp_totals_ptr, MIN_MAX * emp_minMax_ptr, int size);

int main ()
{
   // Set up head pointer to point to the start of the linked list
   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
   TOTALS employeeTotals  = {0,0,0,0,0,0,0};
   TOTALS * emp_totals_ptr = &employeeTotals;

   // set up structure to store min and max values and initialize all to zero
   MIN_MAX employeeMinMax = {0,0,0,0,0,0,0,0,0,0,0,0,0,0};
   MIN_MAX * emp_minMax_ptr = &employeeMinMax;

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

   // determine how many employees are in our linked list
   theSize = isEmployeeSize (head_ptr);
   
   if (theSize <= 0)
   {
       printf("\n\n**** There was no employee input to process ***\n");
   }
   else
   {    
       // Perform calculations
       calcOvertimeHrs (head_ptr);
       calcGrossPay (head_ptr);
       calcStateTax (head_ptr);
       calcFedTax (head_ptr);
       calcNetPay (head_ptr); 
       
       // Calculate totals and min/max values
       calcEmployeeTotals (head_ptr, &employeeTotals);
       calcEmployeeMinMax (head_ptr, &employeeMinMax);
                       
       // Print results
       printHeader();
       printEmp (head_ptr); 
       printEmpStatistics (&employeeTotals, &employeeMinMax, theSize);
   }
   
   printf ("\n\n *** End of Program *** \n");
   return (0);
}

// Function implementations...

EMPLOYEE * getEmpData (void)
{
   char answer[80];
   int more_data = 1;
   char value;

   EMPLOYEE *current_ptr, *head_ptr;

   head_ptr = (EMPLOYEE *) malloc (sizeof(EMPLOYEE));
   current_ptr = head_ptr;

   while (more_data)
   {
       printf ("\nEnter employee first name: ");
       scanf ("%s", current_ptr->empName.firstName);
       printf ("\nEnter employee last name: ");
       scanf ("%s", current_ptr->empName.lastName);
       printf ("\nEnter employee two character tax state: ");
       scanf ("%s", current_ptr->taxState);
       printf("\nEnter employee clock number: ");
       scanf("%li", & current_ptr -> clockNumber);
       printf("\nEnter employee hourly wage: ");
       scanf("%f", & current_ptr -> wageRate);
       printf("\nEnter hours worked this week: ");
       scanf("%f", & current_ptr -> hours);

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

       if ((value = toupper(answer[0])) != 'Y')
       {
          current_ptr->next = (EMPLOYEE *) NULL;
          more_data = 0; 
       }
       else
       {
          current_ptr->next = (EMPLOYEE *) malloc (sizeof(EMPLOYEE));
          current_ptr = current_ptr->next;
       }
   }
   return(head_ptr);
}

int isEmployeeSize (EMPLOYEE * head_ptr)
{
   EMPLOYEE * current_ptr;
   int theSize = 0;

   if (head_ptr->empName.firstName[0] != '\0')
   {
       for (current_ptr = head_ptr; current_ptr; current_ptr = current_ptr->next)
       {  
           ++theSize;
       }
   }
   return (theSize);
}

void printHeader (void) 
{
   printf ("\n\n*** Pay Calculator ***\n");
   printf("\n--------------------------------------------------------------");
   printf("-------------------");
   printf("\nName                Tax  Clock# Wage   Hours  OT   Gross ");
   printf("  State  Fed      Net");
   printf("\n                   State                           Pay   ");
   printf("  Tax    Tax      Pay");
   printf("\n--------------------------------------------------------------");
   printf("-------------------");
}

void printEmp (EMPLOYEE * head_ptr)
{
   char name[FIRST_NAME_SIZE + LAST_NAME_SIZE + 1];
   EMPLOYEE * current_ptr;

   for (current_ptr = head_ptr; current_ptr; current_ptr = current_ptr->next)
   {
       strcpy (name, current_ptr->empName.firstName);
       strcat (name, " ");
       strcat (name, current_ptr->empName.lastName);
   
       printf("\n%-20.20s %-2.2s  %06li %5.2f  %4.1f  %4.1f %7.2f %6.2f %7.2f %8.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);
   }
}

void printEmpStatistics (TOTALS * emp_totals_ptr, MIN_MAX * emp_minMax_ptr, int theSize)
{
   printf("\n--------------------------------------------------------------");
   printf("-------------------");
   
   printf("\nTotals:                         %5.2f %5.1f %5.1f %7.2f %6.2f %7.2f %8.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);
   
   if (theSize > 0)       
   {
       printf("\nAverages:                       %5.2f %5.1f %5.1f %7.2f %6.2f %7.2f %8.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);
   }
   
   printf("\nMinimum:                        %5.2f %5.1f %5.1f %7.2f %6.2f %7.2f %8.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 %7.2f %6.2f %7.2f %8.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);
          
   printf ("\n\nThe total employees processed was: %i\n", theSize);
}

void calcOvertimeHrs (EMPLOYEE * head_ptr)
{
   EMPLOYEE * current_ptr;
   for (current_ptr = head_ptr; current_ptr; current_ptr = current_ptr->next)
   {  
       current_ptr->overtimeHrs = CALC_OT_HOURS(current_ptr->hours);
   }
}

void calcGrossPay (EMPLOYEE * head_ptr)
{
   float theNormalPay, theOvertimePay;
   EMPLOYEE * current_ptr;

   for (current_ptr = head_ptr; current_ptr; current_ptr = current_ptr->next)
   {
       theNormalPay = CALC_NORMAL_PAY(current_ptr->wageRate,
                                      current_ptr->hours,
                                      current_ptr->overtimeHrs);
       theOvertimePay = CALC_OT_PAY(current_ptr->wageRate,
                                    current_ptr->overtimeHrs);
       current_ptr->grossPay = theNormalPay + theOvertimePay;
   }
}

void calcStateTax (EMPLOYEE * head_ptr)
{
   EMPLOYEE * current_ptr;

   for (current_ptr = head_ptr; current_ptr; current_ptr = current_ptr->next)
   {
       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]);
       
       if (strcmp(current_ptr->taxState, "MA") == 0)
           current_ptr->stateTax = CALC_STATE_TAX(current_ptr->grossPay, MA_TAX_RATE);
       else if (strcmp(current_ptr->taxState, "VT") == 0)
           current_ptr->stateTax = CALC_STATE_TAX(current_ptr->grossPay, VT_TAX_RATE);
       else if (strcmp(current_ptr->taxState, "NH") == 0)
           current_ptr->stateTax = CALC_STATE_TAX(current_ptr->grossPay, NH_TAX_RATE);
       else if (strcmp(current_ptr->taxState, "CA") == 0)
           current_ptr->stateTax = CALC_STATE_TAX(current_ptr->grossPay, CA_TAX_RATE);
       else
           current_ptr->stateTax = CALC_STATE_TAX(current_ptr->grossPay, DEFAULT_STATE_TAX_RATE);
   }
}

void calcFedTax (EMPLOYEE * head_ptr)
{
   EMPLOYEE * current_ptr;
   for (current_ptr = head_ptr; current_ptr; current_ptr = current_ptr->next)
   {
       current_ptr->fedTax = CALC_FED_TAX(current_ptr->grossPay);
   }
}

void calcNetPay (EMPLOYEE * head_ptr)
{
   EMPLOYEE * current_ptr;
   for (current_ptr = head_ptr; current_ptr; current_ptr = current_ptr->next)
   {
       current_ptr->netPay = CALC_NET_PAY(current_ptr->grossPay,
                                          current_ptr->stateTax,
                                          current_ptr->fedTax);
   }
}

void calcEmployeeTotals (EMPLOYEE * head_ptr, TOTALS * emp_totals_ptr)
{
   EMPLOYEE * current_ptr;
   for (current_ptr = head_ptr; current_ptr; current_ptr = current_ptr->next)
   {
       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;
   }
}

void calcEmployeeMinMax (EMPLOYEE * head_ptr, MIN_MAX * emp_minMax_ptr)
{
   EMPLOYEE * current_ptr = head_ptr;
   
   // Initialize with first employee's values
   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;
       
   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 next employee
   current_ptr = current_ptr->next;
   
   // Process remaining employees
   for (; current_ptr; current_ptr = current_ptr->next) 
   {
       emp_minMax_ptr->min_wageRate = CALC_MIN(current_ptr->wageRate, emp_minMax_ptr->min_wageRate);
       emp_minMax_ptr->max_wageRate = CALC_MAX(current_ptr->wageRate, emp_minMax_ptr->max_wageRate);
       
       emp_minMax_ptr->min_hours = CALC_MIN(current_ptr->hours, emp_minMax_ptr->min_hours);
       emp_minMax_ptr->max_hours = CALC_MAX(current_ptr->hours, emp_minMax_ptr->max_hours);       
       
       emp_minMax_ptr->min_overtimeHrs = CALC_MIN(current_ptr->overtimeHrs, emp_minMax_ptr->min_overtimeHrs);
       emp_minMax_ptr->max_overtimeHrs = CALC_MAX(current_ptr->overtimeHrs, emp_minMax_ptr->max_overtimeHrs);
       
       emp_minMax_ptr->min_grossPay = CALC_MIN(current_ptr->grossPay, emp_minMax_ptr->min_grossPay);
       emp_minMax_ptr->max_grossPay = CALC_MAX(current_ptr->grossPay, emp_minMax_ptr->max_grossPay);
       
       emp_minMax_ptr->min_stateTax = CALC_MIN(current_ptr->stateTax, emp_minMax_ptr->min_stateTax);
       emp_minMax_ptr->max_stateTax = CALC_MAX(current_ptr->stateTax, emp_minMax_ptr->max_stateTax);
       
       emp_minMax_ptr->min_fedTax = CALC_MIN(current_ptr->fedTax, emp_minMax_ptr->min_fedTax);
       emp_minMax_ptr->max_fedTax = CALC_MAX(current_ptr->fedTax, emp_minMax_ptr->max_fedTax);
       
       emp_minMax_ptr->min_netPay = CALC_MIN(current_ptr->netPay, emp_minMax_ptr->min_netPay);
       emp_minMax_ptr->max_netPay = CALC_MAX(current_ptr->netPay, emp_minMax_ptr->max_netPay);
   }
}