AllCombine.swift

enum Department: String {
    case hr = "HR"
    case sales = "SALES"
    case service = "SERVICE"
}

enum Percentage: Float {
    case three = 3
    case four = 4
    case five = 5
}

struct Employee {
    let id: Int
    let name: String
    let department: Department
    var salary: Float
    
    mutating func increaseSalary(byPercent percent: Float) {
        salary = salary + (salary * percent/100)
    }
}
struct EmployeeAddress {
    let id: Int
    let address: String
}


struct Mailer: CustomStringConvertible {
    let name: String
    let department: String
    let address: String
    let salary: Float
    let message: String
    
    var description: String {
        return "\(name) [\(department)] \(address). \(message) \(salary)\n"
    }
}

let emp1 = Employee(id: 1, name: "John", department: .hr, salary: 5000)
let emp2 = Employee(id: 2, name: "Max", department: .hr, salary: 5600)
let emp3 = Employee(id: 3, name: "Siena", department: .sales, salary: 7000)
let emp4 = Employee(id: 4, name: "Peter", department: .service, salary: 4800)
let emp5 = Employee(id: 5, name: "Sun", department: .sales, salary: 6500)


let add1 = EmployeeAddress(id: 1, address: "Address 1")
let add2 = EmployeeAddress(id: 2, address: "Address 2")
let add3 = EmployeeAddress(id: 3, address: "Address 3")
let add4 = EmployeeAddress(id: 4, address: "Address 4")
let add5 = EmployeeAddress(id: 5, address: "Address 5")
let returnAddress = EmployeeAddress(id: 5, address: "Return Address")

func address(forEmployeeId id: Int ) -> EmployeeAddress {
    switch id {
    case id where id == 1:
        return add1
    case id where id == 2:
        return add2
    case id where id == 3:
        return add3
    case id where id == 4:
        return add4
    case id where id == 5:
        return add5
    default:
        return returnAddress
    }
}

func fetchEmployees(withCallback callback: ([Employee]) -> Void) {
    callback([emp1, emp2, emp3, emp4, emp5])
}

func fetchEmployees() -> AnyPublisher<[Employee], Never> {
    return Just([emp1, emp2, emp3, emp4, emp5])
        .eraseToAnyPublisher()
}

func applyRaise(toEmployees employees: [Employee], withCallback callback: ([Employee]) -> Void) {
    // loop through the employees and apply a salary raise based in the department
    // then callback using the array of Employee
    let newEmployees = employees.map { employee -> Employee in
        var newEmployee = employee
        switch employee.department {
        case .sales:
            newEmployee.increaseSalary(byPercent: Percentage.five.rawValue)
        case .hr:
            newEmployee.increaseSalary(byPercent: Percentage.four.rawValue)
        case .service:
            newEmployee.increaseSalary(byPercent: Percentage.three.rawValue)
        }
        return newEmployee
    }
    callback(newEmployees)
}

func applyRaise(toEmployees employees: [Employee]) -> AnyPublisher<[Employee], Never> {
    // loop through the employees and apply a salary raise based in the department &
    // return a publisher
    return Just(employees.map { employee -> Employee in
        var newEmployee = employee
        switch employee.department {
        case .sales:
            newEmployee.increaseSalary(byPercent: Percentage.five.rawValue)
        case .hr:
            newEmployee.increaseSalary(byPercent: Percentage.four.rawValue)
        case .service:
            newEmployee.increaseSalary(byPercent: Percentage.three.rawValue)
        }
        return newEmployee
    })
    .eraseToAnyPublisher()
}

func generateMailer(forEmployees employees: [Employee], callback: ([Mailer]) -> Void) {
    let newEmployees = employees.map { employee -> Mailer in
        let address = address(forEmployeeId: employee.id)
        let mailer = Mailer(name: employee.name, department: employee.department.rawValue, address: address.address, salary: employee.salary, message: "Congratulations")
        return mailer
    }
    callback(newEmployees)
}

func generateMailer(forEmployees employees: [Employee]) -> AnyPublisher<[Mailer], Never> {
    Just(employees.map { employee -> Mailer in
        let address = address(forEmployeeId: employee.id)
        let mailer = Mailer(name: employee.name, department: employee.department.rawValue, address: address.address, salary: employee.salary, message: "Congratulations")
        return mailer
    })
    .eraseToAnyPublisher()
}

/*
 * Callback approach (needs nesting of callbacks)
 */
fetchEmployees { employees in
    applyRaise(toEmployees: employees) { employees in
        generateMailer(forEmployees: employees) { mailer in
            print(mailer.debugDescription)
        }
    }
}

/*
 * Combine "pipeline"
 */

var cancellables = Set<AnyCancellable>()

fetchEmployees()
    .flatMap(applyRaise)
    .flatMap(generateMailer)
    .sink(
        receiveValue: { mailer in
            print(mailer.debugDescription)
        }
    )
    .store(in: &cancellables)