//********************************************************
//
// Assignment 5 - Functions
//
// Name: Larson Klipic
//
// Class: C Programming, SUMMER 26
//
// Date: JUN 29th
//
// Description: Program which determines overtime and 
// gross pay for a set of employees with outputs sent 
// to standard output (the screen).
//
// Functions called by a combination of by value and by
// reference.
//
//********************************************************

#include <stdio.h>

// constants
#define SIZE 5
#define OVERTIME_RATE 1.5f
#define STD_WORK_WEEK 40.0f

// function prototypes
float getHours (long int clockNumber);
void printHeader (void);
void printEmp  (long int clockNumber[], float wageRate[], float hours[],
                float overtimeHrs[], float grossPay[]);
float OTwork (float hours);
float pay (float wageRate, float hours, float overtimeHrs);
// TODO:  Add other function prototypes here as needed

int main()
{

    // Variable Declarations

    long  int clockNumber[SIZE] = {98401,526488,765349,34645,127615}; // ID
    float grossPay[SIZE];     // gross pay
    float hours[SIZE];        // hours worked in a given week
    int   i;                  // loop and array index
    float overtimeHrs[SIZE];  // overtime hours
    float wageRate[SIZE] = {10.60,9.75,10.50,12.25,8.35}; // hourly wage rate

    // process each employee
    for (i = 0; i < SIZE; ++i)
    {

        // read in hours for the current employee
        hours[i] = getHours (clockNumber[i]); 

        // calculate overtime hours
        overtimeHrs[i] = OTwork (hours[i]);
        //  calculate gross pay 
        grossPay[i] = pay (wageRate[i],hours[i], overtimeHrs[i]);

    }

    // Print the header info
    printHeader();

    // Print all the employees - call by reference
    printEmp (clockNumber, wageRate, hours,
               overtimeHrs, grossPay);

    return (0);

}  // 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 employee information in a
// nice and orderly table format.
// 
// Parameters: 
//
//     clockNumber - Array of employee clock numbers
//     wageRate - Array of employee wages per hour
//     hours - Array of number of hours worked by an employee
//     overtimeHrs - Array of overtime hours for each employee
//     grossPay - Array of gross pay calculations for each employee
// 
// Returns: Nothing (call by reference)
//  
//**************************************************************

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

    int i; // loop index

    // access and print each employee
    for (i = 0; i < SIZE; ++i)
    {
        // TODO: add code to print out each employee one at a time
        printf("%06ld   %5.2f   %5.1f   %5.1f   %8.2f\n", clockNumber[i],
               wageRate[i], hours[i], overtimeHrs[i], grossPay[i]);
    }
} // printEmp

//**************************************************************
// Function: OTwork 
// 
// Purpose: calculate the overtime for an employee.
// 
// Parameters: hours - an array of time the employee worked
// 
// Returns: hrsWork - overtime hours
//  
//**************************************************************

float OTwork (float hours)
{
	float hrsWork; // hours worked
	
	// overtime
	if (hours > STD_WORK_WEEK )
	{
		hrsWork = hours - STD_WORK_WEEK;
	}
	else // no OT
	{
		hrsWork = 0.0;
	}

	return(hrsWork);
} // OTwork

//**************************************************************
// Function: pay 
// 
// Purpose: calculate grosspay for an employee.
// 
// Parameters: wageRate - hourly wage of a employee
//			   hours - time worked from a employee
//			   overtimeHrs - overtime hours of a empoyee
// 
// Returns: gross - calculated grosspay of the employee
//  
//**************************************************************

float pay (float wageRate, float hours, float overtimeHrs)
{
    float gross;       // gross pay
    float normalPay;   // pay without overtime
    float overtimePay; // only overtime pay
    
    // calculate gross with normal pay and overtime pay
    if (overtimeHrs > 0)
    {
        // overtime 
        normalPay = wageRate * STD_WORK_WEEK;
        overtimePay = overtimeHrs * (wageRate * OVERTIME_RATE);
        gross = normalPay + overtimePay;
    }
    else
    {
        // No overtime
        gross = hours * wageRate;
    }
    
    return (gross);
} // pay