# employee.py
# Walker M. White (wmw2)
# November 1, 2013
"""Module with two classes to show off inheritance

This version of employee does not use properties"""

class Employee(object):
    """Instance is an employee with a salary.
    
    INSTANCE ATTRIBUTES:
        _name:   Employee's name [string, not empty]
        _start:  Year hired      [int > 1970; -1 if undefined]
        _salary: Salary          [int or float >= 0]
    """
    
    # GETTERS/SETTERS
    def getName(self):
        """Return: the employee's name."""
        return self._name
    
    def setName(self,value):
        """Changes the employee's name to value
        
        Precondition: value is a nonempty string"""
        assert type(value) == str and value != '', `value`+' is an invalid name'
        self._name = value 

    def getStart(self):
        """Return: the year hired."""
        return self._start
    
    def setStart(self,value):
        """Changes year hired to value.
        
        Precondition: valus is an int > 1970, or -1 if undefined."""
        assert type(value) == int, `value`+' is not an int'
        assert value > 1970 or value == -1, `value`+' is an invalid start date'
        self._start = value 

    def getSalary(self):
        """Return: annual salary"""
        return self._salary
    
    def setSalary(self,value):
        """Changes annual salary to value.
        
        Precondition: value is a number (int or float) >= 0."""
        assert type(value) == int or type(value) == float, `value`+' is not a number'
        assert value >= 0, `value`+' is negative'
        self._salary = value 

    def getCompensation(self):
        """Return: annual compensation (will be overridden)."""
        return self._salary

    # INITIALIZER
    def __init__(self, n, d=-1, s=50000.0):
        """Initializer: Makes an Employee with name n, year hired d, salary s 

        Preconditions: n is a nonempty string
                       d is an int > 1970 or -1 if undefined (default)
                       s is an int or float >= 0 (50000.0 default)
        """
        # LET THE SETTERS ENFORCE THE PRECONDITIONS
        self.setName(n)
        self.setStart(d) 
        self.setSalary(s)
 
    # OPERATIONS
    def __str__(self):
        """Return: String representation of this Employee"""
        return self._name + ', year ' + str(self._start) + ', salary ' + str(self._salary) 
    
    def __eq__(self,other):
        """Return: True if e an Employee, with the same attributes as self.
        False otherwise."""
        # Check if this is an Employee
        if not isinstance(other,Employee): # WILL DISCUSS NEXT LECTURE
            return False
        
        return (self._name == other._name and
                self._start == other._start and
                self._salary == other._salary)

    def __ne__(self,other):
        """Return: False if e an Employee, with the same attributes as self.
        True otherwise."""
        return not self == other


# SUBCLASS
class Executive(Employee):
    """An instance is an Employee with a bonus.
    
    INSTANCE ATTRIBUTES:
        _bonus: annual bonus [float >= 0]
    """

    # GETTERS/SETTERS
    def getBonus(self):
        """Return: bonus salary."""
        return self._bonus
    
    def setBonus(self,value):
        """Change bonus salary to value
        
        Precondition: value is a number (int or float) >= 0."""
        assert type(value) == int or type(value) == float, `value`+' is not a number'
        assert value >= 0, `value`+' is negative'
        self._bonus = value
    
    def getCompensation(self):
        """Return: annual compensation (includes bonus)."""
        return self._salary+self._bonus

    # INITIALIZER    
    def __init__(self, n, d, b=0.0):
        """Initializer: Make an Executive w/ name n, year hired d, and bonus b
        
        The default salary of an executive is 50k
        
        Preconditions: n is a nonempty string
                       d is an int > 1970 or -1 if undefined (default)
                       b is an int or float >= 0 (0.0 default)
        """
        # Asserts precondition for n and d
        Employee.__init__(self,n,d)
        self.setBonus(b)

    # OPERATIONS
    def __str__(self):
        """Return: a string representation of this Executive"""
        # Add on to the string representation of the base class.
        return Employee.__str__(self) + ', bonus ' + str(self._bonus)

    def __eq__(self,other):
        """Return: True if e an Executive, with the same attributes as self.
        False otherwise."""
        # Check if this is an Executive
        if not isinstance(other,Executive): # WILL DISCUSS NEXT LECTURE
            return False
        
        # Use previous __eq__ as helper
        return Employee.__eq__(self,other) and self._bonus == other._bonus