Protocol Oriented Programming Master

let ints = [1, 2, 3]
let strings = ["a", "b", "c"]

// Element가 달라도 Collection API를 동일하게 사용
print(ints.count)
print(strings.count)

let mapped = ints.map { $0 * 10 }
let filtered = strings.filter { $0 != "b" }

protocol Repository {
    associatedtype Entity
    func fetch(by id: String) async throws -> Entity
}

protocol ImageLoading {
    func load(from url: URL) async throws -> Data
}

struct URLImageLoader: ImageLoading {
    func load(from url: URL) async throws -> Data { Data() }
}

struct CacheImageLoader: ImageLoading {
    func load(from url: URL) async throws -> Data { Data() }
}

// any: 서로 다른 구체 타입을 같은 컨테이너에 보관 가능
let loaders: [any ImageLoading] = [URLImageLoader(), CacheImageLoader()]

// some: 호출자 입장에서 타입은 숨겨지지만, 실제 반환 타입은 하나로 고정
func makeDefaultLoader() -> some ImageLoading {
    URLImageLoader() // 이 함수는 항상 URLImageLoader만 반환해야 함
}

// 아래처럼 분기마다 다른 구체 타입을 반환하면 컴파일 에러
// func makeLoader(useCache: Bool) -> some ImageLoading {
//     if useCache { return CacheImageLoader() }
//     return URLImageLoader()
// }

// any 매개변수: 다양한 구현체 주입 허용
func render(loader: any ImageLoading) async throws {
    _ = try await loader.load(from: URL(string: "https://example.com")!)
}

// 실무 패턴: 외부 API는 some으로 감추고, 내부 저장은 any로 받는 식으로 혼합
struct LoaderFactory {
    static func make() -> some ImageLoading {
        URLImageLoader()
    }
}

final class ScreenInteractor {
    private let loader: any ImageLoading

    init(loader: any ImageLoading) {
        self.loader = loader
    }
}

// any 반환: 호출자는 구체 타입을 모른다. 분기별로 다른 타입 반환 가능
func makeLoaderAny(useCache: Bool) -> any ImageLoading {
    if useCache {
        return CacheImageLoader()
    }
    return URLImageLoader()
}

// some 반환: 호출자는 구체 타입을 모른다. 하지만 함수 내부 실제 타입은 하나여야 함
func makeLoaderSome() -> some ImageLoading {
    URLImageLoader()
}

protocol EventEmitter {
    associatedtype Event
    func emit(_ event: Event)
}

struct AnyEventEmitter<E>: EventEmitter {
    private let _emit: (E) -> Void

    init<T: EventEmitter>(_ base: T) where T.Event == E {
        _emit = base.emit
    }

    func emit(_ event: E) {
        _emit(event)
    }
}

protocol Container {
    associatedtype Item
    var items: [Item] { get }
    mutating func add(_ item: Item)
}

struct IntContainer: Container {
    var items: [Int] = []
    mutating func add(_ item: Int) {
        items.append(item)
    }
}

struct StringContainer: Container {
    var items: [String] = []
    mutating func add(_ item: String) {
        items.append(item)
    }
}

protocol Drawable {
    func draw()
}

protocol Animatable {
    func animate()
}

protocol Touchable {
    func onTouch()
}

// 세 프로토콜을 모두 만족해야 함
func setupUIElement(_ element: Drawable & Animatable & Touchable) {
    element.draw()
    element.animate()
    element.onTouch()
}

struct Button: Drawable, Animatable, Touchable {
    func draw() { print("Drawing") }
    func animate() { print("Animating") }
    func onTouch() { print("Tapped") }
}

setupUIElement(Button())  // ✅

// Element가 Equatable일 때만 제공
extension Array where Element: Equatable {
    func removeDuplicates() -> [Element] {
        var result: [Element] = []
        for item in self {
            if !result.contains(item) {
                result.append(item)
            }
        }
        return result
    }
}

[1, 2, 2, 3].removeDuplicates()  // [1, 2, 3]

// Element가 Numeric일 때만 제공
extension Array where Element: Numeric {
    func sum() -> Element {
        return reduce(0, +)
    }
}

[1, 2, 3].sum()  // 6

protocol Copyable {
    func copy() -> Self
}

class Document: Copyable {
    var content: String

    required init(content: String) {
        self.content = content
    }

    func copy() -> Self {
        return type(of: self).init(content: content)
    }
}

class PDFDocument: Document {
    var pageCount: Int = 0
}

let pdf = PDFDocument(content: "Test")
let copied = pdf.copy()  // 타입: PDFDocument (Document가 아님)

protocol Animal {
    var name: String { get }
    func makeSound()
}

protocol Flyable: Animal {
    var wingSpan: Double { get }
    func fly()
}

protocol Swimmable: Animal {
    var swimSpeed: Double { get }
    func swim()
}

// 다중 상속
protocol Amphibious: Flyable, Swimmable {
    func transition()
}

struct Duck: Amphibious {
    var name: String
    var wingSpan: Double
    var swimSpeed: Double

    func makeSound() { print("Quack") }
    func fly() { print("Flying") }
    func swim() { print("Swimming") }
    func transition() { print("Land to water") }
}

enum Authenticated {}
enum Unauthenticated {}

protocol AuthState {}
extension Authenticated: AuthState {}
extension Unauthenticated: AuthState {}

struct Session<State: AuthState> {
    let token: String?
    init(token: String? = nil) {
        self.token = token
    }
}

// 인증 전에만 호출 가능
extension Session where State == Unauthenticated {
    func login(username: String, password: String) -> Session<Authenticated> {
        return Session<Authenticated>(token: "abc123")
    }
}

// 인증 후에만 호출 가능
extension Session where State == Authenticated {
    func fetchUserData() {
        print("Fetching with token: \(token!)")
    }

    func logout() -> Session<Unauthenticated> {
        return Session<Unauthenticated>()
    }
}

// 사용
let unauthenticated = Session<Unauthenticated>()
// unauthenticated.fetchUserData()  // ❌ 컴파일 에러

let authenticated = unauthenticated.login(username: "user", password: "pass")
authenticated.fetchUserData()  // ✅

protocol Drawable {
    func draw()
}

struct Circle: Drawable {
    func draw() { print("Drawing circle") }
}

struct Square: Drawable {
    func draw() { print("Drawing square") }
}

// Protocol Witness Table 생성됨
// Circle의 PWT: draw() -> Circle.draw()
// Square의 PWT: draw() -> Square.draw()

let shapes: [Drawable] = [Circle(), Square()]
for shape in shapes {
    shape.draw()  // Dynamic dispatch (런타임 결정)
}

// 구체 타입 사용 시
let circle = Circle()
circle.draw()  // Static dispatch (컴파일 타임 결정) - 더 빠름

// 상속 기반 - 단일 상속의 한계
class Vehicle {
    func move() { print("Moving") }
}

class Car: Vehicle {
    override func move() { print("Driving") }
}

class Boat: Vehicle {
    override func move() { print("Sailing") }
}

// 문제: AmphibiousCar를 만들려면?
// Car와 Boat 둘 다 상속 불가! 💥

// 조합 기반 - 다중 채택 가능
protocol Drivable {
    func drive()
}

protocol Sailable {
    func sail()
}

extension Drivable {
    func drive() { print("Driving on road") }
}

extension Sailable {
    func sail() { print("Sailing on water") }
}

struct AmphibiousCar: Drivable, Sailable {
    // 둘 다 사용 가능 ✅
}

let amphiCar = AmphibiousCar()
amphiCar.drive()   // Driving on road
amphiCar.sail()    // Sailing on water

// before
protocol UserService {
    func login()
    func logout()
    func loadProfile()
    func uploadImage()
    func trackEvent()
}

// after
protocol AuthService { func login(); func logout() }
protocol ProfileService { func loadProfile(); func uploadImage() }
protocol AnalyticsTracker { func trackEvent() }