struct FixedLengthRange {
    var firstValue: Int
    let length: Int
}

var rangeOfThreeItems = FixedLengthRange(firstValue: 0, length: 3)
// the range represents integer values 0, 1, and 2
rangeOfThreeItems.firstValue = 6
// the range now represents integer values 6, 7, and 8

let rangeOfFourItems = FixedLengthRange(firstValue: 0, length: 4)
// this range represents integer values 0, 1, 2, and 3
rangeOfFourItems.firstValue = 6
// this will report an error, even though firstValue is a variable property

class DataImporter {
    /*
    DataImporter is a class to import data from an external file.
    The class is assumed to take a nontrivial amount of time to initialize.
    */
    var filename = "data.txt"
    // the DataImporter class would provide data importing functionality here
}

class DataManager {
    lazy var importer = DataImporter()
    var data = [String]()
    // the DataManager class would provide data management functionality here
}

let manager = DataManager()
manager.data.append("Some data")
manager.data.append("Some more data")
// the DataImporter instance for the importer property has not yet been created

print(manager.importer.filename)
// the DataImporter instance for the importer property has now been created
// Prints "data.txt"

// 기하학적 모양에 대한 Point, Size, Rect 세 개의 구조체를 정의

// Point는 x와 y좌표를 캡슐화
struct Point {
    var x = 0.0, y = 0.0
}

// Size는 너비와 높이를 캡슐화
struct Size {
    var width = 0.0, height = 0.0
}

// Rect는 origin point와 size를 통해 사각형을 정의
struct Rect {
    var origin = Point()
    var size = Size()
    // 계산 프로퍼티 - center 정의
    var center: Point {
       // 처음 가운데 위치는 origin과 size에 의해 결정 - 가운데 위치를 명시적인 Point 값으로 저장 X
       // Rect는 center 계산 프로퍼티를 위한 커스텀 게터와 세터를 정의
       get {
            let centerX = origin.x + (size.width / 2)
            let centerY = origin.y + (size.height / 2)
            return Point(x: centerX, y: centerY)
        }

        set(newCenter) {
            origin.x = newCenter.x - (size.width / 2)
            origin.y = newCenter.y - (size.height / 2)
        }
    }
}

// 새로운 Rect 변수인 square 정의 - (0, 0)의 origin point와 10의 width와 height로 초기화
var square = Rect(origin: Point(x: 0.0, y: 0.0), size: Size(width: 10.0, height: 10.0))

// 최초값은 남겨두고 center 프로퍼티는 새로운 값인 (15, 15)로 할당
let initialSquareCenter = square.center
square.center = Point(x: 15.0, y: 15.0)

// center 프로퍼티를 세팅하는 것은 center의 세터를 호출하고, origin 프로퍼티에 저장된 x, y 값을 수정
// 정사각형은 새로운 위치로 옮겨진다
print("square.origin is now at (\(square.origin.x), \(square.origin.y))")
// Prints "square.origin is now at (10.0, 10.0)"

struct AlternativeRect {
    var origin = Point()
    var size = Size()
    var center: Point {
        get {
            let centerX = origin.x + (size.width / 2)
            let centerY = origin.y + (size.height / 2)
            return Point(x: centerX, y: centerY)
        }

        set {
            origin.x = newValue.x - (size.width / 2)
            origin.y = newValue.y - (size.height / 2)
        }
    }
}

struct CompactRect {
    var origin = Point()
    var size = Size()
    var center: Point {
        get {
            Point(x: origin.x + (size.width / 2),
                  y: origin.y + (size.height / 2))
        }

        set {
            origin.x = newValue.x - (size.width / 2)
            origin.y = newValue.y - (size.height / 2)
        }
    }
}

struct Cuboid {
    var width = 0.0, height = 0.0, depth = 0.0
    var volume: Double {
        return width * height * depth
    }
}

let fourByFiveByTwo = Cuboid(width: 4.0, height: 5.0, depth: 2.0)
print("the volume of fourByFiveByTwo is \(fourByFiveByTwo.volume)")
// Prints "the volume of fourByFiveByTwo is 40.0"

// Int의 totalSteps 프로퍼티를 선언
// willSet 및 didSet 옵서버는 속성에 새 값이 할당될 때마다 호출
class StepCounter {
    var totalSteps: Int = 0 {
        willSet(newTotalSteps) {
            print("About to set totalSteps to \(newTotalSteps)")
        }

        didSet {
            if totalSteps > oldValue  {
                print("Added \(totalSteps - oldValue) steps")
            }
        }
    }
}

let stepCounter = StepCounter()
stepCounter.totalSteps = 200
// About to set totalSteps to 200
// Added 200 steps

stepCounter.totalSteps = 360
// About to set totalSteps to 360
// Added 160 steps

stepCounter.totalSteps = 896
// About to set totalSteps to 896
// Added 536 steps

// TwelveOrLess 구조체는 그것이 감싸는 값이 항상 12 이하의 숫자를 포함한다는 것을 보장
@propertyWrapper
struct TwelveOrLess {
    // number의 선언은 private으로 표시
    // number 프로퍼티는 오직 TwelveOrLess의 구현에서만 사용될 수 있다는 의미
    private var number: Int
    init() { self.number = 0 }

    // wrappedValue 프로퍼티를 정의하여 프로퍼티 래퍼 구성
    // 세터는 새로운 값이 항상 12 이하임을 보장하고, 게터는 저장된 값을 반환
    var wrappedValue: Int {
        get { return number }
        set { number = min(newValue, 12) }
    }
}

// 래퍼의 이름을 프로퍼티 전에 속성처럼 표기하여 프로퍼티에 래퍼를 적용 가능
struct SmallRectangle {
    @TwelveOrLess var height: Int
    @TwelveOrLess var width: Int
}

var rectangle = SmallRectangle()
print(rectangle.height)
// Prints "0"
// height와 width 프로퍼티는 TwelveOrLess로부터 초기 값 0을 갖게 된다

rectangle.height = 10
print(rectangle.height)
// Prints "10"
// 숫자 10을 rectangle.height에 저장하는 것은 성공

rectangle.height = 24
print(rectangle.height)
// Prints "12"
// 24를 저장하려 하면 세터의 규칙에 의해 12가 대신 저장

struct SmallRectangle {
    // _height와 _width 프로퍼티는 TwelveOrLess 프로퍼티 래퍼 인스턴스를 저장
    private var _height = TwelveOrLess()
    private var _width = TwelveOrLess()
    
    // height와 width에 대한 게터와 세터로 wrappedValue 프로퍼티에 접근 가능
    var height: Int {
        get { return _height.wrappedValue }
        set { _height.wrappedValue = newValue }
    }
    var width: Int {
        get { return _width.wrappedValue }
        set { _width.wrappedValue = newValue }
    }
}

// TwelveOrLess 구조체는 그것이 감싸는 값이 항상 12 이하의 숫자를 포함한다는 것을 보장
@propertyWrapper
struct TwelveOrLess {
    // number의 선언은 private으로 표시
    // number 프로퍼티는 오직 TwelveOrLess의 구현에서만 사용될 수 있다는 의미
    private var number: Int
    init() { self.number = 0 }

    // wrappedValue 프로퍼티를 정의하여 프로퍼티 래퍼 구성
    // 세터는 새로운 값이 항상 12 이하임을 보장하고, 게터는 저장된 값을 반환
    var wrappedValue: Int {
        get { return number }
        set { number = min(newValue, 12) }
    }
}

@propertyWrapper
struct SmallNumber {
    private var maximum: Int
    private var number: Int

    var wrappedValue: Int {
        get { return number }
        set { number = min(newValue, maximum) }
    }

    init() {
        maximum = 12
        number = 0
    }

    init(wrappedValue: Int) {
        maximum = 12
        number = min(wrappedValue, maximum)
    }

    init(wrappedValue: Int, maximum: Int) {
        self.maximum = maximum
        number = min(wrappedValue, maximum)
    }
}

struct ZeroRectangle {
    @SmallNumber var height: Int
    @SmallNumber var width: Int
}

var zeroRectangle = ZeroRectangle()
print(zeroRectangle.height, zeroRectangle.width)
// Prints "0 0"
// 초기 값 없이 프로퍼티에 래퍼를 적용할 때, Swift는 init() initializer를 사용

struct UnitRectangle {
    @SmallNumber var height: Int = 1
    @SmallNumber var width: Int = 1
}

var unitRectangle = UnitRectangle()
print(unitRectangle.height, unitRectangle.width)
// Prints "1 1"
// 프로퍼티에 초기 값을 지정한다면 Swift는 init(wrappedValue:) initializer를 사용해 래퍼를 설정

struct NarrowRectangle {
    @SmallNumber(wrappedValue: 2, maximum: 5) var height: Int
    @SmallNumber(wrappedValue: 3, maximum: 4) var width: Int
}

var narrowRectangle = NarrowRectangle()
print(narrowRectangle.height, narrowRectangle.width)
// Prints "2 3"
// 커스텀 속성(@SmallNumber) 소괄호 안에 인자를 전달하면, 
// Swift는 이 인자를 받아들이는 initializer를 사용해 래퍼를 설정
// ex. 초기 값과 maximam 값을 준다면 Swift는 init(wrappedValue:maximum:) initializer를 사용

narrowRectangle.height = 100
narrowRectangle.width = 100
print(narrowRectangle.height, narrowRectangle.width)
// Prints "5 4"
// maximam 값에 기반하여 결과가 도출

struct MixedRectangle {
    // height를 포장하는 SmallNumber의 인스턴스는 최댓값이 12인 SmallNumber(wrappedValue: 1)을 호출하며, 
    // width를 감싸는 인스턴스는 SmallNumber(wrappedValue: 2, maximum: 9)를 호출
    @SmallNumber var height: Int = 1
    @SmallNumber(maximum: 9) var width: Int = 2
}

var mixedRectangle = MixedRectangle()
print(mixedRectangle.height)
// Prints "1"

mixedRectangle.height = 20
print(mixedRectangle.height)
// Prints "12"

@propertyWrapper
struct SmallNumber {
    private var number: Int
    var projectedValue: Bool

    init() {
        self.number = 0
        self.projectedValue = false
    }

    var wrappedValue: Int {
        get { return number }
        set {
            if newValue > 12 {
                number = 12
                projectedValue = true
            } else {
                number = newValue
                projectedValue = false
            }
        }
    }
}

struct SomeStructure {
    @SmallNumber var someNumber: Int
}
var someStructure = SomeStructure()

someStructure.someNumber = 4
print(someStructure.$someNumber)
// Prints "false"

someStructure.someNumber = 55
print(someStructure.$someNumber)
// Prints "true"

enum Size {
    case small, large
}

struct SizedRectangle {
    @SmallNumber var height: Int
    @SmallNumber var width: Int

    mutating func resize(to size: Size) -> Bool {
        switch size {
        case .small:
            height = 10
            width = 20
        case .large:
            height = 100
            width = 100
        }
        return $height || $width
    }
}

var someSizedRectangle = SizedRectangle()

someSizedRectangle.height = 10
someSizedRectangle.width = 10
print(someSizedRectangle.$height, someSizedRectangle.$width)
// Prints "false, false"

someSizedRectangle.resize(to: .large)
print(someSizedRectangle.$height, someSizedRectangle.$width)
// Prints "true, true"

// 값 타입인 struct, enum의 타입 프로퍼티 정의 
struct SomeStructure {
    static var storedTypeProperty = "Some value."
    static var computedTypeProperty: Int {
        return 1
    }
}

enum SomeEnumeration {
    static var storedTypeProperty = "Some value."
    static var computedTypeProperty: Int {
        return 6
    }
}

// 레퍼 타입인 class의 타입 프로퍼티 정의
// class 키워드를 사용하여 해당 class를 상속 받을 경우 자식 클래스가 오버라이딩하여 재구성 가능 
class SomeClass {
    static var storedTypeProperty = "Some value."
    static var computedTypeProperty: Int {
        return 27
    }
    class var overrideableComputedTypeProperty: Int {
        return 107
    }
}

print(SomeStructure.storedTypeProperty)
// Prints "Some value."
SomeStructure.storedTypeProperty = "Another value."
print(SomeStructure.storedTypeProperty)
// Prints "Another value."
print(SomeEnumeration.computedTypeProperty)
// Prints "6"
print(SomeClass.computedTypeProperty)
// Prints "27"

// AudioChannel 구조체는 두 개의 저장 타입 프로퍼티를 정의
struct AudioChannel {
    // 상수 저장 타입 프로퍼티
    // 오디오 레벨이 가질 수 있는 최대 레벨 값을 정의
    // 모든 AudioChannel 인스턴스에 대해 10의 상수 값을 가짐
    static let thresholdLevel = 10

    // 변수 저장 타입 프로퍼티
    // 모든 AudioChannel 인스턴스에 의해 받는 최대 입력 값을 추적, 기본값 0
    static var maxInputLevelForAllChannels = 0

    // 변수 저장 인스턴스 프로퍼티 
    // 현재 오디오 레벨 값을 정의, 기본값 0
    // didSet 프로퍼티 옵저버를 통해서 값이 변할 때 마다 2가지 사항 체크
    var currentLevel: Int = 0 {
        didSet {
            if currentLevel > AudioChannel.thresholdLevel {
                // cap the new audio level to the threshold level
                // 만약 오디오 신호로 10보다 더 큰 값이 들어온다면, thresholdLevel 값으로 수정
                // didSet 관찰자는 currentLevel을 다른 값으로 설정하지만, 관찰자를 다시 호출하지는 않는다
                currentLevel = AudioChannel.thresholdLevel
            }
            if currentLevel > AudioChannel.maxInputLevelForAllChannels {
                // store this as the new overall maximum input level
                // 새로운 신호가 들어올 때 마다 비교하여 최대 값일 경우 maxInputLevelForAllChannels에 저장 
                AudioChannel.maxInputLevelForAllChannels = currentLevel
            }
        }
    }
}

// 스테레오를 위한 2채널 구성
var leftChannel = AudioChannel()
var rightChannel = AudioChannel()

// 만약 leftChannel의 currentLevel을 7로 설정한다면, 
// maxInputLevelForAllChannels 타입 프로퍼티는 7로 수정
leftChannel.currentLevel = 7
print(leftChannel.currentLevel)
// Prints "7"
print(AudioChannel.maxInputLevelForAllChannels)
// Prints "7"

// 만약 currentLevel에 11을 넣으려 한다면, 
// rightChannel의 currentLevel 프로퍼티는 최댓값인 10으로 정해지며
// maxInputLevelForAllChannels 프로퍼티 역시 10으로 수정
rightChannel.currentLevel = 11
print(rightChannel.currentLevel)
// Prints "10"
print(AudioChannel.maxInputLevelForAllChannels)
// Prints "10"