//********************************************************
//
// Assignment 6 - Structures
//
// Name: Alexander Aguilar
//
// Class: C Programming, Summer 2026 
//
// Date: 07/01/2026
//
// 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.
//
//********************************************************

// Define and Includes

#include <stdio.h>

// Define Constants
#define SIZE 5
#define STD_HOURS 40.0
#define OT_RATE 1.5

// 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 (struct employee employeeData [ ], int theSize);
void calcOT(struct employee employeeData [ ], int theSize);
void calcGrossPay(struct employee employeeData [ ], int theSize);
// TODO: Add your other function prototypes here

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

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

       // TODO: Add other function calls as needed to calculate overtime and gross
       calcOT (employeeData, SIZE);
       calcGrossPay (employeeData, SIZE);
       
            
    } // for

    // Print the column headers
         printHeader();

    // Function call to output results to the screen in table format.
    printEmp (employeeData, SIZE);

    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: Outputs to screen in a table format the following
// information about an employee: Clock, Wage,
// Hours, Overtime, and Gross Pay.
//
// Parameters:
//
//   employeeData - an array of structures containing
//   employee information
//   theSize - number of employees to process
//
// Returns: Nothing (void)
//
// *******************************************************************

void printEmp ( struct employee employeeData [], int theSize )
{
    int i; // loop index

    // print information about each employee
    for (i = 0; i < theSize ; ++i)
    {
        printf("\n %06li %5.2f %4.1f %4.1f %8.2f",
        employeeData[i].clockNumber, employeeData[i].wageRate, employeeData[i].hours,
        employeeData[i].overtimeHrs, employeeData[i].grossPay);
    } // for

} // printEmp

// TODO: Add your functions here

// ******************************************************************
// Function: calcOT
//
// Purpose: Calculates the overtime hours worked by subtracting the total hours
//			from STD_HOURS
// 
//
// Parameters:
//
//   employeeData - an array of structures containing
//   employee information
//   theSize - number of employees to process
//
// Returns: void 
//
// *******************************************************************
void calcOT (struct employee employeeData[], int theSize)
{
	
	int i; //loop index
	
	
	for(i = 0; i < theSize ; ++i)
	{
	
		if (employeeData[i].hours > STD_HOURS){
	
			employeeData[i].overtimeHrs = employeeData[i].hours - STD_HOURS;
			
	
		}//if
	
		else{
			
			employeeData[i].overtimeHrs = 0; 
			
		}//else
		
	}//for
	
	
	
}// calcOT


// ******************************************************************
// Function: calcGrossPay
//
// Purpose: Calculates the employees gross pay by multiplying wage rate and 
//			and hours worked. 
// 
//
// Parameters:
//
//   employeeData - an array of structures containing
//   employee information
//   theSize - number of employees to process
//
// Returns: void
// *******************************************************************


void calcGrossPay( struct employee employeeData[], int theSize)
{
	
	int i; //loop index
	
	for(i = 0; i < theSize; ++i)
	{
		
		employeeData[i].grossPay = employeeData[i].hours * employeeData[i].wageRate
		+ employeeData[i].overtimeHrs * OT_RATE;
		
	}//For loop
	
	
}//calcGrossPay