do {
    let car = Car()
    car.accept(Driver())
    car.accept(Printer())

    let engine = Engine()
    engine.accept(Printer())
}

protocol Visitor
{
    func visit(engine: Engine)
    func visit(body: Body)
    func visit(wheel: Wheel)
    func visit(car: Car)
}

extension Visitor {
    func visit(car: Car)
    {

    }
}

class Driver: Visitor
{
    func visit(engine: Engine)
    {
        print("start engine")
    }

    func visit(body: Body)
    {
        print("move body")
    }

    func visit(wheel: Wheel)
    {
        print("kick wheel")
    }
}

class Printer: Visitor
{
    func visit(engine: Engine)
    {
        print("print engine")
    }

    func visit(body: Body)
    {
        print("print body")
    }

    func visit(wheel: Wheel)
    {
        print("print wheel")
    }
}

protocol Element
{
    func accept(_ visitor: Visitor)
}

class Engine: Element
{
    func accept(_ visitor: Visitor)
    {
        visitor.visit(engine: self)

    }
}

class Body: Element
{
    func accept(_ visitor: Visitor)
    {
        visitor.visit(body: self)
    }
}

class Wheel: Element
{
    func accept(_ visitor: Visitor)
    {
        visitor.visit(wheel: self)
    }
}

class Car: Element
{
    private var elements: [Element] = []

    init()
    {
        self.elements = [
            Engine(),
            Wheel(),
            Body(),
        ]
    }

    func accept(_ visitor: Visitor)
    {
        for elt in elements {
            elt.accept(visitor)
        }
        visitor.visit(car: self)
    }
}

do {
    let sedan = Sedan(Simple())
    sedan.applyBrake()

    let sedan2 = Sedan(ABS())
    sedan2.applyBrake()
}

protocol Brake
{
    func brake()
}

class Simple: Brake
{
    func brake()
    {
        print("simple brake applied")
    }
}

class ABS: Brake
{
    func brake()
    {
        print("brake with ABS applied")
    }
}

protocol Car
{
    var brake: Brake { get }
    func applyBrake()
}

extension Car
{
    func applyBrake()
    {
        brake.brake()
    }
}

class Sedan: Car
{
    private(set) var brake: Brake

    init(_ brake: Brake)
    {
        self.brake = brake
    }
}

do {
    let editor = Editor()
    editor.type("hello WORLD")

    editor.state = Upppercase()
    editor.type("hello world")

    editor.state = Lowercase()
    editor.type("hello world")
}

class Editor
{
    var state: Writing = Default()

    func type(_ words: String)
    {
        state.write(words)
    }
}

protocol Writing
{
    func write(_ words: String)
}

class Default: Writing
{
    func write(_ words: String)
    {
        print(words)
    }
}

class Upppercase: Writing
{
    func write(_ words: String)
    {
        print(words.uppercased())
    }
}

class Lowercase: Writing
{
    func write(_ words: String)
    {
        print(words.lowercased())
    }
}

do {
    var podcast = Podcast()
    let foo = Listener(name: "foo")
    let bar = Listener(name: "bar")
    podcast.add(subscriber: foo)
    podcast.add(subscriber: bar)

    podcast.release("Episode 1: Hello World")
}

protocol Publisher
{
    var subscribers: [Subscriber] {get set}

    mutating func add(subscriber: Subscriber)
    mutating func remove(at index: Int)
    func notify()
}

extension Publisher
{
    func notify()
    {
        for listener in subscribers {
            listener.update(self)
        }
    }

    mutating func add(subscriber: Subscriber)
    {
        subscribers.append(subscriber)
    }

    mutating func remove(at index: Int)
    {
        subscribers.remove(at: index)
    }
}

class Podcast: Publisher
{
    var subscribers: [Subscriber] = []
    var episode = ""

    func release(_ episode: String)
    {
        self.episode = episode
        notify()
    }
}

protocol Subscriber
{
    func update(_ publisher: Publisher)
}

struct Listener: Subscriber
{
    var name: String

    func update(_ publisher: Publisher)
    {
        guard let podast = publisher as? Podcast else {
            return
        }
        print("\(name) receives notification of \(podast.episode)")
    }
}

// caretaker
do {
    var history: [Memento] = []

    let editor = Editor()
    editor.type("foo")
    history.append(editor.save())
    print(editor.content)

    editor.type("bar")
    print(editor.content)

    editor.restore(history[0])
    print(editor.content)
}

// memento
struct Memento
{
    let content: String
}

// originator
class Editor
{
    var content: String = ""
    func type(_ words: String)
    {
        content += words
    }

    func save() -> Memento
    {
        return Memento(content: content)
    }

    func restore(_ memento: Memento)
    {
        content = memento.content
    }
}

do {
    let atc = ATC()
    let flight = Flight(atc)
    let runway = Runway(atc)

    atc.register(flight)
    atc.register(runway)

    runway.land()
    flight.land()
    /*
      Output:
      Landing permission granted.
      Sucessfully landed
    */
}

protocol Mediator
{
	var isLanding: Bool { get set}

	// just demostrate to add command to mediator, in this example it do
	// nothing
	func register(_ command: Command)
}

class ATC: Mediator
{
	var isLanding: Bool = false

	var commands: [Command] = []

	func register(_ command: Command)
	{
		commands.append(command)
	}
}

protocol Command
{
	init(_ atc: Mediator)
	func land()
}

class Flight: Command
{
	private var atc: Mediator
	required init(_ atc: Mediator)
	{
		self.atc = atc
	}

	func land()
	{
		if atc.isLanding {
			print("Sucessfully landed")
			atc.isLanding = true
		} else {
			print("Waiting for landing")
		}
	}
}

class Runway: Command
{
	private var atc: Mediator
	required init(_ atc: Mediator)
	{
		self.atc = atc
	}

	func land()
	{
		atc.isLanding = true
		print("Landing permission granted.")
	}
}

// client
do {
    let receiver = Television()
    let invoker = RemoteControl()

    let turnOn = TurnOn(receiver)
    invoker.submit(turnOn)

    let turnOff = TurnOff(receiver)
    invoker.submit(turnOff)
}

// Receiver
class Television
{
    func turnOn()
    {
        print("turn on")
    }

    func turnOff()
    {
        print("turn off")
    }
}

// Invoker
class RemoteControl
{
    func submit(_ command: Command)
    {
        command.execute()
    }
}

// Command
protocol Command
{
    func execute()
}

class TurnOn: Command
{
    private let receiver: Television

    init(_ receiver: Television)
    {
        self.receiver = receiver
    }

    func execute()
    {
        receiver.turnOn()
    }
}

class TurnOff: Command
{
    private let receiver: Television

    init(_ receiver: Television)
    {
        self.receiver = receiver
    }

    func execute()
    {
        receiver.turnOff()
    }
}

do {
  var bank = Bank(balance: 100)
  var paypal = Paypal(balance: 200)
  bank.setNext(paypal)

  bank.pay(amount: 30)
}

protocol Account
{
    var balance: Float {set get}
    var sucessor: Account? {set get}
}

extension Account
{
    mutating func pay(amount: Float)
    {
        if canPay(amount) {
            balance -= amount
            print("\(String(describing: type(of: self))) paid, balance: \(balance)")
        } else if var account = sucessor {
            account.pay(amount: amount)
        } else {
            print("none accounts have enought balance")
        }
    }

    func canPay(_ amount: Float) -> Bool
    {
        amount <= balance
    }

    mutating func setNext(_ account: Account)
    {
        sucessor = account
    }
}

struct Bank: Account
{
    var balance: Float
    var sucessor: Account?
}

struct Paypal: Account
{
    var balance: Float
    var sucessor: Account?
}

do {
    let builder = SwiftBuilder()
    builder.build()
}

protocol Builder
{
    func build()

    func test()
    func lint()
    func assemble()
    func deploy()
}

extension Builder
{
    func build()
    {
        test()
        lint()
        assemble()
        deploy()
    }
}

class SwiftBuilder: Builder
{
    func test() {
        print("swift test")
    }

    func lint()
    {
        print("swift lint")
    }

    func assemble()
    {
        print("swift assemble")
    }

    func deploy()
    {
        print("swift deploy")
    }

}