5ntak / ios-bank-manager-app Goto Github PK

import Foundation

class BankManager {
    func openBank() {
        let bankOpenMenuState: Bool = bankOpenMenu()
        var customers: [Customer] = visitCustomers()
        
        if bankOpenMenuState {
            bankWorkProgress(customers: &customers)
            
            openBank()
        }
    }
    private func bankOpenMenu() -> Bool {
        
        while true {
            print("1 : 은행개점")
            print("2 : 종료")
            print("입력 : ", terminator : "")
            
            guard let inputNumber = readLine() else {
                return false
            }
            
            if inputNumber == "1" {
                return true
            } else if inputNumber == "2" {
                return false
            } else {
                print("잘못된 입력입니다, 다시 입력해주세요.")
            }
        }
    }
   
    private func bankWorkProgress(customers: inout [Customer]) {
        let TotalCustomersCount: Int = countCustomers(customers: customers)
        
        while true {
            let remainingCustomer: Int = countCustomers(customers: customers)
        
            if remainingCustomer == 0 {
                finishBank(todayTotalVisitCustomers: TotalCustomersCount)
                break
            } else {
                let customer: Int = matchBankerAndCustomer(customers: &customers)
                bankerWorkProgress(customerNumber: customer)
            }
        }
    }
    
    private func bankerWorkProgress(customerNumber: Int) {
        print("\(customerNumber)번 고객 업무 시작")
        usleep(700000)
        print("\(customerNumber)번 고객 업무 완료")
    }

    private func finishBank(todayTotalVisitCustomers: Int) {
        var workTime = Double(todayTotalVisitCustomers) * 0.7
        workTime = round(workTime * 100) / 100
        print("업무가 마감되었습니다. 오늘 업무를 처리한 고객은 총 \(todayTotalVisitCustomers)명이며, 총 업무 시간은 \(workTime)초 입니다.")
    }
    
    private func visitCustomers() -> [Customer] {
        var result: [Customer] = []
        let waitNumbers: [Int] = Array(1...Int.random(in: 10...30))

        for number in waitNumbers {
            let customer: Customer = Customer(waitNumber: number)
            result.append(customer)
        }

        return result
    }
    
    private func matchBankerAndCustomer(customers: inout [Customer]) -> Int {
        let customer: Customer = customers.removeFirst()
        
        return customer.waitNumber
    }
    
    private func countCustomers(customers: [Customer]) -> Int {
        return customers.count
    }
}

// Customer.swift

import Foundation

final class Customer {
    let waitNumber: Int
    
    init(waitNumber: Int) {
        self.waitNumber = waitNumber
    }
    
}

import Foundation

final class BankManager {
    private var customers: [Customer] = []
    private var banker: Banker = Banker()
    private let operationQueue = OperationQueue()
    
    func openBank() {
        let bankOpenMenuState: Bool = bankOpenMenu()
        
        if bankOpenMenuState {
            visitCustomers()
            bankWorkProgress()
            openBank()
        }
    }
    
    private func bankOpenMenu() -> Bool {
        
        while true {
            print("1 : 은행개점")
            print("2 : 종료")
            print("입력 : ", terminator : "")
            
            guard let inputNumber = readLine() else {
                return false
            }
            
            if inputNumber == "1" {
                return true
            } else if inputNumber == "2" {
                return false
            } else {
                print("잘못된 입력입니다, 다시 입력해주세요.")
            }
        }
    }
    
    private func bankWorkProgress() {
        let totalCustomersCount: Int = self.customers.count
        
        let bankerTak = BlockOperation {
            self.banker.bankerWorkProgress(customers: &self.customers)
        }
        let bankerWody = BlockOperation {
            self.banker.bankerWorkProgress(customers: &self.customers)
        }
        let bankerDelma = BlockOperation {
            self.banker.bankerWorkProgress(customers: &self.customers)
        }
        
        operationQueue.addOperations([bankerTak, bankerWody, bankerDelma], waitUntilFinished: true)
        
        if self.customers.count == 0 {
            self.finishBank(totalCustomerCount: totalCustomersCount, bankersWorkTime: self.banker.workTime)
        }
    }
    
    private func finishBank(totalCustomerCount: Int, bankersWorkTime: Double) {
        let workTime: Double = round(bankersWorkTime * 100) / 100
        
        print("업무가 마감되었습니다. 오늘 업무를 처리한 고객은 총 \(totalCustomerCount)명이며, 총 업무 시간은 \(workTime)초 입니다.")
        
        self.banker.workTime = 0
    }
    
    private func visitCustomers() {
        let waitNumbers: [Int] = Array(1...Int.random(in: 10...30))
        
        for number in waitNumbers {
            guard let tier = Tier.allCases.randomElement() else {
                return
            }
            guard let business = Business.allCases.randomElement() else {
                return
            }
            
            let customer: Customer = Customer(waitNumber: number, tier: tier, business: business)
            
            self.customers.append(customer)
        }
        
        self.customers.sort(by: {$0.tier.rawValue < $1.tier.rawValue})
    }
    
}

final class Banker {
    var workTime: Double = 0
    let semaphore = DispatchSemaphore(value: 1)

    func bankerWorkProgress(customers: inout [Customer]) {
        while customers.count > 0 {
            semaphore.wait()
            let customer: Customer = customers.removeFirst()
            semaphore.signal()
            
            print("🟢\(customer.waitNumber)번 \(customer.tier.tierName)고객 \(customer.business.rawValue)업무 시작")
            
            switch customer.business {
            case .deposit:
                usleep(700000)
                self.workTime += 0.7
            default:
                usleep(1100000)
                self.workTime += 1.1
            }
            
            print("🔵\(customer.waitNumber)번 \(customer.tier.tierName)고객 \(customer.business.rawValue)업무 완료")
        }
    }

}

class Customer {
    private let _waitNumber: Int
    private let _tier: Tier
    private let _business: Business
    
    var waitNumber: Int { return _waitNumber }
    var tier: Tier { return _tier }
    var business: Business { return _business }
    
    init(waitNumber: Int, tier: Tier, business: Business) {
        self._waitNumber = waitNumber
        self._tier = tier
        self._business = business
    }
}

enum Tier: Int, CaseIterable {
    case vvip = 0
    case vip = 1
    case normal = 2
}

enum Business: String, CaseIterable {
    case deposit = "예금"
    case loan = "대출"
}

extension Tier {
    var tierName: String {
        switch self {
        case .vvip:
            return "vvip"
        case .vip:
            return "vip"
        default:
            return "일반"
        }
    }
}

let BankManagerConsole = BankManager()
BankManagerConsole.openBank()