//********************************************************
//
// Assignment 6 - Structures
//
// Name: Matt Smith
//
// Class: C Programming, Spring 2025
//
// Date: 
//
// Description: Program which determines overtime and 
// gross pay for a set of employees with outputs sent 
// to standard output (the screen).
//
// Call by Value design
//
//********************************************************

// Define and Includes

#include <stdio.h>

// Define Constants
#define SIZE 5
#define STD_HOURS 40.0
#define OT_RATE 1.5
#define OVERTIME_RATE 1.5f
#define STD_WORK_WEEK 40.0f

// Define a global structure to pass employee data between functions
// Note that the structure type is global, but you don't want a variable
// of that type to be global. Best to declare a variable of that type
// in a function like main or another function and pass as needed.

struct employee
{
    long int clockNumber;
    float wageRate;
    float hours;
    float overtimeHrs;
    float grossPay;
};

// define prototypes here for each function except main
float getHours (long int clockNumber);
void printHeader (void);
void printEmp (long int clockNumber, float wageRate, float hours,
               float overtimeHrs, float grossPay);

// TODO: Add your other function prototypes here
float calcOvertimeHrs (float hoursWorked, float stdWorkWeek);
float calcGrossPay (float normalPay, float overtimeHours, float wageRate, float OTRate, 
                    float stdWorkWeek);

int main ()
{
    // Set up a local variable to store the employee information
    struct employee employeeData[SIZE] = {
        { 98401, 10.60 },
        { 526488, 9.75 },
        { 765349, 10.50 }, // initialize clock and wage values
        { 34645, 12.25 },
        { 127615, 8.35 }
    };

    int i;  // loop and array index

    float overtimeHrs[SIZE];  // overtime hours
    float hours[SIZE];        // hours worked in a given week
    float grossPay[SIZE];     // gross pay
    float wageRate[SIZE] = {10.60,9.75,10.50,12.25,8.35}; // hourly wage rate

    // Call functions as needed to read and calculate information
    for (i = 0; i < SIZE; ++i) 
    { 

       // Prompt for the number of hours worked by the employee
       employeeData[i].hours = getHours (employeeData[i].clockNumber); 

       // Function call to calculate overtime hours
        // Calculates number of hours, not overtime pay
        employeeData[i].overtimeHrs = calcOvertimeHrs(employeeData[i].hours, STD_WORK_WEEK);

        // Function call to calculate gross pay
        // (float normalPay, float overtimeHours, float wageRate, float OTRate)
        employeeData[i].grossPay = calcGrossPay (employeeData[i].hours, employeeData[i].overtimeHrs, employeeData[i].wageRate, OVERTIME_RATE, STD_WORK_WEEK);
            
    } // for

    // Print the column headers
    printHeader();

    // print out each employee
    for (i = 0; i < SIZE; ++i) 
    { 
        printEmp (employeeData[i].clockNumber, 
                  employeeData[i].wageRate, 
                  employeeData[i].hours,
                  employeeData[i].overtimeHrs, 
                  employeeData[i].grossPay);
    }

    return(0); // success

} // main

//**************************************************************
// Function: getHours 
// 
// Purpose: Obtains input from user, the number of hours worked 
// per employee and stores the result in a local variable 
// that is passed back to the calling function. 
// 
// Parameters: clockNumber - The unique employee ID
// 
// Returns: hoursWorked - hours worked in a given week
//  
//**************************************************************

float getHours (long int clockNumber) 
{ 

    float hoursWorked; // hours worked in a given week

    // Read in hours for employee
    printf("\nEnter hours worked by emp # %06li: ", clockNumber); 
    scanf ("%f", &hoursWorked); 

    // return hours back to the calling function
    return (hoursWorked);
 
} // getHours

//**************************************************************
// 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("\nClock# Wage  Hours  OT      Gross\n");
    printf("------------------------------------------------\n");

} // printHeader

//************************************************************* 
// Function: printEmp 
// 
// Purpose: Prints out all the information for an employee
// in a nice and orderly table format.
// 
// Parameters: 
//
//     clockNumber - unique employee ID
//     wageRate - hourly wage rate
//     hours - Hours worked for the week
//     overtimeHrs - overtime hours worked in a week
//     grossPay - gross pay for the week
// 
// Returns: void
//  
//**************************************************************

void printEmp (long int clockNumber, float wageRate, float hours,
                float overtimeHrs, float grossPay)
{

    // Print out a single employee
    printf("\n %06li %5.2f %4.1f %4.1f %8.2f",
          clockNumber, wageRate, hours,
          overtimeHrs, grossPay);

}  // printEmp

//**************************************************************
// Function: calcOvertimeHrs
// 
// Purpose: Calculates overtime hours for an employee. This returns
//          the amount of hours, not the pay.
// 
// Parameters: 
//      hoursWorked - number of hours worked by employee
//      stdWorkWeek - hours in a normal workweek
// 
// Returns: float total hours of overtime worked
//  
//**************************************************************
float calcOvertimeHrs (float hoursWorked, float stdWorkWeek) {
    // return calculation without writing a variable
    // if more than the standard workweek, return the hours
    // if less, then just return zero

    if (hoursWorked > stdWorkWeek){
        return (hoursWorked - stdWorkWeek);
    }

    else {
        return (0);
    }
}

//**************************************************************
// Function: calcGrossPay
// 
// Purpose: calculates gross pay for an employee
// 
// Parameters:
//      normalHours - hours worked in a workweek
//      overtimeHours - the hours over the normal hours worked
//      wageRate - the normal hourly rate
//      OTRate - the overtime hourly rate
//      stdWorkWeek - amount of hours in a normal workweek
// 
// Returns: float - gross pay amount 
//  
//**************************************************************
float calcGrossPay (float normalHours, float overtimeHours, float wageRate, 
                    float OTRate, float stdWorkWeek) {
    if (normalHours > stdWorkWeek) {
        return ((stdWorkWeek * wageRate) + (overtimeHours * wageRate * OTRate));
    }
    else {
        return (normalHours * wageRate);
    }
}