💡 TipKit

import SwiftUI
import TipKit

@main
struct MyApp: App {
    init() {
        // TipKit 초기화
        try? Tips.configure([
            // 개발 중: 앱 실행 시마다 팁 표시
            .displayFrequency(.immediate),

            // 프로덕션: 기본 정책 사용
            // .displayFrequency(.daily)

            // 데이터 저장 위치
            .datastoreLocation(.applicationDefault)
        ])
    }

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

import TipKit

struct FavoriteTip: Tip {
    // 팁 제목
    var title: Text {
        Text("즐겨찾기에 추가하세요")
    }

    // 팁 설명
    var message: Text? {
        Text("별 아이콘을 탭하면 자주 사용하는 항목을 빠르게 찾을 수 있어요")
    }

    // 팁 아이콘
    var image: Image? {
        Image(systemName: "star")
    }
}

// SwiftUI View에서 사용
struct ContentView: View {
    let favoriteTip = FavoriteTip()

    var body: some View {
        VStack {
            // 인라인 팁 (뷰에 직접 삽입)
            TipView(favoriteTip)

            Button("즐겨찾기 추가") {
                // 액션
            }
        }
        .padding()
    }
}

import SwiftUI
import TipKit

struct TipStylesView: View {
    let inlineTip = FavoriteTip()
    let popoverTip = SearchTip()

    var body: some View {
        VStack(spacing: 30) {
            // 1. 인라인 팁 (뷰 계층에 직접 삽입)
            TipView(inlineTip, arrowEdge: .top)

            Divider()

            // 2. 팝오버 팁 (특정 요소에 화살표로 연결)
            Button("검색") {
                // 검색 액션
            }
            .popoverTip(popoverTip)

            // 3. 커스텀 스타일 인라인 팁
            TipView(inlineTip) { action in
                // 액션 버튼 커스터마이즈
                if let action {
                    Button(action: action.handler) {
                        Text(action.label)
                            .foregroundStyle(.white)
                            .padding(8)
                            .background(Color.blue)
                            .cornerRadius(8)
                    }
                }
            }
        }
        .padding()
    }
}

// 검색 팁 정의
struct SearchTip: Tip {
    var title: Text {
        Text("빠른 검색")
    }

    var message: Text? {
        Text("⌘ + F로 빠르게 검색할 수 있어요")
    }

    var image: Image? {
        Image(systemName: "magnifyingglass")
    }
}

import TipKit

struct EditTip: Tip {
    // 사용자가 3개 항목을 생성했는지 추적
    @Parameter
    static var itemsCreated: Int = 0

    // 편집 기능을 사용했는지 추적
    static let hasEditedItem = Event(id: "hasEditedItem")

    var title: Text {
        Text("항목 편집하기")
    }

    var message: Text? {
        Text("항목을 길게 눌러서 편집할 수 있어요")
    }

    var image: Image? {
        Image(systemName: "pencil")
    }

    // 팁 표시 규칙
    var rules: [Rule] {
        [
            // 규칙 1: 3개 이상 항목을 생성했을 때
            #Rule(Self.$itemsCreated) { $0 >= 3 },

            // 규칙 2: 아직 편집을 한 번도 안 했을 때
            #Rule(Self.hasEditedItem) { $0.donations.count == 0 }
        ]
    }

    // 옵션: 표시 후 액션
    var actions: [Action] {
        [
            Action(id: "try-edit", title: "지금 해보기")
        ]
    }
}

// 사용 예제
struct ItemListView: View {
    let editTip = EditTip()
    @State private var items: [String] = []

    var body: some View {
        VStack {
            TipView(editTip) { action in
                if action.id == "try-edit" {
                    Button("지금 해보기") {
                        // 편집 모드로 전환
                    }
                }
            }

            List(items, id: \.self) { item in
                Text(item)
                    .onLongPressGesture {
                        // 편집 액션
                        Task {
                            await EditTip.hasEditedItem.donate()
                        }
                    }
            }

            Button("항목 추가") {
                items.append("새 항목")

                // 파라미터 업데이트
                EditTip.itemsCreated += 1
            }
        }
    }
}

import TipKit

struct ShareTip: Tip {
    // 여러 이벤트 정의
    static let didViewItem = Event(id: "didViewItem")
    static let didCreateItem = Event(id: "didCreateItem")
    static let didShareItem = Event(id: "didShareItem")

    var title: Text {
        Text("친구에게 공유하기")
    }

    var message: Text? {
        Text("공유 버튼으로 친구들과 항목을 공유해보세요")
    }

    var rules: [Rule] {
        [
            // 5번 이상 항목을 봤을 때
            #Rule(Self.didViewItem) {
                $0.donations.count >= 5
            },

            // 2개 이상 항목을 만들었을 때
            #Rule(Self.didCreateItem) {
                $0.donations.count >= 2
            },

            // 아직 공유를 안 했을 때
            #Rule(Self.didShareItem) {
                $0.donations.count == 0
            }
        ]
    }
}

// 이벤트 기록 예제
struct DetailView: View {
    let shareTip = ShareTip()

    var body: some View {
        VStack {
            Text("상세 내용")

            Button("공유") {
                // 공유 액션
                Task {
                    await ShareTip.didShareItem.donate()
                }
            }
            .popoverTip(shareTip)
        }
        .task {
            // 뷰 진입 시 이벤트 기록
            await ShareTip.didViewItem.donate()
        }
    }
}

import TipKit

struct TipManagementView: View {
    let tip = FavoriteTip()

    var body: some View {
        VStack(spacing: 20) {
            TipView(tip)

            // 팁 무효화 (다시는 표시 안 함)
            Button("이 팁 무효화") {
                tip.invalidate(reason: .actionPerformed)
            }

            // 모든 팁 리셋 (개발/테스트용)
            Button("모든 팁 리셋") {
                Task {
                    try? await Tips.resetDatastore()
                }
            }

            // 모든 이벤트와 파라미터 초기화
            Button("데이터 초기화") {
                Task {
                    try? await Tips.configureTips {
                        Tips.showAllTipsForTesting()
                    }
                }
            }
        }
        .padding()
    }
}

// 팁 무효화 이유
extension Tip.InvalidationReason {
    // .actionPerformed - 사용자가 팁의 액션을 수행함
    // .tipClosed - 사용자가 팁을 직접 닫음
    // .displayCountExceeded - 최대 표시 횟수 초과
}

import TipKit

struct ProTip: Tip {
    // 파라미터들
    @Parameter
    static var userLevel: Int = 0

    @Parameter
    static var isPremiumUser: Bool = false

    // 이벤트
    static let usedBasicFeature = Event(id: "usedBasicFeature")
    static let usedProFeature = Event(id: "usedProFeature")

    var title: Text {
        Text("프로 기능 사용하기")
    }

    var message: Text? {
        Text("프리미엄 기능으로 더 많은 작업을 할 수 있어요")
    }

    var rules: [Rule] {
        [
            // 레벨 5 이상
            #Rule(Self.$userLevel) { $0 >= 5 },

            // 프리미엄 유저가 아님
            #Rule(Self.$isPremiumUser) { $0 == false },

            // 기본 기능을 10번 이상 사용
            #Rule(Self.usedBasicFeature) {
                $0.donations.count >= 10
            },

            // 프로 기능은 아직 안 써봄
            #Rule(Self.usedProFeature) {
                $0.donations.count == 0
            },

            // 최근 7일 이내에 기본 기능 사용
            #Rule(Self.usedBasicFeature) {
                $0.donations.last7Days.count > 0
            }
        ]
    }

    var options: [Option] {
        [
            // 최대 3번까지만 표시
            .maxDisplayCount(3),

            // 무시하면 더 이상 표시 안 함
            .ignoresDisplayFrequency(false)
        ]
    }
}

import SwiftUI
import TipKit

struct TipKitDemoView: View {
    @State private var items: [String] = []
    @State private var favorites: Set<String> = []

    let favoriteTip = FavoriteTip()
    let editTip = EditTip()

    var body: some View {
        NavigationStack {
            VStack {
                // 인라인 팁
                TipView(favoriteTip)
                    .padding()

                List {
                    ForEach(items, id: \.self) { item in
                        HStack {
                            Text(item)

                            Spacer()

                            Button {
                                toggleFavorite(item)
                            } label: {
                                Image(systemName: favorites.contains(item) ? "star.fill" : "star")
                            }
                        }
                        .contentShape(Rectangle())
                        .onLongPressGesture {
                            Task {
                                await EditTip.hasEditedItem.donate()
                            }
                        }
                    }
                }

                // 팝오버 팁
                Button("항목 추가") {
                    items.append("항목 \(items.count + 1)")
                    EditTip.itemsCreated += 1
                }
                .buttonStyle(.borderedProminent)
                .padding()
                .popoverTip(editTip)
            }
            .navigationTitle("TipKit 데모")
            .toolbar {
                ToolbarItem(placement: .topBarTrailing) {
                    Button("리셋") {
                        Task {
                            try? await Tips.resetDatastore()
                        }
                    }
                }
            }
        }
    }

    func toggleFavorite(_ item: String) {
        if favorites.contains(item) {
            favorites.remove(item)
        } else {
            favorites.insert(item)
            // 즐겨찾기 추가 시 팁 무효화
            favoriteTip.invalidate(reason: .actionPerformed)
        }
    }
}