class Dog {
    var name: String
    var weight: Double
    
    init(name: String, weight: Double) {
        self.name = name
        self.weight = weight
    }
    
    deinit {  // 실제로 메모리에서 해제가 되는지 확인을 위한 소멸자
        print("\(name) 메모리 해제")
    }
}

var choco: Dog? = Dog(name: "초코", weight: 15.0)  // retain(choco)   RC : 1
var bori: Dog? = Dog(name: "보리", weight: 10.0)   // retain(bori)    RC : 1 

choco = nil  //release(choco)   RC : 0
bori = nil   //release(bori)    RC : 0

class Dog {
    var name: String
    var owner: Person?  // Person을 참조 (서로 참조하고 있음)   RC : 1
    
    init(name: String) {
        self.name = name
    }
    
    deinit {
        print("\(name) 메모리 해제")
    }
}

class Person {
    var name: String
    var pet: Dog?  // Dog를 참조 (서로 참조하고 있음)   RC : 1
    
    init(name: String) {
        self.name = name
    }
    
    deinit {
        print("\(name) 메모리 해제")
    }
}

var bori: Dog? = Dog(name: "보리")         // retain(bori)    RC : 2
var kkoma: Person? = Person(name: "꼬마")  // retain(kkoma)   RC : 2

// 강한 참조 사이클(Strong Reference Cycle)이 일어남
bori?.owner = kkoma
kkoma?.pet = bori

// 참조하는 모든 곳에 nil을 할당해 주어야 RC가 0이되어 메모리 누수가 일어나지 않음
bori?.owner = nil  // release(bori)    RC : 1
kkoma?.pet = nil   // release(kkoma)   RC : 1
bori = nil         // release(bori)    RC : 0
kkoma = nil        // release(kkoma)   RC : 0

// 위의 코드와 같은 내용의 코드
class Dog {
    var name: String
    weak var owner: Person?  // weak 키워드 -> 약한 참조
    // unowned var owner: Person?  // unowned 키워드 -> 비소유 참조
    // Swift 5.3 이전버전에서는 비소유참조의 경우, 옵셔널 타입 선언이 안되었음
    
    init(name: String) {
        self.name = name
    }
    
    deinit {
        print("\(name) 메모리 해제")
    }
}

class Person {
    var name: String
    weak var pet: Dog?  // weak 키워드 -> 약한 참조
    // unowned var pet: Dog?  // unowned 키워드 -> 비소유 참조
    
    init(name: String) {
        self.name = name
    }
    
    deinit {
        print("\(name) 메모리 해제")
    }
}

var bori: Dog? = Dog(name: "보리")
var kkoma: Person? = Person(name: "꼬마")

// 강한 참조 사이클이 일어나지 않음
bori?.owner = kkoma
kkoma?.pet = bori

// 메모리 해제가 잘됨 (사실 이 경우 한쪽만 weak/unowned으로 선언해도 상관없음)
bori = nil
kkoma = nil

// 캡쳐리스트의 문법적 형태

// 파라미터가 없는 경우
{["캡쳐리스트"] in 
    print("캡쳐리스트")
}

// 파라미터가 있는 경우
{["캡쳐리스트"](파라미터)-> 리턴형 in
    print("캡쳐리스트")
}

var num = 1

// 일반적인 클로저
let valTypeCapture1 = {
    print("밸류값 출력: \(num)")
}
// 클로저 외부에 존재하는 밸류 타입의 참조(num의 주소)를 캡쳐함
// 외부 요인에 의해 해당 값이 변했을 때도 계속 참조

// 캡쳐 리스트
let valTypeCapture2 = {[num] in
    print("밸류값 출력: \(num)"
}
// 클로저 외부에 존재하는 밸류타입의 값(1)을 복사해서 사용
// 외부 요인에 의해 해당 값의 변경을 방지할 때 사용

valTypeCapture1 // 밸류값 출력: 1
valTypeCapture2 // 밸류값 출력: 1

var num = 2
valTypeCapture1 // 밸류값 출력: 2
valTypeCapture2 // 밸류값 출력: 1

class SomeClass {
    var num = 0
}

var x = SomeClass()
var y = SomeClass()

// 일반적인 클로저
let refTypeCapture1 = {  // 변수 참조를 캡쳐
    print("참조 출력값:", x.num, y.num)
}
// 클로저 외부에 존재하는 참조타입의 참조(변수 주소)를 캡쳐함
// 외부 요인에 의해 해당 값이 변했을 때도 계속 참조

// 캡쳐 리스트
let refTypeCapture2 = { [x] in  // 참조를 직접 캡쳐
    print("참조 출력값:", x.num, y.num)
}
// 클로저 외부에 존재하는 참조타입의 주소값을 복사해서 사용
// 외부 요인에 의해 해당 인스턴스의 해제를 방지할 때 사용
// -> 가르키는 인스턴스의 RC를 올라가게 함으로써, 메모리에서 해제될 가능성을 방지

// x : (참조 타입) 주소값 캡쳐, x를 직접 참조로 가르킴
// y : 변수를 캡쳐해서, y 변수를 가르킴

var z = SomeClass()

let refTypeCapture1 = { [weak z] in
    print("참조 출력값(캡처리스트):", z?.num)  
    // 약한 참조는 nil을 할당할 수도 있기 때문에 항상 옵셔널 타입
}

refTypeCapture1()                        // Optional(0)

let refTypeCapture2 = { [unowned z] in
    print("참조 출력값(캡처리스트):", z.num)
}

refTypeCapture2()                        // 0

// '약한 참조'와 '비소유 참조'를 통해 가르키는 참조 타입(인스턴스)의 RC를 올라가지 않게 함

// 클로저를 객체 내에서 사용할때는 대부분 weak과 함께 사용한다고 보면 됨

class Person {
    let name = "꼬마"
    
    func sayMyName() {
        print("나의 이름은 \(name)입니다.")
    }
    
    func sayMyName1() {
        // 비동기적으로 실행하는 클로저
        DispatchQueue.global().async {  
            print("나의 이름은 \(self.name)입니다.")
        }
        // 강한 참조
        // 해당 클로저는 오래동안 저장할 필요가 있음
        // -> 새로운 스택을 만들어서 실행하기 때문
    }
    
    func sayMyName2() {
        // 약한 참조
        DispatchQueue.global().async { [weak self] in  
            print("나의 이름은 \(self?.name)입니다.")  
            // 옵셔널 타입으로 출력
        }
    }
    
    func sayMyName3() {
        DispatchQueue.global().async { [weak self] in
            // 가드문 처리 ==> 객체없으면 일종료
            guard let weakSelf = self else { return }   
            print("나의 이름은 \(weakSelf.name)입니다.(가드문)")
        }
    }
}

// (서로가 서로를 가르키는) 강한 참조 사이클은 일어나진 않지만 강한 참조가 일어남
class ViewController: UIViewController {
    
    var name: String = "뷰 컨트롤"
    
    func doSomething() {
        DispatchQueue.global().async {
            sleep(3)
            print("글로벌큐에서 출력하기: \(self.name)")
        }
    }
    
    deinit {  // 메모리 해제를 알려주는 소멸자
        print("\(name) 메모리 해제")
    }
}

func localScopeFunction() {
    let vc = ViewController()
    vc.doSomething()
}  // 이 함수는 이미 종료 -> vc변수 없음

localScopeFunction()
// (3초후)
// 글로벌큐에서 출력하기: 뷰 컨트롤
// 뷰 컨트롤 메모리 해제

// 약한 참조를 사용했지만 오히려 잘못 활용한 경우
class ViewController: UIViewController {
    
    var name: String = "뷰 컨트롤"
    
    func doSomething() {
        // 강한 참조 사이클이 일어나지 않지만, 굳이 뷰컨트롤러를 길게 잡아둘 필요가 없다면
        // weak self로 선언
        DispatchQueue.global().async { [weak self] in
            // guard let weakSelf = self else { return }
            // 가드 렛 구문을 통하면 출력 자체를 하지 않고 리턴
            sleep(3)
            print("글로벌큐에서 출력하기: \(self?.name)")
            // 약한 참조 weak 키워드때문에 self를 옵셔널 타입으로 선언
        }
    }
    
    deinit {  // 메모리 해제를 알려주는 소멸자
        print("\(name) 메모리 해제")
    }
}

func localScopeFunction1() {
    let vc = ViewController1()
    vc.doSomething()
}

localScopeFunction()

// 뷰 컨트롤 메모리 해제
// (3초후)
// 글로벌큐에서 출력하기: nil