struct FoodTruck {
    var pizzaPrice: Int
}

struct FoodTruck {
    // 1. 최대 금액 설정
    private var maxPrice: Int = 10000
    // 2. 접근 제어자를 Private으로 해줌으로써 직접 접근 방지
    private var _pizzaPrice: Int
    
    // 3. setter를 이용하여 값 저장시 maxPrice을 넘을 수 없게 함. 
    var pizzaPrice: Int {
        get { return _pizzaPrice }
        set { _pizzaPrice = min(newValue, maxPrice)}
    }
}

struct FoodTruck {
    private var maxPrice: Int = 10000
    private var _pizzaPrice: Int
    private var _pastaPrice: Int
    private var _chickenPrice: Int
    private var _soupPrice: Int
    private var _kimchiPrice: Int
    
    
    var pizzaPrice: Int {
        get { return _pizzaPrice }
        set { _pizzaPrice = min(newValue, maxPrice)}
    }
    
    var pastaPrice: Int {
        get { return _pastaPrice }
        set { _pastaPrice = min(newValue, maxPrice)}
    }
    
    var chickenPrice: Int {
        get { return _chickenPrice }
        set { _chickenPrice = min(newValue, maxPrice)}
    }
    
    var soupPrice: Int {
        get { return _soupPrice }
        set { _soupPrice = min(newValue, maxPrice)}
    }
    
    var kimchiPrice: Int {
        get { return _kimchiPrice }
        set { _kimchiPrice = min(newValue, maxPrice)}
    }
}

struct FoodTruck {
    
    enum Food {
        case pizza
        case pasta
        case chicken
        case soup
        case kimchi
    }
    
    private var maxPrice: Int = 10000
    private var pizzaPrice: Int
    private var pastaPrice: Int
    private var chickenPrice: Int
    private var soupPrice: Int
    private var kimchiPrice: Int
    
    func getPrice(_ food: Food) -> Int {
        switch food {
        case .pizza: return pizzaPrice
        case .pasta: return pastaPrice
        case .chicken: return chickenPrice
        case .soup: return soupPrice
        case .kimchi: return kimchiPrice
        }
    }
    
    mutating func setPrice(food: Food, price: Int) {
        let realPrice = min(price, maxPrice)
        switch food {
        case .pizza: self.pizzaPrice = realPrice
        case .pasta: self.pastaPrice = realPrice
        case .chicken: self.chickenPrice = realPrice
        case .soup: self.soupPrice = realPrice
        case .kimchi: self.kimchiPrice = realPrice
        }
    }
}

@propertyWrapper
struct MaxPriceOrLessWrapper {
    private var max = 10000
    private var value = 0
    
    var wrappedValue: Int {
        get { return value }
        set { value = min(newValue,max) }
    }
}

struct FoodTruck {
    @MaxPriceOrLessWrapper var pizzaPrice: Int
    @MaxPriceOrLessWrapper var pastaPrice: Int
    @MaxPriceOrLessWrapper var chickenPrice: Int
    @MaxPriceOrLessWrapper var soupPrice: Int
    @MaxPriceOrLessWrapper var kimchiPrice: Int
}

@propertyWrapper
struct MaxPriceOrLessWrapper {
    private var max: Int
    private var value: Int
    
    init(value: Int, maxPrice: Int) {
        self.max = maxPrice
        self.value = min(value, maxPrice)
    }
    
    var wrappedValue: Int {
        get { return value }
        set { value = min(newValue,max) }
    }
}

struct FoodTruck {
    @MaxPriceOrLessWrapper(value: 9000, maxPrice: 10000) 
    var pizzaPrice: Int
    
    @MaxPriceOrLessWrapper(value: 12000, maxPrice: 10000) 
    var pastaPrice: Int
    
    @MaxPriceOrLessWrapper(value: 7500, maxPrice: 10000) 
    var chickenPrice: Int
    
    @MaxPriceOrLessWrapper(value: 400, maxPrice: 500) 
    var soupPrice: Int
    
    @MaxPriceOrLessWrapper(value: 1000, maxPrice: 500) 
    var kimchiPrice: Int
}

struct UserDefaultManager {
    private static var ud = UserDefaults.standard
    
    static var userName: String {
        get {
            return ud.value(forKey: "userName") as? String ?? ""
        }
        set {
            ud.setValue(newValue, forKey: "userName")
        }
    }
    
    static var hasMembership: Bool {
        get {
            return ud.value(forKey: "hasMembership") as? Bool ?? false
        }
        set {
            ud.setValue(newValue, forKey: "hasMembership")
        }
    }
}

@propertyWrapper
struct UserDefaultWrapper {
    private let ud = UserDefaults.standard
    // 1. 키
    private let key: String
    // 2. 기본 값
    private var defaultValue: String
    // 3. wrappedValue 정의
    var wrappedValue: String {
        get {
            return ud.value(forKey: key) as? String ?? defaultValue
        }
        set {
            ud.setValue(newValue, forKey: key)
        }
    }
    // 4. 초기값 및 키 셋팅
    init(key: String, defaultValue: String) {
        self.key = key
        self.defaultValue = defaultValue
    }
}

struct UserDefaultManager {
    private static var ud = UserDefaults.standard
    
    // Property Wrapper 적용
    @UserDefaultWrapper(key: "userName", defaultValue: "")
    static var userName: String
    
    static var hasMembership: Bool {
        get {
            return ud.value(forKey: "hasMembership") as? Bool ?? false
        }
        set {
            ud.setValue(newValue, forKey: "hasMembership")
        }
    }
}

@propertyWrapper
struct UserDefaultWrapper<T> { // 1. 여기에 제네릭 써주고
    private let ud = UserDefaults.standard
    private let key: String
    
    // 2. 여기도 제네릭 써주고
    private var defaultValue: T
    
    // 3. 여기도 제네릭 써주고
    var wrappedValue: T {
        get {
            // 4. 여기도 제네릭 써주고
            return ud.value(forKey: key) as? T ?? defaultValue
        }
        set {
            ud.setValue(newValue, forKey: key)
        }
    }
    
    // 5. 여기도 제네릭 써주고
    init(key: String, defaultValue: T) {
        self.key = key
        self.defaultValue = defaultValue
    }
}

struct UserDefaultManager {
    
    @UserDefaultWrapper(key: "userName", defaultValue: "")
    static var userName: String
    
    @UserDefaultWrapper(key: "hasMembership", defaultValue: false)
    static var hasMembership: Bool
}

// Property Wrapper 적용 전 코드
struct UserDefaultManager {
    private static var ud = UserDefaults.standard
    
    static var userName: String {
        get {
            return ud.value(forKey: "userName") as? String ?? ""
        }
        set {
            ud.setValue(newValue, forKey: "userName")
        }
    }
    
    static var hasMembership: Bool {
        get {
            return ud.value(forKey: "hasMembership") as? Bool ?? false
        }
        set {
            ud.setValue(newValue, forKey: "hasMembership")
        }
    }
}

init(from decoder: Decoder) throws {}