Build a vending machine app...wth am I watching

class Employee
{
    let name: String

    init(name: String)
    {
        self.name = name
    }
}

class HourlyEmployee: Employee
{
    let hourlyWage: Double

    init(name: String, hourlyWage: Double)
    {
        self.hourlyWage = hourlyWage
        super.init(name: name)
    }

    func payWages(for hours: Double) -> Double
    {
        return hourlyWage * hours
    }
}

class SalariedEmployee: Employee
{
    let salary: Double

    init(name: String, salary: Double)
    {
        self.salary = salary
        super.init(name: name)
    }

    func paySalary() -> Double
    {
        return salary/24
    }
}

let hourlyEmployee = HourlyEmployee(name: "Taylor", hourlyWage: 12.00)
let salariedEmployee = SalariedEmployee(name: "Lorenzo", salary: 62000)

let employees = [hourlyEmployee, salariedEmployee]
// We know from learning about arrays that Swift arrays can only contain a single type; however, ypu can mix types in an array if all the array items have a common base type. When we mix and match them in the array, Swift converts or cast each object to the base type, to satisfy the array homogeneity rule.

for employee in employees // currently this will not work to access object methods (unless there are base/super class methods)
{
}

/*
 To actually use this instance in the right context, we can either check that it is the right type that we need or downcast them to a different type--there are two operators to help accomplish this task.

 The 'is' operator returns true if the type matches a type we specify and false if not. Thus, we can use it to inspect each item the array.
 */

for employee in employees // currently this will not work to access object methods (unless there are base/super class methods)
{
    if employee is HourlyEmployee
    {
        print("Hourly")
    }

    if employee is SalariedEmployee
    {
        print("Salaried")
    }
}

/*
 Even though the employee array thinks that its items are of the base classes type, we can check each array item to see if they are instances of a particular sub class (i.e. using the 'is' operator inside the for loop's if statements to check each item in the local constant of the if statement to see if items inherit from Hourhly Employee and from SalariedEmployee). Now we don't want to get into the details of how this is done exactly in the background, but just know that even though that each item in the array are of the employee base class, each array item also contains information on any subclasses they inherit from. But all this allows us to do is check it right (i.e. using the 'is' operator to check.)? We still can't call the payWages function on the hourlyEmployee instance or paySalary on the salariedEmployee instance using just the 'is' operator since both are inside the same array that's contrained to the base class of those instances.

 What if we want to actually work with the specific subtypes? For that, we have another operator, the Typecast operator, 'as'. The Employee class, in this example, is a higher less specific type than than any of the subclasses (i.e. the HourlyEmployee and the SalariedEmployee subclasses.). The 'as' operator allows you to cast to one of the more specific subclasses in a process know as 'downcasting'. It's called downcasting because if you think of the object graph as a tree, the base type on top, and more specific types as nodes extending downwards, then when going from a base, to a subclass we go down the tree.

 Downcasting may not always succeed. So the typecast operator comes in two different flavors, the conditional form as with a question mark, and the forced form, as with an exclamation point. The forced form, like the force unwrap operator, should only be used when you know the downcast will succeed.

 For example, in our code, we verified that an employee instance is of a particular type by using the type check operator (i.e. the 'is' operator). We know that the local constant of the if statement named 'employee' here is an instance of the HourlyEmployee subclass for sure. So inside the if statement, we can use the Forced operator to downcast the instance.
 */

for employee in employees // now this works
{
    if employee is HourlyEmployee
    {
        print("Hourly")
        let hourlyEmployee = employee as! HourlyEmployee
        hourlyEmployee.payWages(for: 10.00)
    }

    if employee is SalariedEmployee
    {
        print("Salaried")
        let salariedEmployee = employee as! SalariedEmployee
    }
}

/*
 The Forced Downcast operater, like the Forced Unwrap operator, should be treated carefully. Only used the Forect Downcast operator ony if you're 110% sure the downcast will succeed, otherwise your application will crash.

 For a safer option, you can use the Conditional Typecast operator as with a question mark. This operator returns an optional value if the cast succeeds or nil if it fails.
 */

for employee in employees // now this works
{
    if employee is HourlyEmployee
    {
        print("Hourly")
        let hourlyEmployee = employee as? HourlyEmployee // using Conditional Typecast operator along with...
        hourlyEmployee?.payWages(for: 10.00) // ...optional chaining

    }

    if employee is SalariedEmployee
    {
        print("Salaried")
        let salariedEmployee = employee as? SalariedEmployee // using Conditional Typecast operator along with...
        salariedEmployee?.paySalary() // ...optional chaining
    }
}




for employee in employees // now this works
{
    if employee is HourlyEmployee
    {
        print("Hourly")
        if let hourlyEmployee = employee as? HourlyEmployee // using if let along with the Conditional Typecast operator
        {
            hourlyEmployee.payWages(for: 10.00)
        }

    }

    if employee is SalariedEmployee
    {
        print("Salaried")
        if let salariedEmployee = employee as? SalariedEmployee  // using if let along with the Conditional Typecast operator
        {
            salariedEmployee.paySalary()
        }
    }
}