//********************************************************
//
// Assignment 8 - Structures and Strings and Pointers
//
// Name: Andrea Huskey
//
// Class: C Programming, Summer 2026
//
// Date: July 18, 2026
//
// 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.
//
// Dynamically allocated linked list version
//
// Call by Reference design (using pointers)
//
//********************************************************

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>

#define SIZE 5
#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 TAX_STATE_SIZE 3
#define FED_TAX_RATE 0.25
#define FIRST_NAME_SIZE 20
#define LAST_NAME_SIZE 20

struct name
{
    char firstName[FIRST_NAME_SIZE];
    char lastName[LAST_NAME_SIZE];
};

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;
};

struct totals
{
    float total_wageRate;
    float total_hours;
    float total_overtimeHrs;
    float total_grossPay;
    float total_stateTax;
    float total_fedTax;
    float total_netPay;
};

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;
};

struct employee *getEmpData(int theSize);
void printEmp(struct employee *emp_ptr);

void calcOvertimeHrs(struct employee *emp_ptr);
void calcGrossPay(struct employee *emp_ptr);
void calcStateTax(struct employee *emp_ptr);
void calcFedTax(struct employee *emp_ptr);
void calcNetPay(struct employee *emp_ptr);

void calcEmployeeTotals(struct employee *emp_ptr,
                        struct totals *emp_totals_ptr);

void calcEmployeeMinMax(struct employee *emp_ptr,
                        struct min_max *emp_MinMax_ptr);

void printHeader(void);
void printEmpStatistics(struct totals *employeeTotals_ptr,
                        struct min_max *employeeMinMax_ptr,
                        int theSize);

int main()
{
    struct employee *head_ptr = NULL;
    struct employee *free_ptr = NULL;

    struct totals employeeTotals = {0, 0, 0, 0, 0, 0, 0};
    struct totals *emp_totals_ptr = &employeeTotals;

    struct min_max employeeMinMax = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
    struct min_max *employeeMinMax_ptr = &employeeMinMax;

    head_ptr = getEmpData(SIZE);

    calcOvertimeHrs(head_ptr);
    calcGrossPay(head_ptr);
    calcStateTax(head_ptr);
    calcFedTax(head_ptr);
    calcNetPay(head_ptr);

    calcEmployeeTotals(head_ptr, emp_totals_ptr);
    calcEmployeeMinMax(head_ptr, employeeMinMax_ptr);

    printHeader();
    printEmp(head_ptr);
    printEmpStatistics(emp_totals_ptr, employeeMinMax_ptr, SIZE);

    while (head_ptr != NULL)
    {
        free_ptr = head_ptr;
        head_ptr = head_ptr->next;
        free(free_ptr);
    }

    return 0;
}

struct employee *getEmpData(int theSize)
{
    struct employee *head_ptr = NULL;
    struct employee *tail_ptr = NULL;
    struct employee *emp_ptr = NULL;
    int i;

    for (i = 0; i < theSize; ++i)
    {
        emp_ptr = (struct employee *)malloc(sizeof(struct employee));
        if (emp_ptr == NULL)
        {
            printf("Memory allocation failed.\n");
            return head_ptr;
        }

        printf("Enter first name: ");
        scanf("%19s", emp_ptr->empName.firstName);

        printf("Enter last name: ");
        scanf("%19s", emp_ptr->empName.lastName);

        printf("Enter tax state: ");
        scanf("%2s", emp_ptr->taxState);

        printf("Enter clock number: ");
        scanf("%ld", &emp_ptr->clockNumber);

        printf("Enter wage rate: ");
        scanf("%f", &emp_ptr->wageRate);

        printf("Enter hours worked: ");
        scanf("%f", &emp_ptr->hours);

        emp_ptr->overtimeHrs = 0;
        emp_ptr->grossPay = 0;
        emp_ptr->stateTax = 0;
        emp_ptr->fedTax = 0;
        emp_ptr->netPay = 0;
        emp_ptr->next = NULL;

        if (head_ptr == NULL)
        {
            head_ptr = emp_ptr;
            tail_ptr = emp_ptr;
        }
        else
        {
            tail_ptr->next = emp_ptr;
            tail_ptr = emp_ptr;
        }
    }

    return head_ptr;
}

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

void printEmp(struct employee *emp_ptr)
{
    char name[FIRST_NAME_SIZE + LAST_NAME_SIZE + 2];

    while (emp_ptr != NULL)
    {
        snprintf(name, sizeof(name), "%s %s", emp_ptr->empName.firstName, emp_ptr->empName.lastName);
        printf("\n%-20.20s %-2s  %06ld  %5.2f  %4.1f  %4.1f  %7.2f  %6.2f  %7.2f  %8.2f",
               name, emp_ptr->taxState, emp_ptr->clockNumber,
               emp_ptr->wageRate, emp_ptr->hours, emp_ptr->overtimeHrs,
               emp_ptr->grossPay, emp_ptr->stateTax,
               emp_ptr->fedTax, emp_ptr->netPay);
        emp_ptr = emp_ptr->next;
    }
}

void printEmpStatistics(struct totals *employeeTotals_ptr,
                        struct min_max *employeeMinMax_ptr,
                        int theSize)
{
    printf("\n---------------------------------------------------------------------------------");

    printf("\nTotals:                          %5.2f %5.1f %5.1f %7.2f %6.2f %7.2f %8.2f",
           employeeTotals_ptr->total_wageRate,
           employeeTotals_ptr->total_hours,
           employeeTotals_ptr->total_overtimeHrs,
           employeeTotals_ptr->total_grossPay,
           employeeTotals_ptr->total_stateTax,
           employeeTotals_ptr->total_fedTax,
           employeeTotals_ptr->total_netPay);

    printf("\nAverages:                        %5.2f %5.1f %5.1f %7.2f %6.2f %7.2f %8.2f",
           employeeTotals_ptr->total_wageRate / theSize,
           employeeTotals_ptr->total_hours / theSize,
           employeeTotals_ptr->total_overtimeHrs / theSize,
           employeeTotals_ptr->total_grossPay / theSize,
           employeeTotals_ptr->total_stateTax / theSize,
           employeeTotals_ptr->total_fedTax / theSize,
           employeeTotals_ptr->total_netPay / theSize);

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

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

void calcOvertimeHrs(struct employee *emp_ptr)
{
    while (emp_ptr != NULL)
    {
        emp_ptr->overtimeHrs = (emp_ptr->hours > STD_HOURS) ? (emp_ptr->hours - STD_HOURS) : 0;
        emp_ptr = emp_ptr->next;
    }
}

void calcGrossPay(struct employee *emp_ptr)
{
    while (emp_ptr != NULL)
    {
        emp_ptr->grossPay = (emp_ptr->wageRate * emp_ptr->hours) + (emp_ptr->overtimeHrs * emp_ptr->wageRate * 0.5f);
        emp_ptr = emp_ptr->next;
    }
}

void calcStateTax(struct employee *emp_ptr)
{
    while (emp_ptr != NULL)
    {
        if (strcmp(emp_ptr->taxState, "MA") == 0)
            emp_ptr->stateTax = emp_ptr->grossPay * MA_TAX_RATE;
        else if (strcmp(emp_ptr->taxState, "NH") == 0)
            emp_ptr->stateTax = emp_ptr->grossPay * NH_TAX_RATE;
        else if (strcmp(emp_ptr->taxState, "VT") == 0)
            emp_ptr->stateTax = emp_ptr->grossPay * VT_TAX_RATE;
        else if (strcmp(emp_ptr->taxState, "CA") == 0)
            emp_ptr->stateTax = emp_ptr->grossPay * CA_TAX_RATE;
        else
            emp_ptr->stateTax = emp_ptr->grossPay * DEFAULT_TAX_RATE;

        emp_ptr = emp_ptr->next;
    }
}

void calcFedTax(struct employee *emp_ptr)
{
    while (emp_ptr != NULL)
    {
        emp_ptr->fedTax = emp_ptr->grossPay * FED_TAX_RATE;
        emp_ptr = emp_ptr->next;
    }
}

void calcNetPay(struct employee *emp_ptr)
{
    while (emp_ptr != NULL)
    {
        emp_ptr->netPay = emp_ptr->grossPay - emp_ptr->stateTax - emp_ptr->fedTax;
        emp_ptr = emp_ptr->next;
    }
}

void calcEmployeeTotals(struct employee *emp_ptr,
                        struct totals *emp_totals_ptr)
{
    while (emp_ptr != NULL)
    {
        emp_totals_ptr->total_wageRate += emp_ptr->wageRate;
        emp_totals_ptr->total_hours += emp_ptr->hours;
        emp_totals_ptr->total_overtimeHrs += emp_ptr->overtimeHrs;
        emp_totals_ptr->total_grossPay += emp_ptr->grossPay;
        emp_totals_ptr->total_stateTax += emp_ptr->stateTax;
        emp_totals_ptr->total_fedTax += emp_ptr->fedTax;
        emp_totals_ptr->total_netPay += emp_ptr->netPay;
        emp_ptr = emp_ptr->next;
    }
}

void calcEmployeeMinMax(struct employee *emp_ptr,
                        struct min_max *emp_minMax_ptr)
{
    if (emp_ptr == NULL) return;

    emp_minMax_ptr->min_wageRate = emp_ptr->wageRate;
    emp_minMax_ptr->min_hours = emp_ptr->hours;
    emp_minMax_ptr->min_overtimeHrs = emp_ptr->overtimeHrs;
    emp_minMax_ptr->min_grossPay = emp_ptr->grossPay;
    emp_minMax_ptr->min_stateTax = emp_ptr->stateTax;
    emp_minMax_ptr->min_fedTax = emp_ptr->fedTax;
    emp_minMax_ptr->min_netPay = emp_ptr->netPay;

    emp_minMax_ptr->max_wageRate = emp_ptr->wageRate;
    emp_minMax_ptr->max_hours = emp_ptr->hours;
    emp_minMax_ptr->max_overtimeHrs = emp_ptr->overtimeHrs;
    emp_minMax_ptr->max_grossPay = emp_ptr->grossPay;
    emp_minMax_ptr->max_stateTax = emp_ptr->stateTax;
    emp_minMax_ptr->max_fedTax = emp_ptr->fedTax;
    emp_minMax_ptr->max_netPay = emp_ptr->netPay;

    emp_ptr = emp_ptr->next;

    while (emp_ptr != NULL)
    {
        if (emp_ptr->wageRate < emp_minMax_ptr->min_wageRate) emp_minMax_ptr->min_wageRate = emp_ptr->wageRate;
        if (emp_ptr->hours < emp_minMax_ptr->min_hours) emp_minMax_ptr->min_hours = emp_ptr->hours;
        if (emp_ptr->overtimeHrs < emp_minMax_ptr->min_overtimeHrs) emp_minMax_ptr->min_overtimeHrs = emp_ptr->overtimeHrs;
        if (emp_ptr->grossPay < emp_minMax_ptr->min_grossPay) emp_minMax_ptr->min_grossPay = emp_ptr->grossPay;
        if (emp_ptr->stateTax < emp_minMax_ptr->min_stateTax) emp_minMax_ptr->min_stateTax = emp_ptr->stateTax;
        if (emp_ptr->fedTax < emp_minMax_ptr->min_fedTax) emp_minMax_ptr->min_fedTax = emp_ptr->fedTax;
        if (emp_ptr->netPay < emp_minMax_ptr->min_netPay) emp_minMax_ptr->min_netPay = emp_ptr->netPay;

        if (emp_ptr->wageRate > emp_minMax_ptr->max_wageRate) emp_minMax_ptr->max_wageRate = emp_ptr->wageRate;
        if (emp_ptr->hours > emp_minMax_ptr->max_hours) emp_minMax_ptr->max_hours = emp_ptr->hours;
        if (emp_ptr->overtimeHrs > emp_minMax_ptr->max_overtimeHrs) emp_minMax_ptr->max_overtimeHrs = emp_ptr->overtimeHrs;
        if (emp_ptr->grossPay > emp_minMax_ptr->max_grossPay) emp_minMax_ptr->max_grossPay = emp_ptr->grossPay;
        if (emp_ptr->stateTax > emp_minMax_ptr->max_stateTax) emp_minMax_ptr->max_stateTax = emp_ptr->stateTax;
        if (emp_ptr->fedTax > emp_minMax_ptr->max_fedTax) emp_minMax_ptr->max_fedTax = emp_ptr->fedTax;
        if (emp_ptr->netPay > emp_minMax_ptr->max_netPay) emp_minMax_ptr->max_netPay = emp_ptr->netPay;

        emp_ptr = emp_ptr->next;
    }
}