import Alamofire
// 예시(등록한 라이브러리가 import된다면 성공~~~)
// 코코아팟이랑 다른점은 또다른 프로젝트가 생성이되지 않음~

let x = 5             // struct, Stack에 저장
let y = User()    // class, Heap에 저장
let z = User() // class, Heap에 저장
 
         x   y        z
 [Stack] | 5 | 0x5F17 | 0x2C90 |
 // Stack -> 처음부터 만들어지는 시점, 크기가 지정되어짐
 
        0x2C90          0x5F16     0x5F17
 [Heap] | z's user data | SomeData | y's user data |
 // Heap -> 실제데이터는 힙에저장. 참조타입.

 --- in Memory ---
 값 타입(Value Type) - Stack
 참조 타입(Reference Type) - Stack -> Heap

class <#ClassName>: <#SuperClassName>, <#ProtocolName...> {
  // SuperClassName: 옵셔널, 상속받지않으면 생략가능
  // ProtocolName: 상속받지않으면 생략가능
   <#PropertyList>
   <#MethodList>
 }
 
 let <#objectName> = <#ClassName()> // 변수에 클래스를 상속
 objectName.<#propertyName>    
 objectName.<#functionName()>

class Dog {
  let name: String
  let color: String

  // init메서드를 다양하게 지정해줄 수 있다.
  init(name: String) {                                      
    // 컬러는 고정되어있는 init
    self.name = name
    color = "Brown"
  }
  init(name: String, color: String) {       
    // 두가지를 바꿀수있는 init
    self.name = name
    self.color = color
  }
  
  func bowwow() {
    print("Dog Bowwow!")
  }
}

class StoredProperty {
  var width = 0.0
  var height = 0.0
}

let stored = StoredProperty()
stored.width = 123
stored.height = 456
stored.width            // 123
stored.height            // 456
// 저장된 값을 사용

class LazyStoredProperty {
  var width = 10.0
  var height = 20.0
  
  // 1. 외부 요인이나 다른 설정에 기반
  lazy var area = self.width * self.height    
  // lazy를 붙여주면 초기화가 끝나지 않아도 사용이 가능(area를 호출할때 비로소 만들어지기 때문)
    
  // 2. 계산 비용이 많이 드는 상황
    lazy var hardWork = "실행하면 약 10초 이상 걸려야 하는 작업"
  // 화면을 띄우는순간 꼭 필요한 작업이 아닌데 lazy가아닌 일반 프로퍼티로 있으면 이작업을 실행후 화면을 띄울수 있기 때문에 사용자가 어떤 버튼을 눌렀을때만 필요한 작업이라면 미리할 필요가없기 때문에 이런상황에서 사용 
  
  // 3. 필요한 경우가 제한적인 상황(대부분 else로빠지는데 5% 상황만 true를 사용할때 메모리를 조금이라도 더아끼기 위해 초기화과정도 하지 않고 넘어가기 위해)
  func ifStatement() {
    if true {               // 5%
      print(area)
    } else {            // 95%
      print(width)
    }
  }
}

// Computed Property 사용
var <#variablename>: <#type> {
      get {
          <#statements>
      }
      set {
          <#variablename> = newValue
      }
  }
// 읽기전용 get, 쓸때는 set 도 붙임

class ComputedProperty {
  var width = 5.0
  var height = 5.0
  
  lazy var lazyArea = width * height
  var area: Double {        // 연산프로퍼티: 매번 새롭게 계산하기위해
    return width * height   // 읽기전용은 get생략 가능, 리턴도 생략 가능
  }
  
  // Stored + Computed get(read), set(write)
  private var _koreanWon = 0.0  // 저장프로포티
  var wonToDollar: Double {
    get {
      return _koreanWon / 1136.5
      // 저장프로퍼티의 값을 이용해서 연산을 함
    }
    set {
      _koreanWon = newValue 
      // set은 값을 저장할 수 없으므로, 저장프로퍼티를 이용한다.
     // newValue 값을넣으면 여기로 들어옴. set에 새로들어오는 값을 newValue에 저장.
    }
  }
}

var computed = ComputedProperty()
computed.area                            // 25
computed.lazyArea                    // 25

computed.width = 10
computed.area                            // 50
computed.lazyArea               // 위에서 최초 초기화를 시켰기에 그대로 25

computed.lazyArea = 50.0  // lazy는 호출된 이후엔 직접 값을 변경시켜줘야함
computed.lazyArea                    // 50

computed.width = 20
computed.height = 20
computed.area                          // 400
computed.lazyArea         // 바꿔준 50으로 나옴

computed.wonToDollar
computed.wonToDollar = 10000
computed.wonToDollar // 만원을 입력시 환율된값이 나오도록 연산프로퍼티를 만듬

// 저장프로퍼티 옵저버 사용
var <#variable> name: <#type> = <#value> {
    willSet {
        <#statements>
      // 변수의 값이 바뀌기 직전 호출
    }
    didSet {
        <#statments>
      // 변경된 직후 호출
    }
}

class PropertyObserver {
  var height = 0.0
  var width = 0.0 {
    willSet {
      print("willSet :", width, "->", newValue) // width = 0.0, newValue = 123.0
    }
    didSet {
      print("didSet :", oldValue, "->", width)  // old = 0.0 , width = 123.0
      height = width / 2
    }
  }
}

var obs = PropertyObserver()
obs.height = 456
obs.height

obs.width = 123
obs.width
/*
willSet : 0.0 -> 123.0
didSet : 0.0 -> 123.0
*/

// 타입프로퍼티 사용
선언 - static let(var) <#propertyName>: <#Type>
       class var <#propertyName>: <#Type> { return <#code> }
사용 - <#TypeName>.<#propertyName>
 
static: override 불가
class: 클래스에서만 사용 가능하고 computed property 형태로 사용. 서브클래스에서 override 가능

class TypeProperty {
  static var unit: String = "cm"    

  var width = 5.0
}

let square = TypeProperty() // 타입을 객체로 만들어서 프로포티에 접근
square.width                                

let square1 = TypeProperty()
square1.width = 10.0                // width의 값을 바꿔준다
square1.width

TypeProperty.unit   
//타입자체에서 프로포티에 접근하는 방식 = 타입 프로포티 // = "cm"
print("\(square.width) \(TypeProperty.unit)")                // 5.0 cm
print("\(square1.width) \(TypeProperty.unit)")            // 10.0 cm

TypeProperty.unit = "m" 
//단위를 전체적으로 바꾸고싶을때 unit자체를 바꿔준다. 모든 객체들이 공통으로 사용해야할 놈을 공유한다.
print("\(square.width) \(TypeProperty.unit)")                // 5.0 m
print("\(square1.width) \(TypeProperty.unit)")            // 10.0 m

class MyClass {
    // 저장 프로퍼티
    var value1 = 0
    // 지연 저장 : 호출했을 때 초기화
    lazy var value2 = value1 + 10
    // 연산
    var value3: Int {
        // 읽기
        get {
            let myValue = 50
            return value1 + myValue
        }
        // 쓰기
        set {
            let myValue = newValue + 10
            value1 = myValue + 20
        }
    }
    // 프로퍼티 옵저버
    var label = UILabel()
    var text = "" {
        willSet {
            label.text = newValue
        }   
        didSet {
            label.text = text
        }
    }
    var value4: Int = 100 {
        willSet {
            print("Value4가 \(value4)에서 \(newValue)으로 바뀔 것이다.")
        }   
        didSet {
            print("Value4가 \(oldValue)에서 \(value4)으로 바뀌었다.")
        }
    }
    // 타입
    static var value5: Int = 15
}
let myclass = MyClass()
myclass.value1          // 읽기
myclass.value1 = 10     // 쓰기
myclass.value2
myclass.value1 = 20
myclass.value2
myclass.value3 = 30
myclass.value1
myclass.value2
myclass.value3
myclass.value4 = 200
myclass.text = "집가고싶다"
MyClass.value5 = 25
MyClass.value5

viewDidLoad--[뷰가로드됨]
viewWillAppear--[뷰가나타날것임]
viewDidAppear--[뷰가나타났다]

----------- [ Nextvc viewDidLoad ] ----------

viewWillDisappear--[뷰가사라질것임]
Nextvc viewWillAppear--[뷰가나타날것임]
Nextvc viewDidAppear--[뷰가나타남]
viewDidDisappear--[뷰가사라졌다]

Nextvc viewWillDisappear--[뷰사라질것]
viewWillAppear--[뷰가나타날것임]
viewDidAppear--[뷰가나타났다]
Nextvc viewDidDisappear--[뷰사라짐]

------------- [ NextVc deinit: 메모리상의삭제됨 ] -----------

isModalInPresentation = true // 드래그로 끌어내려도 화면이 내려가지 않음
// FirstVC에서 넘겨줄때 사용해도되고, secondVC에서 직접 사용 할 수있음

presentingViewController?.view.backgroundColor = .orange
// 나를 띄운놈에게 접근해서 그놈의 값, 동작을 바꿔줄 수 있음
presentedViewController?.view.backgroundColor = .black
// 내가 띄운놈에게 접근해서 값, 동작 변경도 가능
        
// nextView -> View
presentedViewController -> nil // 내가띄운것 - nextvc -> 없음
presentingViewController -> ViewController // 나를띄움놈 - viewvc -> nextvc

// FiestVc -> SecondVC -> ThirdVC
presentingViewController?.presentingViewController.view.backgrond 
// 3번뷰에서 1번뷰의 변경시 단계를거쳐서 가는 방법이있음

// 3번에서 단계를 거치지않고 바로 닫고싶을경우
presentingViewController?.presentingViewController?.dismiss(animated: true)

guard let vc = presentingViewController as? ViewController else { return }
vc.button.setTitle("클릭", for: .normal)

nextVC.modalPresentationStyle = .fullScreen //풀스크린모드 (#available(iOS 12.0, *))
nextVC.modalPresentationStyle = .automatic //오토메틱모드 (#available(iOS 13.0, *)) = 카드형

let year: Int = 2019

let language: String
language = "Swift"

var red, green, blue: Double
red = 255.0
green = 150.123
blue = 75

let name: String = "Babo"
type(of: name)        // String.type

let age: Int = 7
type(of: age)            // Int.type

var weight = 48.3
type(of: weight)    // Double.type

var isDog = true
type(of: isDog)        // Bool.type

a > 0 ? "positive" : "zero or negative"

if a > 0 {        // 삼항연산자와 동일하게 동작
  "positive"
} else {
  "negative"
}

value += 1
//value = value + 1 위와같은
value -= 5
//value = value - 5
value *= 2
//value = value * 2
value /= 2
//value = value / 2
value %= 2
//value = value % 2    //나머지가 나옴

// 미지원 : value++, value--

// 실수에서의 나눗셈
let e = 123.4
let f = 5.678

e / f     // 단순히나누면 나머지가 틀림: 21.73300457907714

// 실수로 나머지를 구할때 사용
// 나머지 구하기 (내림)
e.truncatingRemainder(dividingBy: f)                                     // 4.162000000000007

// 나머지 구하기 계산 방법
let quotient = (e / f).rounded(.towardZero)                     // 몫: 21
let remainder = e.truncatingRemainder(dividingBy: f)  //나머지: 4.162000000000007
let sum = f * quotient + remainder                                        // 123.4
5.678 * 21                                                                                        // 119.238
5.678 * 21 + 4.162000000000007                                                // 123.4

// 범위 연산의 순서를 반대로(내림차순) 적용하려면?

// 반대 reversed
for index in (1...5).reversed() {
  print("\(index) times 5 is \(index * 5)")
}

//결화
5 times 5 is 25
4 times 5 is 20
3 times 5 is 15
2 times 5 is 10
1 times 5 is 5

// 10~1까지 -1로
for index in stride(from: 10, through: 1, by: -2) {
  print("\(index) times 5 is \(index * 5)")
}

//결과
10 times 5 is 50
8 times 5 is 40
6 times 5 is 30
4 times 5 is 20
2 times 5 is 10

// 기본유형
 func <함수이름> (<parameterName>: <Type>) -> <ReturnType> {
   <statements>
 }

func hello1() {
  print("Hello, world!")
}

//
func hello2() -> String {
  return "Hello, world!"
}

func say(number: Int) {
  print(number)
}
// void는 반환값이 없음 ()대체하거나 생략가능
func say(word: String) -> Void {
  print(word)
}

func say(something: String) -> () {
  print(something)
}

// 3개는 같음
say(number: 1)
say(word: "1")
say(something: "1")

func greet(person: String) -> String {
  let greeting = "Hello, " + person + "!"        // greet함수 내에서만 사용되는 상수(greeting)
  return greeting
}

greet(person: "Anna")        // 함수사용

func addNumbers(a: Int, b: Int) -> Int {
  return a + b 
 //한줄만 사용시 return생략 가능 , print를 붙이면 return도 붙여줘야함
}

let x = addNumbers(a: 10, b: 20)                     // x = 30
let y = addNumbers(a: 3, b: 5)                       // y = 8
x + y                                                                          // 38

let outside = "outside"
func scope() {                                    // 반환값이 없으므로 return 사용 안함
  print(outside)
  let inside = "inside"
  print(inside)
}

scope()                                                  // outside; inside;

func functionName(argumentName <parameterName>: <Type>) {
}

func someFunction(_ firstParam: Int, secondParam: Int) {
  print(firstParam, secondParam)
}

// someFunction(firstParameterName: 1, secondParameterName: 2)
someFunction(1, secondParam: 2)
// _를 넣으면 값만 넣을수있음

func summary(num1 a: Int, num2 b: Int) -> Int {
    a + b
} 
// 함수 내에서는 a, b로쓰이고 함수 밖에서는 따로 불러서 사용시엔 num1, num2로사용됌

summary(num1: 1, num2: 2)

func average(_ numbers: Double...) -> Double {
  var total = 0.0
  for a in numbers {
    total += a
  }
  return total / Double(numbers.count)
}

average(1, 2, 3, 4, 5)            // 3
average(3, 8.25, 18.75)            // 10

func average1(_ numbers: Double..., and last: Double) {       
  //네임의 끝을 지정해주거나 첫번째를 지정해줘야함
  print(numbers)
  print(last)
}

average1(1, 2, 3, and: 5)                            // [1.0, 2.0, 3.0]; 5.0;
average1(1,2,3,4,5,6, and: 8873646)        // [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]; 8873646.0;

/* 
함수 function1을 만들고, 그안에 또다른 함수를 중첩 해넣는다. 
if 문을 사용하여 function1의 함수의 파라미터 네임을 사용해 만들어서 true, false일때
다른값이 나오도록 한다.
*/
func function1(backward: Bool, value: Int) -> Int {
  func stepForward(input: Int) -> Int {
    return input + 1
  }
  func stepBackward(input: Int) -> Int {
    return input - 1
  }
  
  if backward {
    return stepBackward(input: value)
  } else {
    return stepForward(input: value)
  }
}

var value = 4
chooseStepFunction(backward: true, value: value)        // 3
chooseStepFunction(backward: false, value: value)        // 5

chooseStepFunction(backward: true, value: 3)                // 2
chooseStepFunction(backward: false, value: 3)                // 4