class Person {
    let name: String
    
    init(name: String) {
        self.name = name
        print("\(name)이(가) 초기화되었습니다")
    }
    
    deinit {
        print("\(name)이(가) 메모리에서 해제되었습니다")
    }
}

// RC = 1 (철수를 가리키는 참조가 1개)
var reference1: Person? = Person(name: "철수")

// RC = 2 (철수를 가리키는 참조가 2개)
var reference2: Person? = reference1

// RC = 3 (철수를 가리키는 참조가 3개)
var reference3: Person? = reference1

// RC = 2 (참조 하나 제거)
reference1 = nil

// RC = 1 (참조 하나 더 제거)
reference2 = nil

// RC = 0 (마지막 참조 제거, deinit 호출됨!)
reference3 = nil
// 출력: "철수이(가) 메모리에서 해제되었습니다"

class Person {
    let name: String
    var apartment: Apartment?
    
    init(name: String) {
        self.name = name
        print("\(name) 초기화")
    }
    
    deinit {
        print("\(name) 해제")
    }
}

class Apartment {
    let unit: String
    var tenant: Person?
    
    init(unit: String) {
        self.unit = unit
        print("아파트 \(unit) 초기화")
    }
    
    deinit {
        print("아파트 \(unit) 해제")
    }
}

var john: Person? = Person(name: "John")
var unit4A: Apartment? = Apartment(unit: "4A")

// 강한 순환 참조 발생!
john?.apartment = unit4A  // Person -> Apartment
unit4A?.tenant = john     // Apartment -> Person

// 참조를 끊어도 메모리에서 해제되지 않음!
john = nil
unit4A = nil
// deinit이 호출되지 않음 = 메모리 누수!

class Person {
    let name: String
    var apartment: Apartment?
    
    init(name: String) {
        self.name = name
        print("\(name) 초기화")
    }
    
    deinit {
        print("\(name) 해제")
    }
}

class Apartment {
    let unit: String
    weak var tenant: Person?  // weak 키워드 추가!
    
    init(unit: String) {
        self.unit = unit
        print("아파트 \(unit) 초기화")
    }
    
    deinit {
        print("아파트 \(unit) 해제")
    }
}

var john: Person? = Person(name: "John")
var unit4A: Apartment? = Apartment(unit: "4A")

john?.apartment = unit4A
unit4A?.tenant = john  // weak 참조라 RC 증가 안 함!

john = nil  // John의 RC가 0이 되어 해제됨
// 출력: "John 해제"

unit4A = nil  // Apartment도 정상적으로 해제됨
// 출력: "아파트 4A 해제"

class Customer {
    let name: String
    var card: CreditCard?
    
    init(name: String) {
        self.name = name
        print("\(name) 고객 생성")
    }
    
    deinit {
        print("\(name) 고객 해제")
    }
}

class CreditCard {
    let number: String
    unowned let customer: Customer  // unowned 사용!
    
    init(number: String, customer: Customer) {
        self.number = number
        self.customer = customer
        print("카드 \(number) 생성")
    }
    
    deinit {
        print("카드 \(number) 해제")
    }
}

var jane: Customer? = Customer(name: "Jane")
jane?.card = CreditCard(number: "1234-5678", customer: jane!)

jane = nil
// 출력:
// "Jane 고객 해제"
// "카드 1234-5678 해제"

class HTMLElement {
    let name: String
    let text: String?
    
    // 클로저가 self를 강하게 참조!
    lazy var asHTML: () -> String = {
        if let text = self.text {
            return "<\(self.name)>\(text)<!--\(self.name)-->"
        } else {
            return "<\(self.name) />"
        }
    }
    
    init(name: String, text: String? = nil) {
        self.name = name
        self.text = text
        print("\(name) 요소 생성")
    }
    
    deinit {
        print("\(name) 요소 해제")
    }
}

var heading: HTMLElement? = HTMLElement(name: "h1", text: "안녕하세요")
print(heading?.asHTML() ?? "")

heading = nil
// deinit이 호출되지 않음! 메모리 누수 발생!

class HTMLElement {
    let name: String
    let text: String?
    
    // 캡처 리스트로 weak self 사용!
    lazy var asHTML: () -> String = { [weak self] in
        guard let self = self else {
            return ""
        }
        
        if let text = self.text {
            return "<\(self.name)>\(text)<!--\(self.name)-->"
        } else {
            return "<\(self.name) />"
        }
    }
    
    init(name: String, text: String? = nil) {
        self.name = name
        self.text = text
        print("\(name) 요소 생성")
    }
    
    deinit {
        print("\(name) 요소 해제")
    }
}

var heading: HTMLElement? = HTMLElement(name: "h1", text: "안녕하세요")
print(heading?.asHTML() ?? "")

heading = nil
// 출력: "h1 요소 해제" - 정상적으로 해제됨!

import UIKit

class ProfileViewController: UIViewController {
    private var userProfile: UserProfile?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        loadUserProfile()
    }
    
    // ❌ 잘못된 예: 메모리 누수 가능성
    func loadUserProfileWrong() {
        NetworkManager.shared.fetchProfile { profile in
            // self를 강하게 캡처하여 순환 참조 발생 가능
            self.userProfile = profile
            self.updateUI()
        }
    }
    
    // ✅ 올바른 예: weak self 사용
    func loadUserProfile() {
        NetworkManager.shared.fetchProfile { [weak self] profile in
            guard let self = self else { return }
            
            self.userProfile = profile
            self.updateUI()
        }
    }
    
    private func updateUI() {
        // UI 업데이트 로직
        print("프로필 업데이트 완료")
    }
    
    deinit {
        print("ProfileViewController 해제")
    }
}

// 네트워크 매니저 예시
class NetworkManager {
    static let shared = NetworkManager()
    
    func fetchProfile(completion: @escaping (UserProfile) -> Void) {
        // 비동기 네트워크 요청 시뮬레이션
        DispatchQueue.global().asyncAfter(deadline: .now() + 2) {
            let profile = UserProfile(name: "홍길동", age: 30)
            DispatchQueue.main.async {
                completion(profile)
            }
        }
    }
}

struct UserProfile {
    let name: String
    let age: Int
}

// 1. 디버그 바에서 메모리 그래프 아이콘 클릭
// 2. 왼쪽 패널에서 의심되는 객체 선택
// 3. 오른쪽 패널에서 참조 관계 확인
// 4. 보라색 느낌표가 있으면 순환 참조!

// 예시: 순환 참조가 있는 경우
class Parent {
    var child: Child?
    deinit { print("Parent deinit") }
}

class Child {
    var parent: Parent?  // 여기가 문제!
    deinit { print("Child deinit") }
}

// 해결: weak 사용
class Child {
    weak var parent: Parent?  // ✅ 해결!
    deinit { print("Child deinit") }
}

// ✅ 올바른 Delegate 패턴 구현

// 1. Protocol에 class 제한 추가
protocol DataManagerDelegate: AnyObject {
    func didReceiveData(_ data: String)
    func didFailWithError(_ error: Error)
}

class DataManager {
    // 2. delegate를 weak으로 선언
    weak var delegate: DataManagerDelegate?
    
    func fetchData() {
        // 데이터 가져오기 시뮬레이션
        DispatchQueue.global().asyncAfter(deadline: .now() + 1) { [weak self] in
            DispatchQueue.main.async {
                self?.delegate?.didReceiveData("Hello, World!")
            }
        }
    }
    
    deinit {
        print("DataManager 해제")
    }
}

class MyViewController: UIViewController, DataManagerDelegate {
    private var dataManager: DataManager?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        dataManager = DataManager()
        dataManager?.delegate = self  // weak이라 순환 참조 없음!
        dataManager?.fetchData()
    }
    
    func didReceiveData(_ data: String) {
        print("데이터 수신: \(data)")
    }
    
    func didFailWithError(_ error: Error) {
        print("에러 발생: \(error)")
    }
    
    deinit {
        print("MyViewController 해제")
    }
}

// 사용 예시
var viewController: MyViewController? = MyViewController()
viewController = nil
// 출력:
// "MyViewController 해제"
// "DataManager 해제"

class AdvancedViewController: UIViewController {
    private var networkManager: NetworkManager?
    private var dataProcessor: DataProcessor?
    
    // 패턴 1: 여러 객체를 weak으로 캡처
    func fetchAndProcess() {
        networkManager?.fetchData { [weak self, weak dataProcessor] data in
            guard let self = self,
                  let processor = dataProcessor else { return }
            
            let processed = processor.process(data)
            self.updateUI(with: processed)
        }
    }
    
    // 패턴 2: 값 타입을 캡처 (복사본 생성)
    func scheduleNotification() {
        let currentCount = 10
        
        Timer.scheduledTimer(withTimeInterval: 1.0, repeats: false) { [weak self] _ in
            // currentCount는 값 타입이라 복사됨
            print("Count: \(currentCount)")
            self?.showAlert()
        }
    }
    
    // 패턴 3: unowned self 사용 (확신이 있을 때)
    func setupAnimation() {
        UIView.animate(withDuration: 1.0) { [unowned self] in
            // 애니메이션 블록은 뷰가 존재하는 동안만 실행되므로 unowned 안전
            self.view.alpha = 0.5
        }
    }
    
    // 패턴 4: 특정 프로퍼티만 캡처
    func loadImage() {
        let imageView = self.imageView  // 지역 변수로 복사
        
        ImageLoader.load(from: url) { [weak self] image in
            // imageView는 이미 캡처되어 self 없이 사용 가능
            imageView.image = image
            self?.hideLoadingIndicator()
        }
    }
    
    private var imageView: UIImageView!
    private var url: URL!
    
    private func updateUI(with data: Any) {}
    private func showAlert() {}
    private func hideLoadingIndicator() {}
}

// 구조체 예시: 순환 참조 걱정 없음
struct Point {
    var x: Double
    var y: Double
}

struct Rectangle {
    var origin: Point
    var size: Point
    
    // 구조체는 값 타입이라 복사됨
    mutating func move(by offset: Point) {
        origin.x += offset.x
        origin.y += offset.y
    }
}

var rect1 = Rectangle(origin: Point(x: 0, y: 0), 
                       size: Point(x: 100, y: 100))
var rect2 = rect1  // 값이 복사됨!
rect2.move(by: Point(x: 10, y: 10))

print(rect1.origin.x)  // 0 (변경 안 됨)
print(rect2.origin.x)  // 10 (변경됨)

// 클래스 예시: 참조 타입
class Person {
    var name: String
    var friend: Person?  // 순환 참조 가능성!
    
    init(name: String) {
        self.name = name
    }
    
    deinit {
        print("\(name) 해제")
    }
}

var person1: Person? = Person(name: "철수")
var person2: Person? = Person(name: "영희")

person1?.friend = person2
person2?.friend = person1  // 순환 참조!

// 해결: weak 사용
class BetterPerson {
    var name: String
    weak var friend: BetterPerson?  // ✅ 순환 참조 해결!
    
    init(name: String) {
        self.name = name
    }
    
    deinit {
        print("\(name) 해제")
    }
}

// ❌ 비효율적: 큰 배열을 계속 복사
func processLargeDataBad() {
    var data = Array(repeating: 0, count: 1_000_000)
    
    for i in 0..<data.count {="" data[i]="i" *="" 2="" 매번="" 복사="" 발생="" 가능="" }="" ✅="" 효율적:="" 인덱스로="" 직접="" 접근="" func="" processlargedatagood()="" var="" data="Array(repeating:" 0,="" count:="" 1_000_000)="" for="" i="" in="" data.indices="" copy-on-write로="" 최적화됨="" ❌="" 비효율적:="" 불필요한="" 객체="" 생성="" class="" imagecache="" private="" cache:="" [string:="" uiimage]="[:]" getimage(for="" key:="" string)="" -=""> UIImage? {
        // 매번 새로운 UIImage 생성 (비효율적!)
        if cache[key] == nil {
            cache[key] = UIImage(named: key)
        }
        return cache[key]
    }
}

// ✅ 효율적: lazy 초기화와 캐싱
class BetterImageCache {
    private var cache: [String: UIImage] = [:]
    
    func getImage(for key: String) -> UIImage? {
        // 이미 있으면 재사용
        if let cached = cache[key] {
            return cached
        }
        
        // 없을 때만 생성하고 캐싱
        if let image = UIImage(named: key) {
            cache[key] = image
            return image
        }
        
        return nil
    }
    
    // 메모리 경고 시 캐시 정리
    func clearCache() {
        cache.removeAll()
    }
}

// ✅ 메모리 경고 처리
class MyViewController: UIViewController {
    private let imageCache = BetterImageCache()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // 메모리 경고 감지
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(handleMemoryWarning),
            name: UIApplication.didReceiveMemoryWarningNotification,
            object: nil
        )
    }
    
    @objc private func handleMemoryWarning() {
        print("메모리 경고! 캐시 정리 중...")
        imageCache.clearCache()
        // 기타 불필요한 데이터 정리
    }
    
    deinit {
        NotificationCenter.default.removeObserver(self)
    }
}</data.count>

// Lazy 초기화 예시
class DataManager {
    // ❌ 즉시 초기화: 사용하지 않아도 메모리 차지
    let heavyProcessor = HeavyDataProcessor()
    
    // ✅ Lazy 초기화: 필요할 때만 생성
    lazy var betterProcessor: HeavyDataProcessor = {
        print("HeavyDataProcessor 생성됨")
        return HeavyDataProcessor()
    }()
    
    // ✅ Lazy 프로퍼티는 클로저로 복잡한 초기화 가능
    lazy var configuration: Configuration = {
        let config = Configuration()
        config.setup()
        config.loadDefaults()
        return config
    }()
}

class HeavyDataProcessor {
    init() {
        print("무거운 객체 초기화 중...")
        // 시간이 오래 걸리는 초기화 작업
    }
}

class Configuration {
    func setup() {}
    func loadDefaults() {}
}

// 사용 예시
let manager = DataManager()
print("DataManager 생성 완료")
// 출력: "DataManager 생성 완료"
// betterProcessor는 아직 생성 안 됨!

manager.betterProcessor.process()
// 출력: "HeavyDataProcessor 생성됨"
// 이제 처음 사용할 때 생성됨!

import UIKit

// MARK: - 이미지 다운로더 (싱글톤 패턴)
class ImageDownloader {
    static let shared = ImageDownloader()
    private init() {}
    
    private var downloadTasks: [URL: URLSessionDataTask] = [:]
    
    func downloadImage(
        from url: URL,
        completion: @escaping (Result<uiimage, error="">) -> Void
    ) {
        // 이미 다운로드 중이면 중복 방지
        guard downloadTasks[url] == nil else { return }
        
        let task = URLSession.shared.dataTask(with: url) { [weak self] data, response, error in
            defer {
                // 작업 완료 후 태스크 제거
                self?.downloadTasks.removeValue(forKey: url)
            }
            
            if let error = error {
                DispatchQueue.main.async {
                    completion(.failure(error))
                }
                return
            }
            
            guard let data = data,
                  let image = UIImage(data: data) else {
                DispatchQueue.main.async {
                    completion(.failure(NSError(domain: "ImageError", code: -1)))
                }
                return
            }
            
            DispatchQueue.main.async {
                completion(.success(image))
            }
        }
        
        downloadTasks[url] = task
        task.resume()
    }
    
    func cancelDownload(for url: URL) {
        downloadTasks[url]?.cancel()
        downloadTasks.removeValue(forKey: url)
    }
    
    deinit {
        print("ImageDownloader deinit")
    }
}

// MARK: - 이미지 캐시 매니저
class ImageCacheManager {
    static let shared = ImageCacheManager()
    private init() {
        setupMemoryWarningObserver()
    }
    
    private var cache = NSCache<nsurl, uiimage="">()
    
    private func setupMemoryWarningObserver() {
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(handleMemoryWarning),
            name: UIApplication.didReceiveMemoryWarningNotification,
            object: nil
        )
    }
    
    @objc private func handleMemoryWarning() {
        print("⚠️ 메모리 경고! 캐시 정리 중...")
        cache.removeAllObjects()
    }
    
    func setImage(_ image: UIImage, for url: URL) {
        cache.setObject(image, forKey: url as NSURL)
    }
    
    func getImage(for url: URL) -> UIImage? {
        return cache.object(forKey: url as NSURL)
    }
    
    func clearCache() {
        cache.removeAllObjects()
    }
    
    deinit {
        NotificationCenter.default.removeObserver(self)
        print("ImageCacheManager deinit")
    }
}

// MARK: - 이미지 뷰어 ViewController
class ImageViewerViewController: UIViewController {
    private let imageView: UIImageView = {
        let iv = UIImageView()
        iv.contentMode = .scaleAspectFit
        iv.translatesAutoresizingMaskIntoConstraints = false
        return iv
    }()
    
    private let activityIndicator: UIActivityIndicatorView = {
        let indicator = UIActivityIndicatorView(style: .large)
        indicator.translatesAutoresizingMaskIntoConstraints = false
        return indicator
    }()
    
    private let imageURL: URL
    private let downloader = ImageDownloader.shared
    private let cacheManager = ImageCacheManager.shared
    
    init(imageURL: URL) {
        self.imageURL = imageURL
        super.init(nibName: nil, bundle: nil)
    }
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    
    override func viewDidLoad() {
        super.viewDidLoad()
        setupUI()
        loadImage()
    }
    
    private func setupUI() {
        view.backgroundColor = .white
        view.addSubview(imageView)
        view.addSubview(activityIndicator)
        
        NSLayoutConstraint.activate([
            imageView.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor),
            imageView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
            imageView.trailingAnchor.constraint(equalTo: view.trailingAnchor),
            imageView.bottomAnchor.constraint(equalTo: view.safeAreaLayoutGuide.bottomAnchor),
            
            activityIndicator.centerXAnchor.constraint(equalTo: view.centerXAnchor),
            activityIndicator.centerYAnchor.constraint(equalTo: view.centerYAnchor)
        ])
    }
    
    private func loadImage() {
        // 캐시 확인
        if let cachedImage = cacheManager.getImage(for: imageURL) {
            print("✅ 캐시에서 이미지 로드")
            imageView.image = cachedImage
            return
        }
        
        // 다운로드
        activityIndicator.startAnimating()
        
        downloader.downloadImage(from: imageURL) { [weak self] result in
            guard let self = self else { return }
            
            self.activityIndicator.stopAnimating()
            
            switch result {
            case .success(let image):
                print("✅ 이미지 다운로드 성공")
                self.imageView.image = image
                self.cacheManager.setImage(image, for: self.imageURL)
                
            case .failure(let error):
                print("❌ 이미지 다운로드 실패: \(error)")
                self.showErrorAlert()
            }
        }
    }
    
    private func showErrorAlert() {
        let alert = UIAlertController(
            title: "오류",
            message: "이미지를 불러올 수 없습니다.",
            preferredStyle: .alert
        )
        alert.addAction(UIAlertAction(title: "확인", style: .default))
        present(alert, animated: true)
    }
    
    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        // 화면이 사라질 때 다운로드 취소
        downloader.cancelDownload(for: imageURL)
    }
    
    deinit {
        print("ImageViewerViewController deinit - 메모리 정상 해제!")
    }
}</nsurl,></uiimage,>

// 연습 문제: 다음 코드의 메모리 문제를 찾아보세요!

class Node {
    var value: Int
    var next: Node?
    var previous: Node?  // 문제 발생 가능!
    
    init(value: Int) {
        self.value = value
    }
    
    deinit {
        print("Node \(value) 해제")
    }
}

// 양방향 연결 리스트 생성
var node1: Node? = Node(value: 1)
var node2: Node? = Node(value: 2)

node1?.next = node2
node2?.previous = node1  // 순환 참조!

node1 = nil
node2 = nil
// deinit이 호출되지 않음!

// 해결책: weak 사용
class BetterNode {
    var value: Int
    var next: BetterNode?
    weak var previous: BetterNode?  // ✅ weak으로 해결!
    
    init(value: Int) {
        self.value = value
    }
    
    deinit {
        print("BetterNode \(value) 해제")
    }
}