🛡️ PermissionKit

<!-- 카메라 -->
<key>NSCameraUsageDescription</key>
<string>사진을 촬영하고 프로필 이미지를 설정하는데 사용됩니다.</string>

<!-- 사진 라이브러리 -->
<key>NSPhotoLibraryUsageDescription</key>
<string>사진을 저장하고 불러오는데 사용됩니다.</string>

<!-- 위치 (사용 중) -->
<key>NSLocationWhenInUseUsageDescription</key>
<string>주변 장소를 검색하고 날씨 정보를 제공하는데 사용됩니다.</string>

<!-- 위치 (항상) -->
<key>NSLocationAlwaysAndWhenInUseUsageDescription</key>
<string>위치 기반 알림을 보내는데 사용됩니다.</string>

<!-- 마이크 -->
<key>NSMicrophoneUsageDescription</key>
<string>음성 메시지를 녹음하는데 사용됩니다.</string>

<!-- 연락처 -->
<key>NSContactsUsageDescription</key>
<string>친구를 찾고 초대하는데 사용됩니다.</string>

<!-- 알림 -->
<key>NSUserNotificationsUsageDescription</key>
<string>중요한 업데이트를 알려드리는데 사용됩니다.</string>

import SwiftUI
import AVFoundation
import CoreLocation
import UserNotifications
import Contacts
import Photos

// 권한 타입
enum PermissionType: String, CaseIterable, Identifiable {
    case camera = "카메라"
    case photoLibrary = "사진"
    case location = "위치"
    case microphone = "마이크"
    case contacts = "연락처"
    case notifications = "알림"

    var id: String { rawValue }

    var icon: String {
        switch self {
        case .camera: return "camera.fill"
        case .photoLibrary: return "photo.fill"
        case .location: return "location.fill"
        case .microphone: return "mic.fill"
        case .contacts: return "person.2.fill"
        case .notifications: return "bell.fill"
        }
    }

    var description: String {
        switch self {
        case .camera: return "사진과 비디오를 촬영하는데 필요합니다"
        case .photoLibrary: return "사진을 저장하고 불러오는데 필요합니다"
        case .location: return "주변 장소를 찾는데 필요합니다"
        case .microphone: return "음성을 녹음하는데 필요합니다"
        case .contacts: return "친구를 찾는데 필요합니다"
        case .notifications: return "중요한 알림을 받는데 필요합니다"
        }
    }
}

// 권한 상태
enum PermissionStatus {
    case notDetermined
    case authorized
    case denied
    case restricted
    case limited // 부분 권한 (사진 등)

    var color: Color {
        switch self {
        case .notDetermined: return .gray
        case .authorized: return .green
        case .denied: return .red
        case .restricted: return .orange
        case .limited: return .yellow
        }
    }

    var text: String {
        switch self {
        case .notDetermined: return "미설정"
        case .authorized: return "허용됨"
        case .denied: return "거부됨"
        case .restricted: return "제한됨"
        case .limited: return "제한적 허용"
        }
    }
}

// 통합 권한 관리자
@Observable
class PermissionManager {
    var permissions: [PermissionType: PermissionStatus] = [:]

    init() {
        // 초기 상태 확인
        Task {
            await checkAllPermissions()
        }
    }

    // 모든 권한 상태 확인
    func checkAllPermissions() async {
        for type in PermissionType.allCases {
            let status = await checkPermission(type)
            await MainActor.run {
                permissions[type] = status
            }
        }
    }

    // 개별 권한 확인
    func checkPermission(_ type: PermissionType) async -> PermissionStatus {
        switch type {
        case .camera:
            return checkCameraPermission()

        case .photoLibrary:
            return checkPhotoLibraryPermission()

        case .location:
            return checkLocationPermission()

        case .microphone:
            return checkMicrophonePermission()

        case .contacts:
            return await checkContactsPermission()

        case .notifications:
            return await checkNotificationPermission()
        }
    }

    // 카메라 권한
    func checkCameraPermission() -> PermissionStatus {
        switch AVCaptureDevice.authorizationStatus(for: .video) {
        case .notDetermined: return .notDetermined
        case .authorized: return .authorized
        case .denied: return .denied
        case .restricted: return .restricted
        @unknown default: return .notDetermined
        }
    }

    // 사진 권한
    func checkPhotoLibraryPermission() -> PermissionStatus {
        switch PHPhotoLibrary.authorizationStatus(for: .readWrite) {
        case .notDetermined: return .notDetermined
        case .authorized: return .authorized
        case .denied: return .denied
        case .restricted: return .restricted
        case .limited: return .limited
        @unknown default: return .notDetermined
        }
    }

    // 위치 권한
    func checkLocationPermission() -> PermissionStatus {
        let status = CLLocationManager().authorizationStatus

        switch status {
        case .notDetermined: return .notDetermined
        case .authorizedAlways, .authorizedWhenInUse: return .authorized
        case .denied: return .denied
        case .restricted: return .restricted
        @unknown default: return .notDetermined
        }
    }

    // 마이크 권한
    func checkMicrophonePermission() -> PermissionStatus {
        switch AVAudioSession.sharedInstance().recordPermission {
        case .undetermined: return .notDetermined
        case .granted: return .authorized
        case .denied: return .denied
        @unknown default: return .notDetermined
        }
    }

    // 연락처 권한
    func checkContactsPermission() async -> PermissionStatus {
        switch CNContactStore.authorizationStatus(for: .contacts) {
        case .notDetermined: return .notDetermined
        case .authorized: return .authorized
        case .denied: return .denied
        case .restricted: return .restricted
        @unknown default: return .notDetermined
        }
    }

    // 알림 권한
    func checkNotificationPermission() async -> PermissionStatus {
        let settings = await UNUserNotificationCenter.current().notificationSettings()

        switch settings.authorizationStatus {
        case .notDetermined: return .notDetermined
        case .authorized, .provisional, .ephemeral: return .authorized
        case .denied: return .denied
        @unknown default: return .notDetermined
        }
    }
}

import SwiftUI

extension PermissionManager {
    // 권한 요청
    func requestPermission(_ type: PermissionType) async -> PermissionStatus {
        switch type {
        case .camera:
            return await requestCameraPermission()

        case .photoLibrary:
            return await requestPhotoLibraryPermission()

        case .location:
            // 위치는 CLLocationManager 델리게이트 필요
            return .notDetermined

        case .microphone:
            return await requestMicrophonePermission()

        case .contacts:
            return await requestContactsPermission()

        case .notifications:
            return await requestNotificationPermission()
        }
    }

    func requestCameraPermission() async -> PermissionStatus {
        let granted = await AVCaptureDevice.requestAccess(for: .video)
        return granted ? .authorized : .denied
    }

    func requestPhotoLibraryPermission() async -> PermissionStatus {
        let status = await PHPhotoLibrary.requestAuthorization(for: .readWrite)

        switch status {
        case .authorized: return .authorized
        case .limited: return .limited
        case .denied: return .denied
        case .restricted: return .restricted
        default: return .notDetermined
        }
    }

    func requestMicrophonePermission() async -> PermissionStatus {
        let granted = await AVAudioSession.sharedInstance().requestRecordPermission()
        return granted ? .authorized : .denied
    }

    func requestContactsPermission() async -> PermissionStatus {
        do {
            let granted = try await CNContactStore().requestAccess(for: .contacts)
            return granted ? .authorized : .denied
        } catch {
            return .denied
        }
    }

    func requestNotificationPermission() async -> PermissionStatus {
        do {
            let granted = try await UNUserNotificationCenter.current()
                .requestAuthorization(options: [.alert, .badge, .sound])
            return granted ? .authorized : .denied
        } catch {
            return .denied
        }
    }

    // 설정 앱으로 이동
    func openSettings() {
        guard let settingsURL = URL(string: UIApplication.openSettingsURLString)
        else { return }

        UIApplication.shared.open(settingsURL)
    }
}

import SwiftUI

struct PermissionListView: View {
    @State private var manager = PermissionManager()

    var body: some View {
        NavigationStack {
            List(PermissionType.allCases) { type in
                PermissionRow(
                    type: type,
                    status: manager.permissions[type] ?? .notDetermined,
                    onRequest: {
                        Task {
                            let newStatus = await manager.requestPermission(type)
                            manager.permissions[type] = newStatus
                        }
                    },
                    onOpenSettings: {
                        manager.openSettings()
                    }
                )
            }
            .navigationTitle("권한 관리")
            .task {
                await manager.checkAllPermissions()
            }
        }
    }
}

struct PermissionRow: View {
    let type: PermissionType
    let status: PermissionStatus
    let onRequest: () -> Void
    let onOpenSettings: () -> Void

    var body: some View {
        VStack(alignment: .leading, spacing: 12) {
            HStack {
                Image(systemName: type.icon)
                    .font(.title2)
                    .foregroundStyle(.blue)
                    .frame(width: 40)

                VStack(alignment: .leading, spacing: 4) {
                    Text(type.rawValue)
                        .font(.headline)

                    Text(type.description)
                        .font(.caption)
                        .foregroundStyle(.secondary)
                }

                Spacer()

                // 상태 배지
                Text(status.text)
                    .font(.caption)
                    .fontWeight(.semibold)
                    .foregroundStyle(.white)
                    .padding(.horizontal, 8)
                    .padding(.vertical, 4)
                    .background(status.color)
                    .cornerRadius(8)
            }

            // 액션 버튼
            switch status {
            case .notDetermined:
                Button {
                    onRequest()
                } label: {
                    Text("권한 허용")
                        .frame(maxWidth: .infinity)
                        .padding(8)
                        .background(Color.blue)
                        .foregroundStyle(.white)
                        .cornerRadius(8)
                }
                .buttonStyle(.plain)

            case .denied:
                VStack(spacing: 8) {
                    Text("권한이 거부되었습니다")
                        .font(.caption)
                        .foregroundStyle(.red)

                    Button {
                        onOpenSettings()
                    } label: {
                        Label("설정에서 허용하기", systemImage: "gear")
                            .frame(maxWidth: .infinity)
                            .padding(8)
                            .background(Color.gray.opacity(0.2))
                            .foregroundStyle(.primary)
                            .cornerRadius(8)
                    }
                    .buttonStyle(.plain)
                }

            case .limited:
                Button {
                    onRequest()
                } label: {
                    Text("전체 액세스 허용")
                        .frame(maxWidth: .infinity)
                        .padding(8)
                        .background(Color.orange)
                        .foregroundStyle(.white)
                        .cornerRadius(8)
                }
                .buttonStyle(.plain)

            case .authorized:
                HStack {
                    Image(systemName: "checkmark.circle.fill")
                        .foregroundStyle(.green)
                    Text("권한이 허용되었습니다")
                        .font(.caption)
                        .foregroundStyle(.secondary)
                }

            case .restricted:
                Text("기기 설정에 의해 제한되었습니다")
                    .font(.caption)
                    .foregroundStyle(.orange)
            }
        }
        .padding(.vertical, 8)
    }
}

import SwiftUI

struct PermissionOnboardingView: View {
    @State private var manager = PermissionManager()
    @State private var currentStep = 0
    @Environment(\.dismiss) var dismiss

    let steps: [PermissionType] = [.camera, .photoLibrary, .location, .notifications]

    var body: some View {
        VStack(spacing: 32) {
            // 진행 표시
            HStack(spacing: 8) {
                ForEach(0..<4, id: \.self) { index in
                    Capsule()
                        .fill(index <= currentStep ? Color.blue : Color.gray.opacity(0.3))
                        .frame(height: 4)
                }
            }
            .padding(.horizontal)

            Spacer()

            // 현재 단계 콘텐츠
            if currentStep < steps.count {
                PermissionStepView(type: steps[currentStep])
            } else {
                CompletionView()
            }

            Spacer()

            // 액션 버튼
            VStack(spacing: 12) {
                if currentStep < steps.count {
                    Button {
                        Task {
                            let type = steps[currentStep]
                            let status = await manager.requestPermission(type)
                            manager.permissions[type] = status
                            currentStep += 1
                        }
                    } label: {
                        Text("허용")
                            .font(.headline)
                            .frame(maxWidth: .infinity)
                            .padding()
                            .background(Color.blue)
                            .foregroundStyle(.white)
                            .cornerRadius(12)
                    }

                    Button {
                        currentStep += 1
                    } label: {
                        Text("나중에")
                            .font(.subheadline)
                            .foregroundStyle(.secondary)
                    }
                } else {
                    Button {
                        dismiss()
                    } label: {
                        Text("시작하기")
                            .font(.headline)
                            .frame(maxWidth: .infinity)
                            .padding()
                            .background(Color.blue)
                            .foregroundStyle(.white)
                            .cornerRadius(12)
                    }
                }
            }
            .padding()
        }
    }
}

struct PermissionStepView: View {
    let type: PermissionType

    var body: some View {
        VStack(spacing: 24) {
            // 아이콘
            Image(systemName: type.icon)
                .font(.system(size: 80))
                .foregroundStyle(.blue)
                .symbolEffect(.bounce)

            // 제목과 설명
            VStack(spacing: 8) {
                Text(type.rawValue)
                    .font(.title)
                    .fontWeight(.bold)

                Text(type.description)
                    .font(.body)
                    .foregroundStyle(.secondary)
                    .multilineTextAlignment(.center)
            }
            .padding(.horizontal)

            // 사용 예시
            VStack(alignment: .leading, spacing: 12) {
                Text("이런 용도로 사용됩니다:")
                    .font(.headline)

                VStack(alignment: .leading, spacing: 8) {
                    usageExample("프로필 사진 촬영")
                    usageExample("문서 스캔")
                    usageExample("AR 기능 사용")
                }
            }
            .padding()
            .frame(maxWidth: .infinity, alignment: .leading)
            .background(Color.gray.opacity(0.1))
            .cornerRadius(12)
            .padding(.horizontal)
        }
    }

    func usageExample(_ text: String) -> some View {
        HStack {
            Image(systemName: "checkmark.circle.fill")
                .foregroundStyle(.green)
            Text(text)
                .font(.subheadline)
        }
    }
}

struct CompletionView: View {
    var body: some View {
        VStack(spacing: 24) {
            Image(systemName: "checkmark.circle.fill")
                .font(.system(size: 80))
                .foregroundStyle(.green)

            VStack(spacing: 8) {
                Text("모두 완료!")
                    .font(.title)
                    .fontWeight(.bold)

                Text("이제 앱의 모든 기능을 사용할 수 있습니다")
                    .font(.body)
                    .foregroundStyle(.secondary)
            }
        }
    }
}

import SwiftUI
import Combine

@Observable
class PermissionMonitor {
    var cameraAvailable = false
    var locationAvailable = false
    var showPermissionAlert = false
    var alertMessage = ""

    private var cancellables = Set<AnyCancellable>()

    init() {
        startMonitoring()
    }

    func startMonitoring() {
        // 앱 포그라운드 진입 시 권한 재확인
        NotificationCenter.default.publisher(for: UIApplication.willEnterForegroundNotification)
            .sink { _ in
                Task {
                    await self.checkPermissions()
                }
            }
            .store(in: &cancellables)
    }

    func checkPermissions() async {
        // 카메라 권한 확인
        let cameraStatus = AVCaptureDevice.authorizationStatus(for: .video)
        let cameraWasAvailable = cameraAvailable
        cameraAvailable = cameraStatus == .authorized

        // 권한이 취소된 경우
        if cameraWasAvailable && !cameraAvailable {
            await showAlert("카메라 권한이 취소되었습니다. 설정에서 다시 허용해주세요.")
        }

        // 위치 권한 확인
        let locationStatus = CLLocationManager().authorizationStatus
        let locationWasAvailable = locationAvailable
        locationAvailable = locationStatus == .authorizedWhenInUse || locationStatus == .authorizedAlways

        if locationWasAvailable && !locationAvailable {
            await showAlert("위치 권한이 취소되었습니다. 설정에서 다시 허용해주세요.")
        }
    }

    func showAlert(_ message: String) async {
        await MainActor.run {
            alertMessage = message
            showPermissionAlert = true
        }
    }
}

// 사용 예제
struct CameraView: View {
    @State private var monitor = PermissionMonitor()

    var body: some View {
        VStack {
            if monitor.cameraAvailable {
                Text("카메라 사용 가능")
                // 카메라 UI
            } else {
                ContentUnavailableView {
                    Label("카메라 권한 필요", systemImage: "camera.fill")
                } description: {
                    Text("설정에서 카메라 권한을 허용해주세요")
                } actions: {
                    Button("설정 열기") {
                        PermissionManager().openSettings()
                    }
                }
            }
        }
        .alert("권한 변경", isPresented: $monitor.showPermissionAlert) {
            Button("설정 열기") {
                PermissionManager().openSettings()
            }
            Button("확인", role: .cancel) { }
        } message: {
            Text(monitor.alertMessage)
        }
        .task {
            await monitor.checkPermissions()
        }
    }
}