//---------------------------------------------------------
// GrossPay6c.cpp
//
// Calculate and display the gross pay given the hourly
// wage and the number of hours worked.
//
// This version maintains the gross pay as a data member
// whose value is automatically updated whenever an
// employee's hours or wage is changed.
//
// D. Searls
// Asbury College
// Oct 2006
//---------------------------------------------------------

#include <string>
#include <iostream>
#include <iomanip>
#include <fstream>
using namespace std;

const int MAXSIZE = 100;

class employeeRecord
{
private:

// Data members

    string id;        // Employee identifier
    double hours;     // Hours worked
    double wage;      // Hourly wage
    double grossPay;  // Gross pay
    
// Gross pay function

    //-----------------------------------------------------
    // findGrossPay
    //
    // Calculates the gross pay.
    //-----------------------------------------------------
    void findGrossPay()
    {
        static const double MAXHOURS = 40.0;
        static double OT_MULTIPLIER = 1.5;
        
        if (hours <= MAXHOURS)
        {
            grossPay = hours * wage;
        }
        else
        {
            grossPay = MAXHOURS * wage
                       + (hours - MAXHOURS)
                         * OT_MULTIPLIER * wage;
        }
    }
  
public:

// Class constructors

    //-----------------------------------------------------
    // Default Constructor
    //
    // Construct a new employee whose identifier is the
    // empty string and whose hours and hourly wage are
    // both zero.
    //-----------------------------------------------------
    employeeRecord()
    {
        id = "";
        hours = 0.0;
        wage = 0.0;
        findGrossPay();
    }
    
    //-----------------------------------------------------
    // Initialization Constructor
    //
    // Preconditions: empHours >= 0
    //                empWage  >= 0
    //
    // Construct a new employee with the specified
    // identifier, hours, and hourly wage. If the specified
    // hours is negative, the employee's hours will be set
    // to zero. If the specified hourly wage is negative,
    // the employee's hourly wage will be set to zero.
    //
    // In Parameters: empId, empHours, empWage
    //-----------------------------------------------------
    employeeRecord(string empId, double empHours, double empWage)
    {
        id = empId;
        
        if (empHours >= 0.0)
        {
            hours = empHours;
        }
        else
        {
            hours = 0.0;
        }
        
        if (empWage >= 0.0)
        {
            wage = empWage;
        }
        else
        {
            wage = 0.0;
        }
        findGrossPay();
    }
    
    //-----------------------------------------------------
    // Copy Constructor
    //
    // Construct a new employee having the same state as
    // the specified employee.
    //
    // In Parameter: emp
    //-----------------------------------------------------
    employeeRecord(const employeeRecord& emp)
    {
        id = emp.id;
        hours = emp.hours;
        wage = emp.wage;
        grossPay = emp.grossPay;
    }

// Member functions

    //-----------------------------------------------------
    // setIdentifier
    //
    // Set the employee's identifier to the specifed value.
    //-----------------------------------------------------
    void setIdentifier(string newId)
    {
        id = newId;
    }
    
    //-----------------------------------------------------
    // setHours
    //
    // Precondition: newHours >= 0
    //
    // Set the employee's hours worked to the specifed
    // value. If the specified value is negative, the
    // employee's hours will not be changed.
    //-----------------------------------------------------
    void setHours(double newHours)
    {
        if (newHours >= 0.0)
        {
            hours = newHours;
            findGrossPay();
        }
    }
    
    //-----------------------------------------------------
    // setWage
    //
    // Precondition: newWage >= 0
    //
    // Set the employee's hourly wage to the specifed value.
    // If the specified value is negative, the employee's
    // wage will not be changed.
    //-----------------------------------------------------
    void setWage(double newWage)
    {
        if (newWage >= 0)
        {
            wage = newWage;
            findGrossPay();
        }
    }
    
    //-----------------------------------------------------
    // getIdentifier
    //
    // Get the employee's identifier.
    //-----------------------------------------------------
    string getIdentifier() const
    {
        return id;
    }

    //-----------------------------------------------------
    // getHours
    //
    // Get the employee's hours worked.
    //-----------------------------------------------------
    double getHours() const
    {
        return hours;
    }

    //-----------------------------------------------------
    // getWage
    //
    // Get the employee's hourly wage.
    //-----------------------------------------------------
    double getWage() const
    {
        return wage;
    }
    
    //-----------------------------------------------------
    // getGrossPay
    //
    // Get the employee's gross pay.
    //-----------------------------------------------------
    double getGrossPay() const
    {
        return grossPay;
    }      
};

//*********************************************************
// getEmployeeData
//
// Out Parameters: data, n
//
// Returns: void
//*********************************************************
void getEmployeeData(employeeRecord data[], int& n)
{
    ifstream infile;
    string identity;
    double wageRate;
    double hours;
    
    infile.open("EmployeeData.txt");
    n = 0;
    infile >> identity >> wageRate >> hours;
    while (!infile.fail() && n < MAXSIZE)
    {
        data[n].setIdentifier(identity);
        data[n].setHours(hours);
        data[n].setWage(wageRate);
        n = n+1;
        
        infile >> identity >> wageRate >> hours;
    }
    infile.close();
}

//*********************************************************
// displayGrossPay
//
// In Parameters: data, n
//
// Returns: void
//*********************************************************
void displayGrossPay(const employeeRecord data[], int n)
{
    cout << fixed << setprecision(2);
    cout << "Employee  Gross Pay" << endl;
    cout << "--------  ---------" << endl;
    for (int i = 0; i < n; i++)
    {
        cout << setw(8) << data[i].getIdentifier()
                << setw(11) << data[i].getGrossPay() << endl;
    }
}

//*********************************************************
//              M A I N   D R I V E R
//*********************************************************
int main()
{
    int n;              // Number of employees
    employeeRecord empData[MAXSIZE];

    getEmployeeData(empData, n);
    displayGrossPay(empData, n);
    
    return 0;
}