func func1() -> Int{
    let a = 10
    func func2() -> Int{
        return a + 5
    }
    return func2()
}

print(func1())

 func makeIncrement() -> ((Int) -> Int){
     func addOne(number : Int) -> Int{
         return 1 + number
     }
     return addOne
 }

 var increment = makeIncrement()
 print(increment(7))

func hasMatch(givenList: [Int], condition: ((Int) -> Bool)) -> Bool{
    for number in givenList{
        if condition(number){
            return true
        }
    }
    return false
}

func lessThanTen(number: Int) -> Bool{
    if number < 11{
        return true
    }
    return false
}

func equalsTen(number: Int) -> Bool{
    if number == 10{
        return true
    }
    return false
}

var list = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21]

print(hasMatch(givenList: list, condition: lessThanTen))
print(hasMatch(givenList: list, condition: equalsTen))

var list2 = list.map{(number: Int) -> Int in
    let result = 2 * number
    return result
}

var list3 = list.map{number in 3 * number}

var list4 = list.map{4 * $0}

var list5 = list.sorted{$0 > $1}

var list6 = list.sorted{$0 < $1}

print(list2)
print(list3)
print(list4)
print(list5)
print(list6)

class shape{
    var name = ""
    var height = 0
    var width = 0

    init(height: Int, width: Int){
        self.name = self.toString()
        self.heightGetterSetter = height
        self.widthGetterSetter = width
    }
    
    init(name: String, height: Int, width: Int){
        self.name = name
        self.heightGetterSetter = height
        self.widthGetterSetter = width
    }
    
    var heightGetterSetter: Int{
        get{
            return self.height
        }
        set{
            if newValue < 1{
                print("height must higher than 0")
            }
            else{
                self.height = newValue
            }
        }
    }
    
    var widthGetterSetter: Int{
        get{
            return self.width
        }
        set{
            if newValue < 1{
                print("width must longer than 0")
            }
            else{
                self.width = newValue
            }
        }
    }
    
    deinit{
        print("\(name) is deinited")
    }
    
    func toString() -> String{
        return "Shape"
    }
    
    func area() -> Int{
        return 0
    }
    
    func introduce(){
        print("\(self.name)'s height is \(self.heightGetterSetter), and width is \(self.widthGetterSetter) and area is \(self.area())")
    }
}

class square: shape{
    override func toString() -> String{
        return "Square"
    }
    
    override func area() -> Int{
        return self.height * self.width
    }
}

class triangle: shape{
    override func toString() -> String{
        return "Triangle"
    }
    
    override func area() -> Int{
        return (self.height * self.width) / 2
    }
}

let shape1 = square(height: 12, width: 8)
let shape2 = triangle(name: "Semo", height: 9, width: 14)
shape1.introduce()
shape2.introduce()

class observerTest{
    var name = ""{
        didSet{
            print("[didSet] name old value \(oldValue), currentValue \(self._name)")
        }
        willSet{
            print("[willSet] name new value \(newValue), currentValue \(self._name)")
        }
    }
        
    var age = 0 {
        didSet{
            print("[didSet] age old value \(oldValue), currentValue \(self._age)")
        }
        willSet{
            print("[willSet] age new value \(newValue), currentValue \(self._age)")
        }
    }

    init(name: String, age: Int){
        self._age = age
        self._name = name
    }
    
    var _name: String{
        get{
            return self.name
        }
        set{
            self.name = newValue
        }
    }
    
    var _age: Int{
        get{
            return self.age
        }
        set{
            self.age = newValue
        }
    }
    
    func toString(){
        print("\(self._name) is age of \(self._age)")
    }
}

var tester = observerTest(name: "seunghun", age: 23)
tester.toString()
print()
tester._age = 24
tester._name = "Seunghun Yang"
tester.toString()

print()
enum Rank: Int{
    case ace = 1;                                                                           //explicitly set Integer value of enum element
    case two, three, four, five, six, seven, eight, nine, ten, jack, queen, king
    
    func description() -> String{
        switch self{
        case .ace:
            return "ace"
        case .jack:
            return "jack"
        case .queen:
            return "queen"
        case .king:
            return "king"
        default:
            return String(self.rawValue)
        }
    }
    
    func isSpecial() -> String{
        switch self{
        case .ace, .jack, .queen, .king:
            return "special"
        default:
            return "not special"
        }
    }
}

let card1 = Rank.three
    print("\(card1.description()) and it is \(card1.isSpecial())")

if let card2 = Rank(rawValue: 11) {                                                             //rawValue is naive value of element in enum, it returns optional
    print("\(card2.description()) and it is \(card2.isSpecial())")
}
else{
    print("value is nil!!")
}

if let card3 = Rank(rawValue: 14){
    print("\(card3.description()) and it is \(card3.isSpecial())")
}
else{
    print("value is nil!!")
}

let card4: Rank? = Rank(rawValue: 12)
print("\(card4!.description()) and it is \(card4!.isSpecial())")                                  //it may be nil and if it is, it occurs fatal error

enum ServerResponse{
    case onoffTime(Int, Int)
    case serverFailed(String)
    case broadCast(String)
    
    func toString() -> String{
        switch self{
        case let .onoffTime(onTime, offTime):
            return "server on at \(onTime) and it offs at \(offTime)"
        case let .serverFailed(message):
            return "server failed because of \(message)"
        case let .broadCast(message):
            return "[BroadCast] \(message)"
        }
    }
}

let serverMessage1 = ServerResponse.onoffTime(6, 23)
let serverMessage2 = ServerResponse.serverFailed("out of memory")
let serverMessage3 = ServerResponse.broadCast("Hello")

print(serverMessage1.toString())
print(serverMessage2.toString())
print(serverMessage3.toString())

struct structTest{
    var count = 0{
        didSet{
            print("changed from \(oldValue) to \(self.count)")
        }
    }
    
    init(givenCount: Int){
        self.count = givenCount
    }
}

class classTest{
    var count = 0{
        didSet{
            print("changed from \(oldValue) to \(self.count)")
        }
    }
    
    init(givenCount: Int){
        self.count = givenCount
    }
}

//func incrementStruct(target: structTest){
//    target.count += 1
//}

func incrementClass(target: classTest){
    target.count += 1
}

var test1 = structTest(givenCount: 0)
var test2 = classTest(givenCount: 0)
//incrementStruct(target: test1)
incrementClass(target: test2)

protocol animal{
    var name: String{get set}
    func speak()
}

class dog: animal{
    var name: String = ""
    
    init(givenName: String){
        self.name = givenName;
    }
    
    func speak(){
        print("\(self.name) : bark bark")
    }
}

class cat: animal{
    var name: String = ""
    
    init(givenName: String){
        self.name = givenName;
    }
    
    func speak(){
        print("\(self.name) : meow")
    }
}

var doggy = dog(givenName: "Peter")
var kitty = cat(givenName: "Tom")
doggy.speak()
kitty.speak()

protocol speak{
    func toString()
}

extension Int: speak{
    func toString(){
        print("I am \(self)")
    }
}

extension dog: speak{
    func toString(){
        print("Hi, my name is \(self.name)")
    }
}

var number = 3
number.toString()
5.toString()
doggy.toString()

var doggyProtocol: animal = doggy
doggyProtocol.speak()

enum errorList: Error{
    case errorTwo
    case errorThree
}

func errorChecker(inputNumber: Int) throws -> String{
    if inputNumber % 2 != 0{
        throw errorList.errorTwo
    }
    else if inputNumber % 3 != 0{
        throw errorList.errorThree
    }
    return "your input handled normally"
}

do{
    let errorCheck1 = try errorChecker(inputNumber: 6)
    print(errorCheck1)
    
    let errorCheck2 = try errorChecker(inputNumber: 133)
    print(errorCheck2)
}
catch errorList.errorTwo{
    print("errorTwo raised")
}
catch errorList.errorThree{
    print("errorThree raised")
}

func testingDeffer(){
    print("first sentence")
    defer{
        print("last sentence")
    }
    print("second sentence")
    print("third sentence")
}

testingDeffer()

func bulletBelt<Bullet>(bullet: Bullet, numberOfBullets: Int) -> [Bullet]{
    var beltOfBullets = [Bullet]()
    for _ in 0..<numberOfBullets{
        beltOfBullets.append(bullet)
    }
    return beltOfBullets
}

func fireAllBullets<Bullet>(bulletBelt: [Bullet]){
    for _ in 0..<bulletBelt.endIndex{
        print("Bang!!")
    }
}

var beltOfBullets = bulletBelt(bullet: "5.56mm", numberOfBullets: 15)
fireAllBullets(bulletBelt: beltOfBullets)

func commonElements<T: Sequence>(_ left: T,_ right: T) -> [T.Element] where T.Element: Equatable{
    var found = [T.Element]()
    for leftElement in left{
        for rightElement in right{
            if leftElement == rightElement{
                found.append(leftElement)
                print("found common element \(leftElement)")
            }
        }
    }
    return found
}

commonElements([1, 3, 5, 7, 9, 11, 13], [1, 1, 2, 3, 5, 8, 13])
print()
commonElements("strawberry", "tangerine")