// Property Wrapper 없이 UserDefaults 저장하는 코드
// 매번 이렇게 써야 했음... 진짜 노가다 ㅠㅠ

class UserSettings {
    var username: String {
        get {
            return UserDefaults.standard.string(forKey: "username") ?? ""
        }
        set {
            UserDefaults.standard.set(newValue, forKey: "username")
        }
    }
    
    var isDarkMode: Bool {
        get {
            return UserDefaults.standard.bool(forKey: "isDarkMode")
        }
        set {
            UserDefaults.standard.set(newValue, forKey: "isDarkMode")
        }
    }
    
    var fontSize: Double {
        get {
            return UserDefaults.standard.double(forKey: "fontSize")
        }
        set {
            UserDefaults.standard.set(newValue, forKey: "fontSize")
        }
    }
    // ... 이게 10개 20개면?? 😱
}

// Property Wrapper 사용 후 — 완전 깔끔 ✨

@propertyWrapper
struct UserDefault<T> {
    let key: String
    let defaultValue: T
    
    var wrappedValue: T {
        get {
            return UserDefaults.standard.object(forKey: key) as? T ?? defaultValue
        }
        set {
            UserDefaults.standard.set(newValue, forKey: key)
        }
    }
}

class UserSettings {
    @UserDefault(key: "username", defaultValue: "")
    var username: String
    
    @UserDefault(key: "isDarkMode", defaultValue: false)
    var isDarkMode: Bool
    
    @UserDefault(key: "fontSize", defaultValue: 16.0)
    var fontSize: Double
}

@propertyWrapper
struct MyWrapper<T> {
    
    // 1️⃣ 필수: wrappedValue — 실제 값을 저장/반환하는 핵심
    private var value: T
    
    var wrappedValue: T {
        get { value }
        set { value = newValue }
    }
    
    // 2️⃣ 선택: projectedValue — $변수명으로 접근
    var projectedValue: String {
        return "현재 값: \(value)"
    }
    
    // 3️⃣ 이니셜라이저
    init(wrappedValue: T) {
        self.value = wrappedValue
    }
}

// 사용법
struct Example {
    @MyWrapper var name: String = "Swift"
    
    func show() {
        print(name)        // wrappedValue 접근
        print($name)       // projectedValue 접근 → "현재 값: Swift"
    }
}

// 우리가 쓴 코드
@MyWrapper var name: String = "Swift"

// 컴파일러가 실제로 생성하는 코드 (개념적 표현)
private var _name: MyWrapper<String> = MyWrapper(wrappedValue: "Swift")

var name: String {
    get { _name.wrappedValue }
    set { _name.wrappedValue = newValue }
}

var $name: String {  // projectedValue
    get { _name.projectedValue }
}

@propertyWrapper
struct Clamped<T: Comparable> {
    private var value: T
    private let range: ClosedRange<T>
    
    var wrappedValue: T {
        get { value }
        set { value = min(max(newValue, range.lowerBound), range.upperBound) }
    }
    
    init(wrappedValue: T, _ range: ClosedRange<T>) {
        self.range = range
        self.value = min(max(wrappedValue, range.lowerBound), range.upperBound)
    }
}

// 사용 예시
struct GameCharacter {
    @Clamped(0...100) var health: Int = 100
    @Clamped(0.0...1.0) var opacity: Double = 1.0
    @Clamped(1...5) var starRating: Int = 3
}

var hero = GameCharacter()
hero.health = 150    // 자동으로 100으로 클램핑됨 ✅
hero.health = -50    // 자동으로 0으로 클램핑됨 ✅
print(hero.health)   // 0
hero.opacity = 2.5   // 자동으로 1.0으로 클램핑됨 ✅

@propertyWrapper
struct Trimmed {
    private var value: String = ""
    
    var wrappedValue: String {
        get { value }
        set { value = newValue.trimmingCharacters(in: .whitespacesAndNewlines) }
    }
    
    init(wrappedValue: String) {
        self.value = wrappedValue.trimmingCharacters(in: .whitespacesAndNewlines)
    }
}

struct UserProfile {
    @Trimmed var name: String = ""
    @Trimmed var email: String = ""
    @Trimmed var bio: String = ""
}

var profile = UserProfile()
profile.name = "  김스위프트  "
print(profile.name)  // "김스위프트" — 공백 자동 제거! ✨
profile.email = "  swift@example.com  "
print(profile.email) // "swift@example.com"

@propertyWrapper
struct Logged<T: CustomStringConvertible> {
    private var value: T
    private let label: String
    
    var wrappedValue: T {
        get { value }
        set {
            print("[\(label)] 변경: \(value) → \(newValue)")
            value = newValue
        }
    }
    
    // projectedValue로 현재 값의 문자열 표현 제공
    var projectedValue: String {
        return "\(label): \(value)"
    }
    
    init(wrappedValue: T, label: String) {
        self.value = wrappedValue
        self.label = label
    }
}

struct AppState {
    @Logged(label: "사용자 점수") var score: Int = 0
    @Logged(label: "레벨") var level: Int = 1
}

var state = AppState()
state.score = 100  // 콘솔: [사용자 점수] 변경: 0 → 100
state.score = 250  // 콘솔: [사용자 점수] 변경: 100 → 250
state.level = 2    // 콘솔: [레벨] 변경: 1 → 2

print($state.score) // projectedValue: "사용자 점수: 250"

@propertyWrapper
struct Validated {
    private var value: String
    private let validator: (String) -> Bool
    
    var wrappedValue: String {
        get { value }
        set { value = newValue }
    }
    
    // $변수명으로 유효성 여부 확인
    var projectedValue: Bool {
        return validator(value)
    }
    
    init(wrappedValue: String, validator: @escaping (String) -> Bool) {
        self.value = wrappedValue
        self.validator = validator
    }
}

struct SignUpForm {
    @Validated(validator: { email in
        let pattern = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}"
        return email.range(of: pattern, options: .regularExpression) != nil
    })
    var email: String = ""
    
    @Validated(validator: { $0.count >= 8 })
    var password: String = ""
    
    var isValid: Bool {
        return $email && $password  // projectedValue 사용!
    }
}

var form = SignUpForm()
form.email = "swift@example.com"
form.password = "mypassword123"

print($form.email)    // true — 유효한 이메일
print(form.isValid)   // true — 폼 전체 유효성 ✅

// @State의 개념적 구현 (실제 구현은 더 복잡함)
@propertyWrapper
struct State<T> {
    private var value: T
    
    var wrappedValue: T {
        get { value }
        nonmutating set {
            // 실제로는 SwiftUI 렌더링 엔진에 변경 알림
            value = newValue
            // → 뷰 재렌더링 트리거!
        }
    }
    
    // $변수명으로 Binding 반환
    var projectedValue: Binding<T> {
        Binding(
            get: { self.wrappedValue },
            set: { self.wrappedValue = $0 }
        )
    }
    
    init(wrappedValue: T) {
        self.value = wrappedValue
    }
}

// 실제 사용
struct CounterView: View {
    @State private var count: Int = 0  // wrappedValue
    
    var body: some View {
        VStack {
            Text("\(count)")           // count 직접 접근
            Stepper("카운트", value: $count)  // $count = Binding<Int>
        }
    }
}

// 여러 Wrapper 중첩 — 바깥쪽부터 안쪽으로 적용됨
struct UserInput {
    // Trimmed가 먼저 적용되고, 그 결과에 Validated 적용
    // 실제로 Swift는 단일 Wrapper만 직접 중첩 지원
    // 아래처럼 하나의 Wrapper에서 여러 기능을 조합하는 게 일반적
    
    @Trimmed var username: String = ""
    @Validated(validator: { !$0.isEmpty && $0.count >= 2 })
    var displayName: String = ""
}

// 더 나은 방법: 기능을 합친 새 Wrapper 만들기
@propertyWrapper
struct TrimmedAndValidated {
    private var value: String
    private let minLength: Int
    
    var wrappedValue: String {
        get { value }
        set { value = newValue.trimmingCharacters(in: .whitespacesAndNewlines) }
    }
    
    var projectedValue: Bool {
        return value.count >= minLength
    }
    
    init(wrappedValue: String, minLength: Int = 1) {
        self.value = wrappedValue.trimmingCharacters(in: .whitespacesAndNewlines)
        self.minLength = minLength
    }
}

struct Form {
    @TrimmedAndValidated(minLength: 2) var name: String = ""
    @TrimmedAndValidated(minLength: 8) var password: String = ""
}

var form = Form()
form.name = "  김개발  "
print(form.name)    // "김개발"
print($form.name)   // true (2글자 이상)

// 클래스 기반 Wrapper — 공유 상태 관리에 유용
@propertyWrapper
final class SharedStorage<T> {
    private var value: T
    private var observers: [(T) -> Void] = []
    
    var wrappedValue: T {
        get { value }
        set {
            value = newValue
            observers.forEach { $0(newValue) }  // 모든 옵저버에 알림
        }
    }
    
    var projectedValue: SharedStorage<T> {
        return self
    }
    
    init(wrappedValue: T) {
        self.value = wrappedValue
    }
    
    func observe(_ handler: @escaping (T) -> Void) {
        observers.append(handler)
    }
}

class ViewModel {
    @SharedStorage var theme: String = "라이트"
}

let vm = ViewModel()
$vm.theme.observe { newTheme in
    print("테마 변경됨: \(newTheme)")
}
vm.theme = "다크"  // 콘솔: 테마 변경됨: 다크

@propertyWrapper
struct SmartDefault<T> {
    var wrappedValue: T
    
    // 기본값으로 초기화
    init(wrappedValue: T) {
        self.wrappedValue = wrappedValue
    }
    
    // 클로저로 지연 초기화
    init(defaultProvider: () -> T) {
        self.wrappedValue = defaultProvider()
    }
}

struct Config {
    // 직접 값 지정
    @SmartDefault var maxRetries: Int = 3
    
    // 클로저로 복잡한 기본값 계산
    @SmartDefault(defaultProvider: {
        ProcessInfo.processInfo.processorCount * 2
    })
    var threadCount: Int
}

let config = Config()
print(config.maxRetries)   // 3
print(config.threadCount)  // CPU 코어 수 × 2

// Codable 친화적인 Property Wrapper
@propertyWrapper
struct DefaultEmpty: Codable {
    var wrappedValue: String
    
    init(wrappedValue: String = "") {
        self.wrappedValue = wrappedValue
    }
    
    init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        // null이거나 디코딩 실패 시 빈 문자열로 대체
        wrappedValue = (try? container.decode(String.self)) ?? ""
    }
    
    func encode(to encoder: Encoder) throws {
        var container = encoder.singleValueContainer()
        try container.encode(wrappedValue)
    }
}

@propertyWrapper
struct DefaultFalse: Codable {
    var wrappedValue: Bool
    
    init(wrappedValue: Bool = false) {
        self.wrappedValue = wrappedValue
    }
    
    init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        wrappedValue = (try? container.decode(Bool.self)) ?? false
    }
    
    func encode(to encoder: Encoder) throws {
        var container = encoder.singleValueContainer()
        try container.encode(wrappedValue)
    }
}

// 서버 응답에서 null 값이 올 수 있는 필드들
struct UserResponse: Codable {
    let id: Int
    @DefaultEmpty var nickname: String    // null이면 ""
    @DefaultEmpty var bio: String         // null이면 ""
    @DefaultFalse var isPremium: Bool     // null이면 false
    @DefaultFalse var isVerified: Bool    // null이면 false
}

// JSON: {"id": 1, "nickname": null, "isPremium": null}
// 파싱 결과: id=1, nickname="", bio="", isPremium=false, isVerified=false
// 에러 없이 안전하게 파싱됨! 🎉

struct Person {
    var name: String = "김스위프트"
    var age: Int = 25
    var email: String = "swift@example.com"
}

let person = Person()
let mirror = Mirror(reflecting: person)

// 타입 정보 확인
print(mirror.displayStyle)  // Optional(struct)
print(mirror.subjectType)   // Person

// 모든 프로퍼티 순회
for child in mirror.children {
    if let label = child.label {
        print("\(label): \(child.value)")
    }
}
// 출력:
// name: 김스위프트
// age: 25
// email: swift@example.com

// 실용적인 활용: 자동 로깅 함수
func autoLog<T>(_ object: T) {
    let mirror = Mirror(reflecting: object)
    let typeName = String(describing: type(of: object))
    print("=== \(typeName) 상태 ===")
    for child in mirror.children {
        print("  \(child.label ?? "??"): \(child.value)")
    }
}

autoLog(person)
// === Person 상태 ===
//   name: 김스위프트
//   age: 25
//   email: swift@example.com

// Property Wrapper가 적용된 프로퍼티를 Mirror로 조회할 때
@propertyWrapper
struct Trackable<T> {
    var wrappedValue: T
    var projectedValue: Self { self }
    
    var isModified: Bool = false
    
    init(wrappedValue: T) {
        self.wrappedValue = wrappedValue
    }
    
    mutating func update(_ newValue: T) {
        wrappedValue = newValue
        isModified = true
    }
}

struct FormData {
    @Trackable var name: String = ""
    @Trackable var email: String = ""
}

var form = FormData()
form.name = "김개발"

// Mirror로 Wrapper 인스턴스 자체에 접근
let mirror = Mirror(reflecting: form)
for child in mirror.children {
    print("\(child.label ?? ""): \(child.value)")
}
// _name: Trackable<String>(wrappedValue: "김개발", isModified: false)
// _email: Trackable<String>(wrappedValue: "", isModified: false)
// 언더스코어(_)가 붙은 게 Wrapper 인스턴스야!

// Swift 5.9+ @Observable 매크로
// ObservableObject + @Published 조합을 대체
import Observation

@Observable  // 이게 매크로!
class UserViewModel {
    var name: String = ""
    var age: Int = 0
    var isLoggedIn: Bool = false
    // @Published 없어도 자동으로 관찰 가능!
}

// 컴파일러가 자동 생성하는 코드 (개념적):
// - _$observationRegistrar 추가
// - 각 프로퍼티에 willSet/didSet 관찰 코드 추가
// - ObservationIgnored 등 지원

// SwiftUI에서 사용
struct ContentView: View {
    @State private var vm = UserViewModel()  // @StateObject 대신 @State!
    
    var body: some View {
        Text(vm.name)
    }
}

enum LoadingState<T> {
    case idle
    case loading
    case success(T)
    case failure(Error)
}

@propertyWrapper
struct AsyncState<T> {
    private var state: LoadingState<T> = .idle
    
    var wrappedValue: LoadingState<T> {
        get { state }
        set { state = newValue }
    }
    
    // projectedValue로 편의 프로퍼티 제공
    var projectedValue: AsyncStateHelper<T> {
        AsyncStateHelper(state: state)
    }
}

struct AsyncStateHelper<T> {
    let state: LoadingState<T>
    
    var isLoading: Bool {
        if case .loading = state { return true }
        return false
    }
    
    var value: T? {
        if case .success(let v) = state { return v }
        return nil
    }
    
    var error: Error? {
        if case .failure(let e) = state { return e }
        return nil
    }
}

class ProductViewModel: ObservableObject {
    @Published @AsyncState var products: LoadingState<[String]>
    // 실제로는 @Published와 커스텀 Wrapper 조합이 복잡할 수 있음
    // 아래처럼 분리하는 게 더 현실적
    
    @Published var productState: LoadingState<[String]> = .idle
    
    func fetchProducts() async {
        productState = .loading
        do {
            // 네트워크 요청...
            let data = ["상품A", "상품B", "상품C"]
            productState = .success(data)
        } catch {
            productState = .failure(error)
        }
    }
}

// 멀티스레드 환경에서 안전한 프로퍼티 접근
@propertyWrapper
final class ThreadSafe<T> {
    private var value: T
    private let lock = NSLock()
    
    var wrappedValue: T {
        get {
            lock.lock()
            defer { lock.unlock() }
            return value
        }
        set {
            lock.lock()
            defer { lock.unlock() }
            value = newValue
        }
    }
    
    init(wrappedValue: T) {
        self.value = wrappedValue
    }
}

class DataManager {
    @ThreadSafe var cache: [String: Any] = [:]
    @ThreadSafe var requestCount: Int = 0
    
    func processRequest() {
        requestCount += 1  // 스레드 안전하게 증가
        // 여러 스레드에서 동시 접근해도 안전!
    }
}

// 간단한 의존성 컨테이너
class DependencyContainer {
    static let shared = DependencyContainer()
    private var dependencies: [String: Any] = [:]
    
    func register<T>(_ type: T.Type, factory: @escaping () -> T) {
        let key = String(describing: type)
        dependencies[key] = factory
    }
    
    func resolve<T>(_ type: T.Type) -> T? {
        let key = String(describing: type)
        if let factory = dependencies[key] as? () -> T {
            return factory()
        }
        return nil
    }
}

@propertyWrapper
struct Injected<T> {
    private var value: T?
    
    var wrappedValue: T {
        get {
            if let value = value { return value }
            guard let resolved = DependencyContainer.shared.resolve(T.self) else {
                fatalError("의존성 \(T.self)가 등록되지 않았습니다!")
            }
            return resolved
        }
    }
    
    init() {}
}

// 프로토콜 정의
protocol NetworkService {
    func fetch(url: String) async throws -> Data
}

// 실제 구현체
class RealNetworkService: NetworkService {
    func fetch(url: String) async throws -> Data {
        // 실제 네트워크 요청
        return Data()
    }
}

// 등록
DependencyContainer.shared.register(NetworkService.self) {
    RealNetworkService()
}

// 사용
class ViewModel {
    @Injected var networkService: NetworkService
    // 자동으로 DependencyContainer에서 주입됨!
}