🧩 재사용 가능한 코드 짜기

// Protocol 선언 — "이걸 구현하면 Drawable이다"
protocol Drawable {
    func draw() -> String
}

protocol Describable {
    var description: String { get }
}

// 여러 Protocol 동시 채택
struct Circle: Drawable, Describable {
    let radius: Double

    func draw() -> String { "◯ r=\(radius)" }
    var description: String { "Circle(radius: \(radius))" }
}

struct Rectangle: Drawable, Describable {
    let width: Double
    let height: Double

    func draw() -> String { "▭ \(width)×\(height)" }
    var description: String { "Rect(\(width)×\(height))" }
}

// Protocol 타입으로 다형성 활용
let shapes: [any Drawable] = [
    Circle(radius: 5),
    Rectangle(width: 10, height: 3),
    Circle(radius: 2)
]

// 구체적 타입 몰라도 draw() 호출 가능
shapes.forEach { print($0.draw()) }
// ◯ r=5.0
// ▭ 10.0×3.0
// ◯ r=2.0

// Protocol with default implementation (Extension)
protocol Shape: Drawable {
    var area: Double { get }
    func describe() -> String
}

extension Shape {
    // 기본 구현 — 채택 타입이 override 안 해도 동작
    func describe() -> String {
        "이 도형의 넓이는 \(area)입니다."
    }
}

// String Extension
extension String {
    var isEmail: Bool {
        contains("@") && contains(".")
    }

    var trimmed: String {
        trimmingCharacters(in: .whitespaces)
    }

    func repeated(_ times: Int) -> String {
        String(repeating: self, count: times)
    }
}

"hello@example.com".isEmail   // true
"  hello  ".trimmed            // "hello"
"ha".repeated(3)               // "hahaha"

// Int Extension
extension Int {
    var isEven: Bool { self % 2 == 0 }
    var isOdd: Bool  { !isEven }

    // 범위 내 클램프
    func clamped(to range: ClosedRange) -> Int {
        min(max(self, range.lowerBound), range.upperBound)
    }
}

7.isOdd                    // true
150.clamped(to: 0...100)   // 100

// Array Extension
extension Array where Element: Comparable {
    var sortedUnique: [Element] {
        Array(Set(self)).sorted()
    }
}

[3, 1, 2, 1, 3].sortedUnique  // [1, 2, 3]

// Collection Extension — 안전한 subscript
extension Collection {
    subscript(safe index: Index) -> Element? {
        indices.contains(index) ? self[index] : nil
    }
}

let arr = [1, 2, 3]
arr[safe: 5]  // nil (크래시 없음)

// Generic 스택 자료구조
struct Stack {
    private var storage: [Element] = []

    mutating func push(_ element: Element) {
        storage.append(element)
    }

    mutating func pop() -> Element? {
        storage.popLast()
    }

    var top: Element? { storage.last }
    var isEmpty: Bool { storage.isEmpty }
    var count: Int { storage.count }
}

var intStack = Stack()
intStack.push(1); intStack.push(2); intStack.push(3)
intStack.pop()  // 3

var strStack = Stack()
strStack.push("Swift")
strStack.push("Generic")

// Generic 함수
func swapValues(_ a: inout T, _ b: inout T) {
    let temp = a
    a = b
    b = temp
}

// Generic + where (타입 제약)
func findMin(_ array: [T]) -> T? {
    guard !array.isEmpty else { return nil }
    return array.min()
}

func findMax(_ array: [T]) -> T? {
    array.max()
}

findMin([3, 1, 4, 1, 5])  // Optional(1)
findMin(["banana", "apple", "cherry"])  // Optional("apple")

// 여러 타입 제약
func process(
    _ items: [T]
) -> [T] {
    Array(Set(items)).sorted()
}

// Generic typealias
typealias Pair = (T, T)
let point: Pair = (3.0, 4.0)

// 커스텀 에러 타입
enum AppError: LocalizedError {
    case invalidInput(String)
    case notFound(id: Int)
    case permissionDenied
    case unknown(Error)

    var errorDescription: String? {
        switch self {
        case .invalidInput(let msg):
            return "잘못된 입력: \(msg)"
        case .notFound(let id):
            return "ID \(id)를 찾을 수 없습니다"
        case .permissionDenied:
            return "권한이 없습니다"
        case .unknown(let e):
            return "알 수 없는 오류: \(e)"
        }
    }
}

// throws 함수
func validateAge(_ age: Int) throws -> String {
    guard age >= 0 else {
        throw AppError.invalidInput("나이는 0 이상이어야 합니다")
    }
    guard age <= 150 else {
        throw AppError.invalidInput("유효하지 않은 나이입니다")
    }
    return age >= 18 ? "성인" : "미성년자"
}

// do-catch 에러 처리
do {
    let result = try validateAge(-5)
    print(result)
} catch AppError.invalidInput(let msg) {
    print("입력 오류:", msg)   // 입력 오류: 나이는 0 이상이어야 합니다
} catch AppError.permissionDenied {
    print("권한 없음")
} catch {
    print("기타 오류:", error)
}

// try? — 실패 시 nil 반환 (에러 무시)
let result1 = try? validateAge(25)    // Optional("성인")
let result2 = try? validateAge(-1)    // nil

// try! — 실패 시 크래시 (확실할 때만 사용)
let result3 = try! validateAge(30)    // "성인"

// 에러를 위로 전파 (rethrows)
func transform(
    _ value: T,
    using block: (T) throws -> T
) rethrows -> T {
    try block(value)
}

// Result 타입 기본 사용
func divide(_ a: Double, by b: Double) -> Result {
    guard b != 0 else {
        return .failure(.invalidInput("0으로 나눌 수 없습니다"))
    }
    return .success(a / b)
}

// switch로 처리
let result = divide(10, by: 2)
switch result {
case .success(let value):
    print("결과:", value)  // 결과: 5.0
case .failure(let error):
    print("오류:", error.errorDescription ?? "")
}

// map / flatMap 체이닝
let doubled = divide(10, by: 2)
    .map { $0 * 2 }           // success → 값 변환
    // .mapError { ... }       // failure → 에러 변환

// get()으로 throws로 변환
do {
    let value = try divide(10, by: 0).get()
    print(value)
} catch {
    print(error)  // 0으로 나눌 수 없습니다
}

// Result vs throws — 언제 무엇을?
// throws: 동기 함수, 즉시 처리 흐름에서
// Result: 콜백 전달, 나중에 처리, 값으로 저장할 때

// Result를 저장하고 나중에 처리
struct CachedResult {
    var value: Result?

    func unwrap() throws -> T {
        guard let result = value else {
            throw AppError.notFound(id: 0)
        }
        return try result.get()
    }
}

// 네트워크 상태 — 각 케이스에 다른 데이터
enum NetworkState {
    case idle
    case loading(progress: Double)
    case success(data: Data, statusCode: Int)
    case failure(error: Error, retryCount: Int)
}

// switch로 패턴 매칭 + 값 추출
func handleState(_ state: NetworkState) {
    switch state {
    case .idle:
        print("대기 중")
    case .loading(let progress):
        print("로딩 중: \(Int(progress * 100))%")
    case .success(let data, let code):
        print("성공 (\(code)): \(data.count) bytes")
    case .failure(let error, let retry):
        print("실패 (재시도 \(retry)회): \(error)")
    }
}

handleState(.loading(progress: 0.75))
// 로딩 중: 75%

// if case let — 단일 케이스 추출
let state = NetworkState.success(
    data: Data(), statusCode: 200
)
if case .success(_, let code) = state, code == 200 {
    print("요청 성공!")
}

// 실전 예시 — 앱 알림 타입
enum AppNotification {
    case message(from: String, body: String)
    case friendRequest(userId: Int, name: String)
    case systemAlert(title: String, priority: Int)
    case promotion(discount: Double, expiry: Date)
}

func notificationTitle(_ n: AppNotification) -> String {
    switch n {
    case .message(let from, _):      return "\(from)님의 메시지"
    case .friendRequest(_, let name): return "\(name)님이 친구 요청"
    case .systemAlert(let title, _): return title
    case .promotion(let d, _):       return "\(Int(d*100))% 할인!"
    }
}