import SwiftUI

struct ContentView: View {
    @Environment(TestObservable.self) var testObservable
    
    var body: some View {
        Text(testObservable.name)
        Button {
            testObservable.changeName(name: "旧姓")
        } label: {
            Text("旧姓")
        }
        Button {
            testObservable.refreshName()
        } label: {
            Text("新姓")
        }
    }
}

@Observable
class TestObservable {
    var name: String
    
    init() {
        self.name = "新姓"
    }
    
    func refreshName() {
        self.name = "新姓"
    }
    
    func changeName(name: String) {
        self.name = name
    }
}

#Preview {
    ContentView()
        .environment(TestObservable())
}

import SwiftUI

@main
struct SwiftUILearnApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
                .environment(TestObservable())
        }
    }
}

CKContainer(identifier: <your container ID>)

let container = CKContainer.defualt()

let container = CKContainer(identifier: <your container ID>)

async let 非同期1 = await 遅延関数1(1)

//順番に実行されます
print("after1")

//順番に実行されます
let 普通2 = 関数1(2)

//順番に実行されます
print("after2")

//同一関数は一度に一つしか実行されません
async let 非同期3 = await 遅延関数1(3)

//順番に実行されます
print("after3")

//遅延関数1とは異なる関数なので遅延関数1が終わるより先に実行されます
async let 非同期4 = await 遅延関数2(4)

//順番に実行されます
print("after4")

//順番に実行されます
let 普通4 = 関数1(5)

//順番に実行されます
print("after5")

/*
after1
Check Number: 2
after2
after3
after4
Check Number: 5
Check Number: 4
after5
Check Number: 1
Check Number: 3
*/


func 遅延関数1(_ check: Int) async -> String {
    for _ in 1...1000000 {
    }
    print("Check Number: \(check)")
    return ("遅延1-\(check)")
}
func 遅延関数2(_ check: Int) async -> String {
    for _ in 1...100000 {
    }
    print("Check Number: \(check)")
    return ("遅延2-\(check)")
}


func 関数1(_ check: Int) -> String {
    print("Check Number: \(check)")
    return ("普通\(check)")
}

enum Seasons {
    case Spring
    case Summer
    case Autumn
    case Winter
}

var myFavorite = Seasons.Spring

switch myFavorite {
    case .Spring:
        print("どことなく気持ちが浮かれますよね")
    case .Summer:
        print("何かしなくちゃって気がせきますね")
    case .Autumn:
        print("旅に出たくなりますよね")
    case .Winter:
        print("一人が落ち着きますよね")
}

//どことなく気持ちが浮かれますよね

enum Seasons: CaseIterable {
    case Spring
    case Summer
    case Autumn
    case Winter
}

enum Seasons: CaseIterable {
    case Spring(month: String)
    case Summer(month: String)
    case Autumn(month: String)
    case Winter(month: String)
}

enum E干支時刻: CaseIterable {
	//associated Value
	case eto(kanji: String, yomi: String, startJi: Int, shouJi: Int, endJi: Int)

	//CaseIterableプロトコルに準拠させる為
	//allCasesをassociated Valueを具体化して定義します。
	static var allCases: [E干支時刻] {
		return [.eto(kanji: "子", yomi: "ね", startJi: 23, shouJi: 0, endJi: 1),
			.eto(kanji: "丑", yomi: "うし", startJi: 1, shouJi: 2, endJi: 3),
			.eto(kanji: "寅", yomi: "とら", startJi: 3, shouJi: 4, endJi: 5),
			.eto(kanji: "卯", yomi: "う", startJi: 5, shouJi: 6, endJi: 7),
			.eto(kanji: "辰", yomi: "たつ", startJi: 7, shouJi: 8, endJi: 9),
			.eto(kanji: "巳", yomi: "み", startJi: 9, shouJi: 10, endJi: 11),
			.eto(kanji: "午", yomi: "うま", startJi: 11, shouJi: 12, endJi: 13),
			.eto(kanji: "未", yomi: "ひつじ", startJi: 13, shouJi: 14, endJi: 15),
			.eto(kanji: "申", yomi: "さる", startJi: 15, shouJi: 16, endJi: 17),
			.eto(kanji: "酉", yomi: "とり", startJi: 17, shouJi: 18, endJi: 19),
			.eto(kanji: "戌", yomi: "いぬ", startJi: 19, shouJi: 20, endJi: 21),
			.eto(kanji: "亥", yomi: "い", startJi: 21, shouJi: 22, endJi: 23)]
	}
}

E干支時刻.allCases.forEach { e干支時刻 in
	switch e干支時刻 {
	case .eto(let kanji, let yomi, let startJi, let shouJi, let endJi):
			print("\(kanji)(\(yomi))の刻は \(startJi)時から\(endJi)時です。正\(kanji)は\(shouJi)時です。")
	}
}
/*
子(ね)の刻は 23時から1時です。正子は0時です。
丑(うし)の刻は 1時から3時です。正丑は2時です。
寅(とら)の刻は 3時から5時です。正寅は4時です。
卯(う)の刻は 5時から7時です。正卯は6時です。
辰(たつ)の刻は 7時から9時です。正辰は8時です。
巳(み)の刻は 9時から11時です。正巳は10時です。
午(うま)の刻は 11時から13時です。正午は12時です。
未(ひつじ)の刻は 13時から15時です。正未は14時です。
申(さる)の刻は 15時から17時です。正申は16時です。
酉(とり)の刻は 17時から19時です。正酉は18時です。
戌(いぬ)の刻は 19時から21時です。正戌は20時です。
亥(い)の刻は 21時から23時です。正亥は22時です。
*/

protocol PersonProtocol {
	var name: String {get set}
}

//protocol PersonProtocol に準拠したprotocol AdultPersonProtocolを定義します
protocol AdultPersonProtocol: PersonProtocol {
	var job: String {get set}
}

//protocol PersonProtocol に準拠したstruct PersonAを定義します
struct PersonA: PersonProtocol {
	var name: String
	init(){
		name = ""
	}
}

//protocol AdultPersonProtocolに準拠したstruct PersonBを定義します
struct PersonB: AdultPersonProtocol {
	var name: String
	var job: String
	init(){
		name = ""
		job = ""
	}
}

//struct PersonAを実装したpersonAを定義します
var personA = PersonA()
personA.name = "子供店長"

//struct PersonBを実装したpersonBを定義します
var personB = PersonB()
personB.name = "大人店長"
personB.job = "サラリーマン"

//ここでprotocol PersonProtocolをfuncの引数personの型に設定します
func printName(_ person: PersonProtocol) {
	//protocol PersonProtocolのプロパティnameに設定された値を表示します
	print(person.name)
}

printName(personA)
//子供店長
printName(personB)
//大人店長  

struct TestStruct {
	var sampleStruct: String 
	init(){
		sampleStruct = ""
	}
}

class TestClass {
	var sampleClass: String 
	init(){
		sampleClass = ""
	}
}

var testStruct = TestStruct()
var testClass = TestClass()

testStruct.sampleStruct = "Hello"
testClass.sampleClass = "Hello"

var ts1 = testStruct
var ts2 = testStruct
var tc1 = testClass
var tc2 = testClass

ts1.sampleStruct = "なんでやねん"
tc1.sampleClass = "なんでやねん"

print("structは値渡しなのでts2.sampleStructは\(ts2.sampleStruct)のままです。")
//structは値渡しなのでts2.sampleStructはHelloのままです。
print("classは参照渡しなのでtc2.sampleClassは\(tc2.sampleClass)に変わります。")
//classは参照渡しなのでtc2.sampleClassはなんでやねんに変わります。