🎯 RelevanceKit

import RelevanceKit
import Foundation

@Observable
class RelevanceManager {
    var currentRelevance: Double = 0.5
    private let relevanceContext = RKRelevanceContext()

    // 관련성 업데이트
    func updateRelevance(score: Double, reason: String) async {
        currentRelevance = score

        // 시스템에 관련성 신호 전달
        await relevanceContext.updateRelevance(
            score: score,
            metadata: [
                "reason": reason,
                "timestamp": Date().timeIntervalSince1970
            ]
        )
    }

    // 컨텍스트 기반 관련성 계산
    func calculateContextualRelevance(
        location: String?,
        timeOfDay: String,
        userActivity: String
    ) -> Double {
        var score = 0.0

        // 위치 기반 점수
        if location == "gym" {
            score += 0.3
        }

        // 시간 기반 점수
        if timeOfDay == "morning" {
            score += 0.2
        }

        // 활동 기반 점수
        if userActivity == "workout" {
            score += 0.5
        }

        return min(score, 1.0)
    }
}

import ActivityKit
import RelevanceKit

struct DeliveryAttributes: ActivityAttributes {
    public struct ContentState: Codable, Hashable {
        var status: String
        var estimatedTime: Date
        var relevanceScore: Double // 🆕 관련성 점수
    }

    var orderId: String
}

@Observable
class LiveActivityRelevanceManager {
    private var activity: Activity<DeliveryAttributes>?

    // Live Activity 시작 (관련성 포함)
    func startActivity(orderId: String) async throws {
        let attributes = DeliveryAttributes(orderId: orderId)
        let initialState = DeliveryAttributes.ContentState(
            status: "준비 중",
            estimatedTime: Date().addingTimeInterval(1800),
            relevanceScore: 0.5
        )

        activity = try Activity.request(
            attributes: attributes,
            content: .init(state: initialState, staleDate: nil),
            pushType: nil
        )
    }

    // 배달 임박 시 우선순위 증가
    func updateForIncomingDelivery() async {
        guard let activity else { return }

        let updatedState = DeliveryAttributes.ContentState(
            status: "배달 중 - 5분 남음",
            estimatedTime: Date().addingTimeInterval(300),
            relevanceScore: 0.95 // 🆕 높은 우선순위
        )

        await activity.update(using: updatedState)
    }

    // 배달 완료 시 우선순위 감소
    func updateForCompletion() async {
        guard let activity else { return }

        let finalState = DeliveryAttributes.ContentState(
            status: "배달 완료",
            estimatedTime: Date(),
            relevanceScore: 0.1 // 🆕 낮은 우선순위
        )

        await activity.update(using: finalState)

        // 5초 후 종료
        try? await Task.sleep(for: .seconds(5))
        await activity.end(nil, dismissalPolicy: .immediate)
    }
}

import CoreSpotlight
import RelevanceKit

@Observable
class SpotlightRelevanceManager {
    // 컨텍스트 기반 검색 항목 색인
    func indexWithRelevance(
        title: String,
        description: String,
        contextScore: Double
    ) async {
        let attributeSet = CSSearchableItemAttributeSet(
            contentType: .init(rawValue: "public.content")
        )

        attributeSet.title = title
        attributeSet.contentDescription = description

        // 🆕 관련성 점수 설정
        attributeSet.rankingHint = contextScore

        // 컨텍스트 메타데이터
        attributeSet.keywords = [
            "relevant",
            "priority-\(Int(contextScore * 10))"
        ]

        let item = CSSearchableItem(
            uniqueIdentifier: UUID().uuidString,
            domainIdentifier: "com.app.relevance",
            attributeSet: attributeSet
        )

        try? await CSSearchableIndex.default().indexSearchableItems([item])
    }

    // 운동 시간에 피트니스 콘텐츠 우선순위 증가
    func indexWorkoutContent() async {
        let currentHour = Calendar.current.component(.hour, from: Date())
        let isWorkoutTime = (6...9).contains(currentHour) || (17...20).contains(currentHour)

        await indexWithRelevance(
            title: "오늘의 운동 루틴",
            description: "맞춤형 운동 계획",
            contextScore: isWorkoutTime ? 0.9 : 0.3
        )
    }

    // 위치 기반 관련성
    func indexLocationBasedContent(nearGym: Bool) async {
        await indexWithRelevance(
            title: "체육관 회원권",
            description: "회원권 정보 확인",
            contextScore: nearGym ? 0.95 : 0.2
        )
    }
}

import RelevanceKit
import CoreLocation

@Observable
class IntentPredictionManager {
    private var userPatterns: [String: [Date]] = [:]
    private let relevanceContext = RKRelevanceContext()

    // 사용자 행동 패턴 기록
    func recordActivity(_ activity: String) {
        if userPatterns[activity] == nil {
            userPatterns[activity] = []
        }
        userPatterns[activity]?.append(Date())
    }

    // 패턴 기반 관련성 예측
    func predictRelevance(for activity: String) -> Double {
        guard let history = userPatterns[activity] else {
            return 0.1
        }

        let now = Date()
        let calendar = Calendar.current
        let currentHour = calendar.component(.hour, from: now)

        // 같은 시간대 활동 빈도 계산
        let sameHourActivities = history.filter {
            calendar.component(.hour, from: $0) == currentHour
        }

        let frequency = Double(sameHourActivities.count) / Double(history.count)
        return min(frequency * 2.0, 1.0)
    }

    // 시스템에 예측 전달
    func updatePredictedRelevance(for activity: String) async {
        let score = predictRelevance(for: activity)

        await relevanceContext.updateRelevance(
            score: score,
            metadata: [
                "activity": activity,
                "prediction_confidence": score,
                "timestamp": Date().timeIntervalSince1970
            ]
        )
    }
}

// 실사용 예제
struct WorkoutPredictionView: View {
    @State private var predictor = IntentPredictionManager()
    @State private var relevanceScore = 0.0

    var body: some View {
        VStack {
            Text("운동 관련성: \(Int(relevanceScore * 100))%")
                .font(.title)

            Button("운동 시작") {
                predictor.recordActivity("workout")
                Task {
                    await predictor.updatePredictedRelevance(for: "workout")
                }
            }
        }
        .task {
            relevanceScore = predictor.predictRelevance(for: "workout")
        }
    }
}

import RelevanceKit
import CoreLocation

@Observable
class LocationRelevanceManager: NSObject, CLLocationManagerDelegate {
    private let locationManager = CLLocationManager()
    private let relevanceContext = RKRelevanceContext()
    var currentRelevance = 0.0

    // 관심 위치 정의
    private let gymLocation = CLLocationCoordinate2D(
        latitude: 37.5665,
        longitude: 126.9780
    )

    override init() {
        super.init()
        locationManager.delegate = self
        locationManager.desiredAccuracy = kCLLocationAccuracyHundredMeters
    }

    // 위치 모니터링 시작
    func startMonitoring() {
        locationManager.requestWhenInUseAuthorization()
        locationManager.startUpdatingLocation()
    }

    // 위치 업데이트 처리
    func locationManager(
        _ manager: CLLocationManager,
        didUpdateLocations locations: [CLLocation]
    ) {
        guard let location = locations.last else { return }

        // 체육관과의 거리 계산
        let gymCLLocation = CLLocation(
            latitude: gymLocation.latitude,
            longitude: gymLocation.longitude
        )
        let distance = location.distance(from: gymCLLocation)

        // 거리 기반 관련성 계산
        let relevance: Double
        if distance < 100 {
            relevance = 1.0 // 매우 가까움
        } else if distance < 500 {
            relevance = 0.7 // 가까움
        } else if distance < 1000 {
            relevance = 0.4 // 중간
        } else {
            relevance = 0.1 // 멀음
        }

        currentRelevance = relevance

        // 시스템에 전달
        Task {
            await relevanceContext.updateRelevance(
                score: relevance,
                metadata: [
                    "distance": distance,
                    "location": "gym"
                ]
            )
        }
    }
}

import SwiftUI
import RelevanceKit

struct RelevanceApp: View {
    @State private var relevanceManager = RelevanceManager()
    @State private var liveActivityManager = LiveActivityRelevanceManager()
    @State private var locationManager = LocationRelevanceManager()

    var body: some View {
        NavigationStack {
            List {
                Section("현재 관련성") {
                    HStack {
                        Text("시스템 관련성")
                        Spacer()
                        Text("\(Int(relevanceManager.currentRelevance * 100))%")
                            .foregroundStyle(.secondary)
                    }

                    HStack {
                        Text("위치 기반")
                        Spacer()
                        Text("\(Int(locationManager.currentRelevance * 100))%")
                            .foregroundStyle(.secondary)
                    }
                }

                Section("액션") {
                    Button("운동 시작") {
                        Task {
                            await relevanceManager.updateRelevance(
                                score: 0.9,
                                reason: "workout_started"
                            )
                        }
                    }

                    Button("배달 시작") {
                        Task {
                            try? await liveActivityManager.startActivity(
                                orderId: "ORDER123"
                            )
                        }
                    }

                    Button("위치 추적 시작") {
                        locationManager.startMonitoring()
                    }
                }
            }
            .navigationTitle("RelevanceKit")
        }
    }
}