19 · Codable ① 합성과 커스텀

struct NonCodableType {}
struct Case1: Codable {
    var value: NonCodableType
}
// error: type 'Case1' does not conform to protocol 'Decodable'
// note: cannot automatically synthesize 'Decodable' because
//       'NonCodableType' does not conform to 'Decodable'
// (Encodable도 같은 이유로 별도 에러가 난다)

struct Case2<T>: Codable {
    var value: T
}
// error: type 'Case2<T>' does not conform to protocol 'Decodable'
// note: cannot automatically synthesize 'Decodable' because
//       'T' does not conform to 'Decodable'

protocol Shape {}
struct Case3: Codable {
    var shape: Shape
}
// error: type 'Case3' does not conform to protocol 'Decodable'
// note: cannot automatically synthesize 'Decodable' because
//       'Shape' does not conform to 'Decodable'

class Animal: Codable {
    var name: String = ""
}
class Dog: Animal {
    var breed: String = ""   // 새 저장 프로퍼티를 추가했을 뿐, Codable을 다시 선언하지 않음
}

let dog = Dog()
dog.name = "바둑이"; dog.breed = "진돗개"
let data = try! JSONEncoder().encode(dog)
print(String(data: data, encoding: .utf8)!)
// {"name":"바둑이"}                 ← breed가 통째로 빠졌다, 에러 없음

let incoming = #"{"name":"흰둥이","breed":"말티즈"}"#.data(using: .utf8)!
let decoded = try! JSONDecoder().decode(Dog.self, from: incoming)
print(decoded.name, decoded.breed)
// 흰둥이                            ← breed는 JSON에 있어도 무시되고 기본값 "" 그대로

// ❌ UIColor는 Codable이 아니라 컴파일 에러
struct BadgeStyleBroken: Codable {
    var tint: UIColor
}

// ✅ 실제로 저장하는 값은 hex 문자열, UIColor는 계산 프로퍼티로만 노출
struct BadgeStyle: Codable {
    var tintHex: String     // 예: "#FF6B00"
    var tint: UIColor {
        UIColor(hex: tintHex) ?? .systemOrange
    }
}

final class Dog: Animal {
    var breed: String = ""

    private enum CodingKeys: String, CodingKey { case breed }

    required init(from decoder: Decoder) throws {
        let c = try decoder.container(keyedBy: CodingKeys.self)
        breed = try c.decode(String.self, forKey: .breed)
        try super.init(from: decoder)   // 같은 decoder를 넘겨 name도 함께 복원
    }
    override func encode(to encoder: Encoder) throws {
        try super.encode(to: encoder)   // name을 먼저 쓰고
        var c = encoder.container(keyedBy: CodingKeys.self)
        try c.encode(breed, forKey: .breed)   // 이어서 breed
    }
}

struct Car: Codable {
    var name: String
    var speed: Int = 100   // CodingKeys에서 뺐지만 기본값이 있어 합성은 통과

    enum CodingKeys: String, CodingKey {
        case name
    }
}

let car = Car(name: "소나타", speed: 220)
let data = try! JSONEncoder().encode(car)
print(String(data: data, encoding: .utf8)!)
// {"name":"소나타"}                       ← speed 자체가 안 나온다

let incoming = #"{"name":"아반떼","speed":180}"#.data(using: .utf8)!
let decoded = try! JSONDecoder().decode(Car.self, from: incoming)
print(decoded.name, decoded.speed)
// 아반떼 100                              ← JSON에 180이 와도 무시, 기본값 100 그대로

struct Car: Codable {
    var name: String
    var speed: Int   // CodingKeys에서 뺐는데 기본값도 옵셔널도 아님

    enum CodingKeys: String, CodingKey {
        case name
    }
}
// error: type 'Car' does not conform to protocol 'Decodable'
// note: cannot automatically synthesize 'Decodable' because 'speed'
//       does not have a matching CodingKey and does not have a default value

struct Config: Codable {
    let version: Int = 1   // let + 초기값 -> 디코딩되지 않음
    var name: String
}
// warning: immutable property will not be decoded because it is declared
//          with an initial value which cannot be overwritten
// note: set the initial value via the initializer or explicitly define a
//       CodingKeys enum including a 'version' case to silence this warning
// note: make the property mutable instead

let incoming = #"{"version":99,"name":"설정A"}"#.data(using: .utf8)!
let decoded = try! JSONDecoder().decode(Config.self, from: incoming)
print(decoded.version, decoded.name)   // 1 설정A          ← 99가 아니라 고정값 1
print(String(data: try! JSONEncoder().encode(decoded), encoding: .utf8)!)
// {"name":"설정A","version":1}                            ← encode는 정상적으로 1을 내보낸다

struct ArticleDTO: Codable {
    var title: String
    var body: String
    var isBookmarkedLocally: Bool = false   // 로컬 북마크 UI 상태, 서버 개념 아님

    enum CodingKeys: String, CodingKey {
        case title, body   // isBookmarkedLocally는 의도적으로 제외
    }
}
// 서버가 이 필드를 보내도 무시되고, 우리가 저장/전송할 때도 안 나간다

struct CachedProfile: Codable {
    // schemaVersion은 항상 2로 고정한다: 디스크의 옛 캐시(v1)를 읽어도
    // 메모리 위에서는 최신 스키마 취급하기 위한 의도적 let. 디코딩 안 됨.
    let schemaVersion: Int = 2
    var nickname: String

    enum CodingKeys: String, CodingKey { case schemaVersion, nickname }
}

// 입력: {"city":"Seoul","main":{"temp":23.5,"humidity":60},"coord":[37.5665,126.978]}
struct WeatherReport {
    var city: String
    var temp: Double
    var humidity: Int
    var latitude: Double
    var longitude: Double
}

extension WeatherReport: Codable {
    enum CodingKeys: String, CodingKey { case city, main, coord }
    enum MainKeys: String, CodingKey { case temp, humidity }

    init(from decoder: Decoder) throws {
        // 1) keyed container — 최상위 { } 를 키로 접근
        let top = try decoder.container(keyedBy: CodingKeys.self)
        city = try top.decode(String.self, forKey: .city)

        // 2) nestedContainer — "main" 중첩 객체를 별도 keyed container로 펼침
        let main = try top.nestedContainer(keyedBy: MainKeys.self, forKey: .main)
        temp = try main.decode(Double.self, forKey: .temp)
        humidity = try main.decode(Int.self, forKey: .humidity)

        // 3) unkeyed container — "coord" 배열은 순서로 접근
        var coord = try top.nestedUnkeyedContainer(forKey: .coord)
        latitude = try coord.decode(Double.self)
        longitude = try coord.decode(Double.self)
    }

    func encode(to encoder: Encoder) throws {
        var top = encoder.container(keyedBy: CodingKeys.self)
        try top.encode(city, forKey: .city)

        var main = top.nestedContainer(keyedBy: MainKeys.self, forKey: .main)
        try main.encode(temp, forKey: .temp)
        try main.encode(humidity, forKey: .humidity)

        var coord = top.nestedUnkeyedContainer(forKey: .coord)
        try coord.encode(latitude)
        try coord.encode(longitude)
    }
}

let decoded = try! JSONDecoder().decode(WeatherReport.self, from: json.data(using: .utf8)!)
print(decoded)
// WeatherReport(city: "Seoul", temp: 23.5, humidity: 60, latitude: 37.5665, longitude: 126.978)
print(String(data: try! JSONEncoder().encode(decoded), encoding: .utf8)!)
// {"city":"Seoul","coord":[37.5665,126.978],"main":{"temp":23.5,"humidity":60}}

struct Celsius: Codable {
    var value: Double
    init(from decoder: Decoder) throws {
        let single = try decoder.singleValueContainer()
        value = try single.decode(Double.self)
    }
    func encode(to encoder: Encoder) throws {
        var single = encoder.singleValueContainer()
        try single.encode(value)
    }
}
let temp = try! JSONDecoder().decode(Celsius.self, from: "23.5".data(using: .utf8)!)
print(temp.value)   // 23.5 — JSON 최상위가 그냥 숫자 하나였다

// 서버: {"data":{"id":1,"name":"item"},"meta":{"page":1}}
struct Item: Codable {
    var id: Int
    var name: String
    var page: Int   // meta.page를 최상위로 끌어올림

    enum CodingKeys: String, CodingKey { case data, meta }
    enum DataKeys: String, CodingKey { case id, name }
    enum MetaKeys: String, CodingKey { case page }

    init(from decoder: Decoder) throws {
        let top = try decoder.container(keyedBy: CodingKeys.self)
        let data = try top.nestedContainer(keyedBy: DataKeys.self, forKey: .data)
        id = try data.decode(Int.self, forKey: .id)
        name = try data.decode(String.self, forKey: .name)
        let meta = try top.nestedContainer(keyedBy: MetaKeys.self, forKey: .meta)
        page = try meta.decode(Int.self, forKey: .page)
    }
    func encode(to encoder: Encoder) throws { /* 대칭 구현 생략 */ }
}

init(from decoder: Decoder) throws {
    var arr = try decoder.unkeyedContainer()
    var results: [Int] = []
    while !arr.isAtEnd {
        results.append(try arr.decode(Int.self))
    }
    self.values = results
}

class Animal: Codable {
    var name: String
    init(name: String) { self.name = name }
    enum CodingKeys: String, CodingKey { case name }
    required init(from decoder: Decoder) throws {
        let c = try decoder.container(keyedBy: CodingKeys.self)
        name = try c.decode(String.self, forKey: .name)
    }
    func encode(to encoder: Encoder) throws {
        var c = encoder.container(keyedBy: CodingKeys.self)
        try c.encode(name, forKey: .name)
    }
}

class Cat: Animal {
    var name2: String
    enum CodingKeys: String, CodingKey { case name2 = "name" }  // 의도치 않게 겹침

    init(name: String, name2: String) { self.name2 = name2; super.init(name: name) }
    override func encode(to encoder: Encoder) throws {
        var c = encoder.container(keyedBy: CodingKeys.self)
        try c.encode(name2, forKey: .name2)     // "name" 키에 먼저 씀
        try super.encode(to: encoder)            // Animal도 같은 "name" 키에 다시 씀
    }
    required init(from decoder: Decoder) throws { fatalError() }
}

let cat = Cat(name: "고양이-원본", name2: "야옹이-대체값")
print(String(data: try! JSONEncoder().encode(cat), encoding: .utf8)!)
// {"name":"고양이-원본"}   ← name2("야옹이-대체값")는 통째로 사라졌다, 에러 없음

class Dog: Animal {
    var breed: String
    init(name: String, breed: String) { self.breed = breed; super.init(name: name) }
    enum CodingKeys: String, CodingKey { case breed }

    required init(from decoder: Decoder) throws {
        let c = try decoder.container(keyedBy: CodingKeys.self)
        breed = try c.decode(String.self, forKey: .breed)
        let superDecoder = try c.superDecoder()   // "super" 키 아래 별도 디코더
        try super.init(from: superDecoder)
    }
    override func encode(to encoder: Encoder) throws {
        var c = encoder.container(keyedBy: CodingKeys.self)
        try c.encode(breed, forKey: .breed)
        let superEncoder = c.superEncoder()       // "super" 키 아래 별도 인코더
        try super.encode(to: superEncoder)
    }
}

let dog = Dog(name: "바둑이", breed: "진돗개")
let data = try! JSONEncoder().encode(dog)
print(String(data: data, encoding: .utf8)!)
// {"breed":"진돗개","super":{"name":"바둑이"}}   ← name이 "super" 아래로 격리됨

let decoded = try! JSONDecoder().decode(Dog.self, from: data)
print(decoded.name, decoded.breed)   // 바둑이 진돗개 — 왕복 성공

class Pet: Animal {
    var ownerName: String
    enum CodingKeys: String, CodingKey { case ownerName }
    override func encode(to encoder: Encoder) throws {
        var c = encoder.container(keyedBy: CodingKeys.self)
        try c.encode(ownerName, forKey: .ownerName)
        try super.encode(to: c.superEncoder())   // Animal 몫은 한 단계 더 깊이 격리
    }
    // init(from:)도 대칭으로 구현
}
// 결과 JSON: {"breed":"진돗개","ownerName":"김철수","super":{"super":{"name":"바둑이"}}}

struct AnimalInfo: Codable { var name: String }
struct Dog: Codable {
    var animal: AnimalInfo   // 상속 대신 포함 — CodingKeys 충돌 걱정 자체가 없음
    var breed: String
}

enum AppEvent: Codable {
    case login(userId: String)   // 레이블 있는 연관값 1개
    case purchase(String, Int)   // 레이블 없는 연관값 2개 -> _0, _1
    case logout                  // 연관값 없음
}

let events: [AppEvent] = [.login(userId: "u_42"), .purchase("sku_100", 3), .logout]
let encoder = JSONEncoder()
encoder.outputFormatting = [.sortedKeys]
for e in events {
    print(String(data: try! encoder.encode(e), encoding: .utf8)!)
}
// {"login":{"userId":"u_42"}}
// {"purchase":{"_0":"sku_100","_1":3}}
// {"logout":{}}                          ← 문자열 "logout"이 아니라 빈 객체다

let decoded = try! JSONDecoder().decode([AppEvent].self, from: try! encoder.encode(events))
print(decoded)
// [AppEvent.login(userId: "u_42"), AppEvent.purchase("sku_100", 3), AppEvent.logout]  ← 왕복 성공

enum AnalyticsEvent: Codable {
    case screenView(name: String)
    case buttonTap(id: String, screen: String)
    case appLaunched
}
// 디스크에 줄 단위 JSON Lines로 append — 서버 계약이 없으니 합성 모양 그대로 OK
let line = try! JSONEncoder().encode(AnalyticsEvent.screenView(name: "Home"))

// ❌ SE-0295 합성을 그대로 쓰면 {"login":{"userId":"u_42"}} 모양만 나온다
// enum ServerEvent: Codable { case login(userId: String) }

// ✅ {"type":"login","userId":"u_42"} 모양이 필요하면 init(from:)을 직접 짠다 — 20장 Q3 참고
struct ServerEvent: Codable {
    let type: String
    let userId: String?
    // ... type으로 분기하는 커스텀 init(from:)
}