import Foundation

enum Animals {
    case cat
    case dog
    case rabbit
}

let cat = Animals.cat
cat

if cat == Animals.cat {
    "This is a cat"
} else {
    "This is something else"
}

switch cat {
case .cat:
    "This is a cat"
    break
case .dog:
    "This is a dog"
    break
case .rabbit:
    "This is a rabbit"
    break
}



enum Shortcut {
    case fileOrFolder(path: URL, name: String)
    case wwwUrl(path: URL)
    case song(artist: String, songName: String)
}

let wwwApple = Shortcut.wwwUrl(path: URL(string: "https://apple.com")!)

switch wwwApple {
case .fileOrFolder(path: let path, name: let name):
    path
    name
case .wwwUrl(path: let path):
    path
case .song(artist: let artist, songName: let songName):
    artist
    songName
}

switch wwwApple {
case .fileOrFolder(let path, let name):
    path
    name
case .wwwUrl(let path):
    path
case .song(let artist, let songName):
    artist
    songName
}

switch wwwApple {
case let .fileOrFolder(path, name):
    path
    name
case let .wwwUrl(path):
    path
case let .song(artist, songName):
    artist
    songName
}

if case let .wwwUrl(path) = wwwApple {
    path
}

let withoutYou = Shortcut.song(artist: "Gary", songName: "X")

if case let .song(_, songName) = withoutYou {
    songName
}

enum Vehicle {
    case car(manufacturer: String, model: String)
    case bike(manufacturer: String, yearMade: Int)
    
//    func getManufacturer() -> String {
//        switch self {
//        case let .bike(manufacturer, _):
//            return manufacturer
//        case let .car(manufacturer, _):
//            return manufacturer
//        }
//    }
    
//    var manufacturer: String {
//        switch self {
//        case let .bike(manufacturer, _):
//            return manufacturer
//        case let .car(manufacturer, _):
//            return manufacturer
//        }
//    }
    
    var manufacturer: String {
        switch self {
        case let .bike(manufacturer, _), let .car(manufacturer, _):
            return manufacturer
        }
    }
    
    var manufacturer_foo: String {
        switch self {
        case let .bike(foo, _), let .car(_, foo):
            return foo
        }
    }

}

let car = Vehicle.car(manufacturer: "Tesla", model: "X")

let bike = Vehicle.bike(manufacturer: "HD", yearMade: 2013)


car.manufacturer
bike.manufacturer

car.manufacturer_foo
bike.manufacturer_foo


enum FamilyMember: String {
    case father = "Dad"
    case mother = "Mom"
    case brother = "Bro"
    case sister = "Sis"
}

FamilyMember.brother.rawValue


enum FavouriteEmoji: String, CaseIterable {
    case blush = "😊"
    case rocket = "🚀"
    case fire = "🔥"
}

FavouriteEmoji.allCases
FavouriteEmoji.allCases.map(\.rawValue)

FavouriteEmoji.blush.rawValue
FavouriteEmoji(rawValue: "😊")


enum Height {
    case short, medium, long
    mutating func makeLong() {
        self = Height.long
    }
}

var myHeight = Height.medium
myHeight.makeLong()
myHeight


indirect enum IntOperation {
    case add(Int, Int)
    case subtract(Int, Int)
    case freehand(IntOperation)
    
    func calculateResult(of operation: IntOperation? = nil) -> Int{
        switch operation ?? self {
        case let .add(lhs, rhs):
            return lhs + rhs
        case let .subtract(lhs, rhs):
            return lhs - rhs
        case let .freehand(operation):
            return calculateResult(of: operation)
        }
    }
}

let freeHand = IntOperation.freehand(.add(4, 1))
freeHand.calculateResult()