//********************************************************
//
// Assignment 10 - Linked Lists, Typedef, and Macros
//
// Name: John Nguyen
//
// Class: C Programming, Fall 2024
//
// Date: 11/24/2024
//
// Description: Program determines overtime and gross pay
// for employees and calculates state, federal tax, net pay.
// It also calculates totals, averages, minimum, and maximum
// values for all floating point items.
//
//********************************************************

// necessary header files
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h> 

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

// typedef for structures
typedef struct employee {
    struct {
        char firstName[FIRST_NAME_SIZE];
        char lastName[LAST_NAME_SIZE];
    } 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;

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;

typedef struct min_max {
    float min_wageRate, min_hours, min_overtimeHrs, min_grossPay;
    float min_stateTax, min_fedTax, min_netPay;
    float max_wageRate, max_hours, max_overtimeHrs, max_grossPay;
    float max_stateTax, max_fedTax, 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 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 printHeader(void);
void printEmp(EMPLOYEE *head_ptr);
void printEmpStatistics(TOTALS *emp_totals_ptr, MIN_MAX *emp_minMax_ptr, int size);

int main() {
    EMPLOYEE *head_ptr; 
    int theSize;

    TOTALS employeeTotals = {0, 0, 0, 0, 0, 0, 0};
    TOTALS *emp_totals_ptr = &employeeTotals;

    MIN_MAX employeeMinMax = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
    MIN_MAX *emp_minMax_ptr = &employeeMinMax;

    head_ptr = getEmpData();
    theSize = isEmployeeSize(head_ptr);

    if (theSize <= 0) {
        printf("\n\n**** There was no employee input to process ***\n");
    } else {
        calcOvertimeHrs(head_ptr);
        calcGrossPay(head_ptr);
        calcStateTax(head_ptr);
        calcFedTax(head_ptr);
        calcNetPay(head_ptr);
        calcEmployeeTotals(head_ptr, emp_totals_ptr);
        calcEmployeeMinMax(head_ptr, emp_minMax_ptr);
        printHeader();
        printEmp(head_ptr);
        printEmpStatistics(emp_totals_ptr, emp_minMax_ptr, theSize);
    }

    printf("\n\n *** End of Program *** \n");
    return 0;
}

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

    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 (toupper(answer[0]) != 'Y') {
            current_ptr->next = 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) {
    int theSize = 0;
    for (EMPLOYEE *current_ptr = head_ptr; current_ptr; current_ptr = current_ptr->next) {
        theSize++;
    }
    return theSize;
}

void calcOvertimeHrs(EMPLOYEE *head_ptr) {
    for (EMPLOYEE *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) {
    for (EMPLOYEE *current_ptr = head_ptr; current_ptr; current_ptr = current_ptr->next) {
        current_ptr->grossPay = CALC_NORMAL_PAY(current_ptr->wageRate, current_ptr->hours, current_ptr->overtimeHrs) +
                                CALC_OT_PAY(current_ptr->wageRate, current_ptr->overtimeHrs);
    }
}

void calcStateTax(EMPLOYEE *head_ptr) {
    for (EMPLOYEE *current_ptr = head_ptr; current_ptr; current_ptr = current_ptr->next) {
        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) {
    for (EMPLOYEE *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) {
    for (EMPLOYEE *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) {
    for (EMPLOYEE *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;

    emp_minMax_ptr->min_wageRate = emp_minMax_ptr->max_wageRate = current_ptr->wageRate;
    emp_minMax_ptr->min_hours = emp_minMax_ptr->max_hours = current_ptr->hours;
    emp_minMax_ptr->min_overtimeHrs = emp_minMax_ptr->max_overtimeHrs = current_ptr->overtimeHrs;
    emp_minMax_ptr->min_grossPay = emp_minMax_ptr->max_grossPay = current_ptr->grossPay;
    emp_minMax_ptr->min_stateTax = emp_minMax_ptr->max_stateTax = current_ptr->stateTax;
    emp_minMax_ptr->min_fedTax = emp_minMax_ptr->max_fedTax = current_ptr->fedTax;
    emp_minMax_ptr->min_netPay = emp_minMax_ptr->max_netPay = current_ptr->netPay;

    for (current_ptr = current_ptr->next; 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);
    }
}

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];
    for (EMPLOYEE *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 size) {
    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 (size > 0) {
        printf("\nAverages:                       %5.2f %5.1f %5.1f %7.2f %6.2f %7.2f %8.2f",
               emp_totals_ptr->total_wageRate / size,
               emp_totals_ptr->total_hours / size,
               emp_totals_ptr->total_overtimeHrs / size,
               emp_totals_ptr->total_grossPay / size,
               emp_totals_ptr->total_stateTax / size,
               emp_totals_ptr->total_fedTax / size,
               emp_totals_ptr->total_netPay / size);
    }

    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", size);
}