Blog

import UIKit

@IBDesignable
final class InputView: UIView {
    @IBOutlet weak var titleLabel: UILabel!
    @IBOutlet weak var inputTextField: UITextField!
    @IBOutlet weak var tipStepper: UIStepper!

    override func prepareForInterfaceBuilder() {
        super.prepareForInterfaceBuilder()
    }

//It called when you are using the xib for creating it.
    required init?(coder: NSCoder) {
        super.init(coder: coder)
        setupView()
    }

//It called when you create view programmatically.
    override init(frame: CGRect) {
        super.init(frame: frame)
        setupView()
    }

    private func setupView() {
        guard let nib = loadNib() else {
            return
        }
        nib.translatesAutoresizingMaskIntoConstraints = false
        addSubview(nib)
        NSLayoutConstraint.activate([
            nib.leadingAnchor.constraint(equalTo: self.leadingAnchor),
            nib.trailingAnchor.constraint(equalTo: self.trailingAnchor),
            nib.topAnchor.constraint(equalTo: self.topAnchor),
            nib.bottomAnchor.constraint(equalTo: self.bottomAnchor)
        ])
    }

    private func loadNib() -> UIView? {
        let bundle = Bundle(for: Self.self)
        return bundle.loadNibNamed(String(describing: Self.self), owner: self, options: nil)?.first as? UIView
    }

    @IBAction func didUpdateStepper(_ sender: UIStepper) {
        inputTextField.becomeFirstResponder()
        inputFormatter?.updateTipValue(inputTextField, value: sender.value)
    }
}

@IBInspectable var title: String? = nil {
        didSet {
            titleLabel.text = title
        }
    }

    @IBInspectable var placeHolder: String? = nil {
        didSet {
            inputTextField.placeholder = placeHolder
        }
    }

    @IBInspectable var editable: Bool = true {
        didSet {
            inputTextField.isEnabled = editable
        }
    }

    @IBInspectable var tipInput: Bool = false {
        didSet {
            if tipInput {
                tipStepper.isHidden = false
            }
        }
    }

class InputFormatter: NSObject {
    enum InputType {
        case tip
        case bill
    }

    private var inputType: InputType = .bill

    private lazy var formatter: NumberFormatter = {
        let formatter = NumberFormatter()
        formatter.maximumFractionDigits = 0
        if self.inputType == .bill {
            formatter.numberStyle = .currency
            formatter.currencyCode = Locale(identifier: "en-US").currencyCode
        }
        else if self.inputType == .tip {
            formatter.numberStyle = .percent
            formatter.multiplier = 1
        }
        return formatter
    }()

    override init() {
        super.init()
    }

    convenience init(type: InputType) {
        self.init()
        inputType = type
    }

    private func setupKeyboardType(_ textField: UITextField) {
        textField.keyboardType = .numberPad
    }
}

extension InputFormatter: UITextFieldDelegate {    
    func textFieldShouldBeginEditing(_ textField: UITextField) -> Bool {
        if textField.keyboardType == .default {
            setupKeyboardType(textField)
        }
        return true
    }

    func textField(
        _ textField: UITextField,
        shouldChangeCharactersIn range: NSRange,
        replacementString string: String
    ) -> Bool {
        guard let text = textField.text else {
            return true
        }
        if let formattedString = convertFormattedString(text, replacementString: string) {
            textField.text = formattedString
        }
        return false
    }
}
}

func textField(
        _ textField: UITextField,
        shouldChangeCharactersIn range: NSRange,
        replacementString string: String
    ) -> Bool

class ViewController: UIViewController {    
    @IBOutlet weak var resultStackView: UIStackView!
    @IBOutlet weak var resultTitleLabel: UILabel!
    @IBOutlet weak var tipResultView: InputView!
    @IBOutlet weak var totalResultView: InputView!

    @IBOutlet weak var inputStackView: UIStackView!
    @IBOutlet weak var inputTitleLabel: UILabel!
    @IBOutlet weak var billInputView: InputView!
    @IBOutlet weak var tipInputView: InputView!

    override func viewDidLoad() {
        super.viewDidLoad()
        resultStackView.setCustomSpacing(40, after: resultTitleLabel)
        inputStackView.setCustomSpacing(40, after: inputTitleLabel)
        billInputView.delegate = InputFormatter(type: .bill)
        tipInputView.delegate = InputFormatter(type: .tip)
    }
}

protocol InputFormatterDelegate: AnyObject {
    func didUpdateInput(_ type: InputFormatter.InputType, number: NSNumber)
}

class InputFormatter: NSObject {
    private weak var delegate: InputFormatterDelegate?

}

protocol AmountPresentable {
    var billValue: NSNumber { get }
    var tipValue: NSNumber { get }
    var tipPercentage: NSNumber { get }
    var formatter: NumberFormatter { get }

    func updateTipAmount(assign to: InputView)
    func updateTotalAmount(assign to: InputView)
    func updateStepperValue(assign to: InputView)
}

extension AmountPresentable {
    func updateTipAmount(assign to: InputView) {
        let tipAmount = formatter.string(from: self.tipValue)
        to.inputTextField.text = tipAmount
    }

    func updateStepperValue(assign to: InputView) {
        to.tipStepper.value = tipPercentage.doubleValue
    }

    func updateTotalAmount(assign to: InputView) {
        let totalValue = billValue.doubleValue + tipValue.doubleValue
        let totalAmount = formatter.string(from: NSNumber(value: totalValue))
        to.inputTextField.text = totalAmount
    }
}

class ViewController: UIViewController, AmountPresentable {
    var billValue: NSNumber = 0
    var tipValue: NSNumber = 0
    var tipPercentage: NSNumber = 0
    //…

    override func viewDidLoad() {
        super.viewDidLoad()
    //…
        billInputView.delegate = InputFormatter(type: .bill, delegate: self)
        tipInputView.delegate = InputFormatter(type: .tip, delegate: self)
    }
}

extension ViewController: InputFormatterDelegate {
    func didUpdateInput(_ type: InputFormatter.InputType, number: NSNumber) {
        if type == .tip {
            tipValue = NSNumber(value: billValue.doubleValue * (number.doubleValue * 0.01))
            tipPercentage = number
        }
        else if type == .bill {
            billValue = number
            tipValue = NSNumber(value: billValue.doubleValue * (tipPercentage.doubleValue * 0.01))
        }
        updateTipAmount(assign: tipResultView)
        updateTotalAmount(assign: totalResultView)
        updateStepperValue(assign: tipInputView)
    }
}