protocol Openable {
    mutating func open()
}

protocol Closeable {
    mutating func close()
}

// मैं दरवाज़ा हूँ। मेरी एक संकुचित स्थिति है और आप इसे मेथड्स से बदल सकते हैं।
struct PodBayDoor: Openable, Closeable {

    private enum State {
        case open
        case closed
    }

    private var state: State = .closed

    mutating func open() {
        state = .open
    }

    mutating func close() {
        state = .closed
    }
}

// मैं केवल खोलने के लिए ज़िम्मेदार हूँ, मुझे नहीं पता अंदर क्या है या कैसे बंद करना है।
final class DoorOpener {
    private var door: Openable

    init(door: Openable) {
        self.door = door
    }

    func execute() {
        door.open()
    }
}

// मैं केवल बंद करने के लिए ज़िम्मेदार हूँ, मुझे नहीं पता अंदर क्या है या कैसे खोलना है।
final class DoorCloser {
    private var door: Closeable

    init(door: Closeable) {
        self.door = door
    }

    func execute() {
        door.close()
    }
}

let door = PodBayDoor()


// ⚠️ केवल `DoorOpener` ही दरवाज़ा खोलने के लिए ज़िम्मेदार है।
let doorOpener = DoorOpener(door: door)
doorOpener.execute()

// ⚠️ यदि दरवाज़ा बंद करते समय कोई अन्य ऑपरेशन करना हो,
// जैसे अलार्म चालू करना, तो `DoorOpener` क्लास को बदलने की ज़रूरत नहीं है।
let doorCloser = DoorCloser(door: door)
doorCloser.execute()

protocol Shooting {
    func shoot() -> String
}

// मैं एक लेज़र बीम हूँ। मैं गोली चला सकती हूँ।
final class LaserBeam: Shooting {
    func shoot() -> String {
        return "Ziiiiiip!"
    }
}

// मेरे पास हथियार हैं और मुझ पर भरोसा करो, मैं उन सबको एक साथ दाग़ सकता हूँ। धमाका! धमाका! धमाका!
final class WeaponsComposite {

    let weapons: [Shooting]

    init(weapons: [Shooting]) {
        self.weapons = weapons
    }

    func shoot() -> [String] {
        return weapons.map { $0.shoot() }
    }
}

let laser = LaserBeam()
var weapons = WeaponsComposite(weapons: [laser])

weapons.shoot()

// मैं एक रॉकेट लॉन्चर हूँ। मैं रॉकेट दाग़ सकता हूँ।
// ⚠️ रॉकेट लॉन्चर का समर्थन जोड़ने के लिए मुझे मौजूदा क्लासेज़ में कुछ भी बदलने की ज़रूरत नहीं है।
final class RocketLauncher: Shooting {
    func shoot() -> String {
        return "Whoosh!"
    }
}

let rocket = RocketLauncher()

weapons = WeaponsComposite(weapons: [laser, rocket])
weapons.shoot()

let requestKey: String = "NSURLRequestKey"

// मैं NSError की उपक्लास हूँ। मैं अतिरिक्त कार्यक्षमता प्रदान करती हूँ लेकिन मूल को बाधित नहीं करती।
class RequestError: NSError {

    var request: NSURLRequest? {
        return self.userInfo[requestKey] as? NSURLRequest
    }
}

// मैं डेटा प्राप्त करने में विफल रही और RequestError लौटाऊँगी।
func fetchData(request: NSURLRequest) -> (data: NSData?, error: RequestError?) {

    let userInfo: [String:Any] = [requestKey : request]

    return (nil, RequestError(domain:"DOMAIN", code:0, userInfo: userInfo))
}

// मुझे नहीं पता कि RequestError क्या है और मैं विफल होकर NSError लौटाऊँगी।
func willReturnObjectOrError() -> (object: AnyObject?, error: NSError?) {

    let request = NSURLRequest()
    let result = fetchData(request: request)

    return (result.data, result.error)
}

let result = willReturnObjectOrError()

// ठीक है। मेरे दृष्टिकोण से यह NSError का एक उत्तम इंस्टेंस है।
let error: Int? = result.error?.code

// ⚠️ लेकिन रुकिए! यह क्या है? यह एक RequestError भी है! बढ़िया!
if let requestError = result.error as? RequestError {
    requestError.request
}

// मेरे पास एक लैंडिंग साइट है।
protocol LandingSiteHaving {
    var landingSite: String { get }
}

// मैं LandingSiteHaving ऑब्जेक्ट्स पर लैंड कर सकता हूँ।
protocol Landing {
    func land(on: LandingSiteHaving) -> String
}

// मेरे पास पेलोड है।
protocol PayloadHaving {
    var payload: String { get }
}

// मैं वाहन से पेलोड प्राप्त कर सकता हूँ (जैसे कैनेडार्म के माध्यम से)।

protocol PayloadFetching {
    func fetchPayload(vehicle: PayloadHaving) -> String
}

final class InternationalSpaceStation: PayloadFetching {


    // ⚠ अंतरिक्ष स्टेशन को SpaceXCRS8 की लैंडिंग क्षमताओं के बारे में कोई जानकारी नहीं है।
    func fetchPayload(vehicle: PayloadHaving) -> String {
        return "Deployed \(vehicle.payload) at April 10, 2016, 11:23 UTC"
    }
}

// मैं एक बार्ज हूँ — मेरे पास लैंडिंग साइट है (खैर, आप समझ गए होंगे)।
final class OfCourseIStillLoveYouBarge: LandingSiteHaving {
    let landingSite = "a barge on the Atlantic Ocean"
}

// मेरे पास पेलोड है और मैं लैंडिंग साइट वाली चीज़ों पर लैंड कर सकता हूँ।
// मैं एक बहुत सीमित अंतरिक्ष वाहन हूँ, मुझे पता है।
final class SpaceXCRS8: Landing, PayloadHaving {

    let payload = "BEAM and some Cube Sats"

    // ⚠️ CRS8 केवल लैंडिंग साइट की जानकारी जानता है।
    func land(on: LandingSiteHaving) -> String {
        return "Landed on \(on.landingSite) at April 8, 2016 20:52 UTC"
    }
}

let crs8 = SpaceXCRS8()
let barge = OfCourseIStillLoveYouBarge()
let spaceStation = InternationalSpaceStation()

spaceStation.fetchPayload(vehicle: crs8)
crs8.land(on: barge)

protocol TimeTraveling {
    func travelInTime(time: TimeInterval) -> String
}

final class DeLorean: TimeTraveling {
	func travelInTime(time: TimeInterval) -> String {
		return "Used Flux Capacitor and travelled in time by: \(time)s"
	}
}

final class EmmettBrown {
	private let timeMachine: TimeTraveling

    // ⚠️ Emmett Brown को एक `TimeTraveling` उपकरण दिया गया है, न कि ठोस क्लास `DeLorean`!
	init(timeMachine: TimeTraveling) {
		self.timeMachine = timeMachine
	}

	func travelInTime(time: TimeInterval) -> String {
		return timeMachine.travelInTime(time: time)
	}
}

let timeMachine = DeLorean()

let mastermind = EmmettBrown(timeMachine: timeMachine)
mastermind.travelInTime(time: -3600 * 8760)