import Foundation
import Security

// MARK: - Keychain 에러 정의
enum KeychainError: Error, LocalizedError {
    case duplicateEntry
    case itemNotFound
    case invalidData
    case unexpectedStatus(OSStatus)
    
    var errorDescription: String? {
        switch self {
        case .duplicateEntry:
            return "이미 존재하는 항목입니다"
        case .itemNotFound:
            return "항목을 찾을 수 없습니다"
        case .invalidData:
            return "유효하지 않은 데이터입니다"
        case .unexpectedStatus(let status):
            return "예상치 못한 오류: \(status)"
        }
    }
}

// MARK: - Keychain 접근 가능 시점 설정
enum KeychainAccessibility {
    /// 기기 잠금 해제 후 접근 가능 (가장 일반적)
    case whenUnlocked
    /// 기기 잠금 해제 후 접근 가능 + iCloud 백업 제외
    case whenUnlockedThisDeviceOnly
    /// 첫 번째 잠금 해제 후 재부팅 전까지 접근 가능
    case afterFirstUnlock
    /// 항상 접근 가능 (비추천)
    case always
    
    var value: CFString {
        switch self {
        case .whenUnlocked:
            return kSecAttrAccessibleWhenUnlocked
        case .whenUnlockedThisDeviceOnly:
            return kSecAttrAccessibleWhenUnlockedThisDeviceOnly
        case .afterFirstUnlock:
            return kSecAttrAccessibleAfterFirstUnlock
        case .always:
            return kSecAttrAccessibleAlways
        }
    }
}

// MARK: - KeychainManager
final class KeychainManager {
    
    static let shared = KeychainManager()
    private init() {}
    
    private let service = Bundle.main.bundleIdentifier ?? "com.myapp.keychain"
    
    // MARK: - 저장 (Create/Update)
    func save(_ value: String, 
              forKey key: String,
              accessibility: KeychainAccessibility = .whenUnlockedThisDeviceOnly) throws {
        
        guard let data = value.data(using: .utf8) else {
            throw KeychainError.invalidData
        }
        
        // 먼저 기존 항목 삭제 시도 (업데이트를 위해)
        try? delete(forKey: key)
        
        let query: [String: Any] = [
            kSecClass as String: kSecClassGenericPassword,
            kSecAttrService as String: service,
            kSecAttrAccount as String: key,
            kSecValueData as String: data,
            kSecAttrAccessible as String: accessibility.value
        ]
        
        let status = SecItemAdd(query as CFDictionary, nil)
        
        guard status == errSecSuccess else {
            if status == errSecDuplicateItem {
                throw KeychainError.duplicateEntry
            }
            throw KeychainError.unexpectedStatus(status)
        }
    }
    
    // MARK: - 읽기 (Read)
    func read(forKey key: String) throws -> String {
        let query: [String: Any] = [
            kSecClass as String: kSecClassGenericPassword,
            kSecAttrService as String: service,
            kSecAttrAccount as String: key,
            kSecReturnData as String: true,
            kSecMatchLimit as String: kSecMatchLimitOne
        ]
        
        var result: AnyObject?
        let status = SecItemCopyMatching(query as CFDictionary, &result)
        
        guard status == errSecSuccess else {
            if status == errSecItemNotFound {
                throw KeychainError.itemNotFound
            }
            throw KeychainError.unexpectedStatus(status)
        }
        
        guard let data = result as? Data,
              let string = String(data: data, encoding: .utf8) else {
            throw KeychainError.invalidData
        }
        
        return string
    }
    
    // MARK: - 삭제 (Delete)
    func delete(forKey key: String) throws {
        let query: [String: Any] = [
            kSecClass as String: kSecClassGenericPassword,
            kSecAttrService as String: service,
            kSecAttrAccount as String: key
        ]
        
        let status = SecItemDelete(query as CFDictionary)
        
        guard status == errSecSuccess || status == errSecItemNotFound else {
            throw KeychainError.unexpectedStatus(status)
        }
    }
    
    // MARK: - 존재 여부 확인
    func exists(forKey key: String) -> Bool {
        let query: [String: Any] = [
            kSecClass as String: kSecClassGenericPassword,
            kSecAttrService as String: service,
            kSecAttrAccount as String: key,
            kSecMatchLimit as String: kSecMatchLimitOne
        ]
        
        let status = SecItemCopyMatching(query as CFDictionary, nil)
        return status == errSecSuccess
    }
}

// 사용 예시 - 이렇게 쓰면 됨!
class AuthService {
    
    private let tokenKey = "auth_token"
    private let refreshTokenKey = "refresh_token"
    private let keychain = KeychainManager.shared
    
    // 로그인 후 토큰 저장
    func saveTokens(accessToken: String, refreshToken: String) {
        do {
            try keychain.save(accessToken, forKey: tokenKey)
            try keychain.save(refreshToken, forKey: refreshTokenKey)
            print("✅ 토큰 저장 완료!")
        } catch {
            print("❌ 토큰 저장 실패: \(error.localizedDescription)")
        }
    }
    
    // 저장된 토큰 가져오기
    func getAccessToken() -> String? {
        return try? keychain.read(forKey: tokenKey)
    }
    
    // 로그아웃 시 토큰 삭제
    func logout() {
        try? keychain.delete(forKey: tokenKey)
        try? keychain.delete(forKey: refreshTokenKey)
        print("👋 로그아웃 완료, 토큰 삭제됨")
    }
}

<!-- Info.plist에 추가 -->
<key>NSFaceIDUsageDescription</key>
<string>안전한 로그인을 위해 Face ID를 사용합니다</string>

import LocalAuthentication
import Foundation

// MARK: - 생체 인증 타입
enum BiometricType {
    case none
    case touchID
    case faceID
    case opticID  // Apple Vision Pro용 (iOS 17+)
    
    var displayName: String {
        switch self {
        case .none: return "생체 인증 없음"
        case .touchID: return "Touch ID"
        case .faceID: return "Face ID"
        case .opticID: return "Optic ID"
        }
    }
    
    var iconName: String {
        switch self {
        case .none: return "lock.fill"
        case .touchID: return "touchid"
        case .faceID: return "faceid"
        case .opticID: return "opticid"
        }
    }
}

// MARK: - 인증 결과
enum AuthResult {
    case success
    case failure(AuthError)
}

// MARK: - 인증 에러
enum AuthError: Error, LocalizedError {
    case biometryNotAvailable      // 생체 인증 하드웨어 없음
    case biometryNotEnrolled       // 생체 정보 미등록
    case biometryLockout           // 너무 많은 실패로 잠김
    case userCancel                // 사용자가 취소
    case userFallback              // 비밀번호 입력 선택
    case systemCancel              // 시스템이 취소 (전화 수신 등)
    case authenticationFailed      // 인증 실패
    case unknown(Error)            // 기타 에러
    
    var errorDescription: String? {
        switch self {
        case .biometryNotAvailable:
            return "이 기기는 생체 인증을 지원하지 않습니다"
        case .biometryNotEnrolled:
            return "생체 정보가 등록되지 않았습니다. 설정에서 등록해주세요"
        case .biometryLockout:
            return "너무 많은 실패로 생체 인증이 잠겼습니다. 기기 암호를 사용해주세요"
        case .userCancel:
            return "인증이 취소되었습니다"
        case .userFallback:
            return "비밀번호 입력을 선택했습니다"
        case .systemCancel:
            return "시스템에 의해 인증이 취소되었습니다"
        case .authenticationFailed:
            return "인증에 실패했습니다"
        case .unknown(let error):
            return "알 수 없는 오류: \(error.localizedDescription)"
        }
    }
}

// MARK: - BiometricAuthManager
@MainActor
final class BiometricAuthManager: ObservableObject {
    
    static let shared = BiometricAuthManager()
    private init() {}
    
    // MARK: - 현재 기기의 생체 인증 타입 확인
    var biometricType: BiometricType {
        let context = LAContext()
        var error: NSError?
        
        guard context.canEvaluatePolicy(.deviceOwnerAuthenticationWithBiometrics, 
                                        error: &error) else {
            return .none
        }
        
        switch context.biometryType {
        case .touchID:
            return .touchID
        case .faceID:
            return .faceID
        case .opticID:
            return .opticID
        case .none:
            return .none
        @unknown default:
            return .none
        }
    }
    
    // MARK: - 생체 인증 가능 여부 확인
    var isBiometricAvailable: Bool {
        let context = LAContext()
        var error: NSError?
        return context.canEvaluatePolicy(.deviceOwnerAuthenticationWithBiometrics, 
                                         error: &error)
    }
    
    // MARK: - 생체 인증 실행 (async/await 버전)
    func authenticate(reason: String = "본인 확인을 위해 인증이 필요합니다") async -> AuthResult {
        let context = LAContext()
        context.localizedCancelTitle = "취소"
        context.localizedFallbackTitle = "비밀번호 사용"
        
        // 생체 인증 가능 여부 먼저 체크
        var error: NSError?
        guard context.canEvaluatePolicy(.deviceOwnerAuthenticationWithBiometrics, 
                                        error: &error) else {
            return .failure(mapLAError(error))
        }
        
        do {
            let success = try await context.evaluatePolicy(
                .deviceOwnerAuthenticationWithBiometrics,
                localizedReason: reason
            )
            return success ? .success : .failure(.authenticationFailed)
        } catch let laError as LAError {
            return .failure(mapLAError(laError as NSError))
        } catch {
            return .failure(.unknown(error))
        }
    }
    
    // MARK: - 기기 암호 포함 인증 (생체 실패 시 암호로 폴백)
    func authenticateWithFallback(reason: String = "본인 확인이 필요합니다") async -> AuthResult {
        let context = LAContext()
        context.localizedCancelTitle = "취소"
        
        var error: NSError?
        guard context.canEvaluatePolicy(.deviceOwnerAuthentication, error: &error) else {
            return .failure(mapLAError(error))
        }
        
        do {
            let success = try await context.evaluatePolicy(
                .deviceOwnerAuthentication,  // 기기 암호 포함!
                localizedReason: reason
            )
            return success ? .success : .failure(.authenticationFailed)
        } catch let laError as LAError {
            return .failure(mapLAError(laError as NSError))
        } catch {
            return .failure(.unknown(error))
        }
    }
    
    // MARK: - LAError 매핑
    private func mapLAError(_ error: NSError?) -> AuthError {
        guard let error = error else { return .authenticationFailed }
        
        switch LAError.Code(rawValue: error.code) {
        case .biometryNotAvailable:
            return .biometryNotAvailable
        case .biometryNotEnrolled:
            return .biometryNotEnrolled
        case .biometryLockout:
            return .biometryLockout
        case .userCancel:
            return .userCancel
        case .userFallback:
            return .userFallback
        case .systemCancel:
            return .systemCancel
        case .authenticationFailed:
            return .authenticationFailed
        default:
            return .unknown(error)
        }
    }
}

import Foundation
import Security
import LocalAuthentication

// MARK: - 생체 인증 연동 Keychain 저장
final class SecureBiometricKeychain {
    
    static let shared = SecureBiometricKeychain()
    private init() {}
    
    private let service = Bundle.main.bundleIdentifier ?? "com.myapp"
    
    // MARK: - 생체 인증 보호 항목 저장
    // 이 항목은 생체 인증 성공 시에만 읽을 수 있음!
    func saveWithBiometricProtection(
        value: String,
        forKey key: String
    ) throws {
        guard let data = value.data(using: .utf8) else {
            throw KeychainError.invalidData
        }
        
        // 생체 인증 접근 제어 설정
        var error: Unmanaged<CFError>?
        guard let accessControl = SecAccessControlCreateWithFlags(
            kCFAllocatorDefault,
            kSecAttrAccessibleWhenUnlockedThisDeviceOnly,
            .biometryCurrentSet,  // 현재 등록된 생체 정보로만 접근 가능
            &error
        ) else {
            throw KeychainError.invalidData
        }
        
        // 기존 항목 삭제
        let deleteQuery: [String: Any] = [
            kSecClass as String: kSecClassGenericPassword,
            kSecAttrService as String: service,
            kSecAttrAccount as String: key
        ]
        SecItemDelete(deleteQuery as CFDictionary)
        
        // 새 항목 저장
        let query: [String: Any] = [
            kSecClass as String: kSecClassGenericPassword,
            kSecAttrService as String: service,
            kSecAttrAccount as String: key,
            kSecValueData as String: data,
            kSecAttrAccessControl as String: accessControl
        ]
        
        let status = SecItemAdd(query as CFDictionary, nil)
        guard status == errSecSuccess else {
            throw KeychainError.unexpectedStatus(status)
        }
    }
    
    // MARK: - 생체 인증 후 항목 읽기
    func readWithBiometricAuth(
        forKey key: String,
        reason: String = "저장된 정보에 접근하려면 인증이 필요합니다"
    ) throws -> String {
        
        // LAContext를 직접 전달해서 인증 이유 커스터마이징
        let context = LAContext()
        context.localizedReason = reason
        
        let query: [String: Any] = [
            kSecClass as String: kSecClassGenericPassword,
            kSecAttrService as String: service,
            kSecAttrAccount as String: key,
            kSecReturnData as String: true,
            kSecMatchLimit as String: kSecMatchLimitOne,
            kSecUseAuthenticationContext as String: context  // 인증 컨텍스트 주입!
        ]
        
        var result: AnyObject?
        let status = SecItemCopyMatching(query as CFDictionary, &result)
        
        guard status == errSecSuccess else {
            if status == errSecItemNotFound {
                throw KeychainError.itemNotFound
            }
            // errSecUserCanceled: 사용자가 취소
            // errSecAuthFailed: 인증 실패
            throw KeychainError.unexpectedStatus(status)
        }
        
        guard let data = result as? Data,
              let string = String(data: data, encoding: .utf8) else {
            throw KeychainError.invalidData
        }
        
        return string
    }
}

// MARK: - .biometryCurrentSet vs .biometryAny 차이점
/*
 .biometryCurrentSet:
 - 현재 등록된 생체 정보로만 접근 가능
 - 새 지문/얼굴 추가하면 기존 항목 접근 불가 (보안 강화)
 - 뱅킹, 결제 앱에 권장
 
 .biometryAny:
 - 어떤 생체 정보로도 접근 가능
 - 새 지문 추가해도 기존 항목 접근 가능
 - 일반 앱 잠금에 적합
*/

import SwiftUI
import LocalAuthentication

// MARK: - 인증 상태
enum AuthenticationState {
    case unauthenticated
    case authenticating
    case authenticated
    case failed(String)
}

// MARK: - 인증 뷰모델
@MainActor
class AuthViewModel: ObservableObject {
    
    @Published var authState: AuthenticationState = .unauthenticated
    @Published var isAuthenticated = false
    
    private let biometricManager = BiometricAuthManager.shared
    private let keychain = KeychainManager.shared
    
    // 생체 인증 타입 (UI에서 아이콘 표시용)
    var biometricType: BiometricType {
        biometricManager.biometricType
    }
    
    // MARK: - 생체 인증 실행
    func authenticate() async {
        authState = .authenticating
        
        let result = await biometricManager.authenticate(
            reason: "앱에 접근하려면 \(biometricManager.biometricType.displayName) 인증이 필요합니다"
        )
        
        switch result {
        case .success:
            authState = .authenticated
            isAuthenticated = true
            // 인증 성공 후 Keychain에서 토큰 가져오기
            loadUserData()
            
        case .failure(let error):
            switch error {
            case .userCancel:
                authState = .unauthenticated  // 취소는 에러 아님
            case .biometryLockout:
                // 잠금 상태면 기기 암호로 폴백
                await authenticateWithDevicePasscode()
            default:
                authState = .failed(error.localizedDescription ?? "인증 실패")
            }
        }
    }
    
    // MARK: - 기기 암호로 인증 (폴백)
    func authenticateWithDevicePasscode() async {
        let result = await biometricManager.authenticateWithFallback(
            reason: "기기 암호로 인증해주세요"
        )
        
        switch result {
        case .success:
            authState = .authenticated
            isAuthenticated = true
        case .failure(let error):
            authState = .failed(error.localizedDescription ?? "인증 실패")
        }
    }
    
    // MARK: - 인증 후 데이터 로드
    private func loadUserData() {
        if let token = try? keychain.read(forKey: "auth_token") {
            print("✅ 토큰 로드 성공: \(token.prefix(10))...")
        }
    }
    
    // MARK: - 로그아웃
    func logout() {
        isAuthenticated = false
        authState = .unauthenticated
    }
}

// MARK: - 인증 화면 뷰
struct AuthenticationView: View {
    
    @StateObject private var viewModel = AuthViewModel()
    
    var body: some View {
        ZStack {
            // 배경
            LinearGradient(
                colors: [Color(hex: "#f0f4ff"), Color(hex: "#f5f0ff")],
                startPoint: .topLeading,
                endPoint: .bottomTrailing
            )
            .ignoresSafeArea()
            
            if viewModel.isAuthenticated {
                // 인증 성공 화면
                MainContentView()
                    .transition(.opacity.combined(with: .scale))
            } else {
                // 인증 화면
                VStack(spacing: 32) {
                    Spacer()
                    
                    // 앱 아이콘 영역
                    ZStack {
                        Circle()
                            .fill(Color(hex: "#4a6cf7").opacity(0.1))
                            .frame(width: 120, height: 120)
                        
                        Image(systemName: "lock.shield.fill")
                            .font(.system(size: 50))
                            .foregroundColor(Color(hex: "#4a6cf7"))
                    }
                    
                    VStack(spacing: 8) {
                        Text("본인 확인")
                            .font(.title.bold())
                            .foregroundColor(.primary)
                        
                        Text("앱에 접근하려면 인증이 필요합니다")
                            .font(.subheadline)
                            .foregroundColor(.secondary)
                            .multilineTextAlignment(.center)
                    }
                    
                    // 인증 상태 표시
                    authStateView
                    
                    Spacer()
                    
                    // 인증 버튼
                    VStack(spacing: 12) {
                        Button(action: {
                            Task { await viewModel.authenticate() }
                        }) {
                            HStack(spacing: 12) {
                                Image(systemName: viewModel.biometricType.iconName)
                                    .font(.title3)
                                Text("\(viewModel.biometricType.displayName)로 인증")
                                    .font(.headline)
                            }
                            .foregroundColor(.white)
                            .frame(maxWidth: .infinity)
                            .padding(.vertical, 16)
                            .background(
                                LinearGradient(
                                    colors: [Color(hex: "#4a6cf7"), Color(hex: "#6a3de8")],
                                    startPoint: .leading,
                                    endPoint: .trailing
                                )
                            )
                            .cornerRadius(14)
                        }
                        .disabled(viewModel.authState == .authenticating)
                        
                        // 기기 암호 사용 버튼
                        Button("기기 암호 사용") {
                            Task { await viewModel.authenticateWithDevicePasscode() }
                        }
                        .font(.subheadline)
                        .foregroundColor(Color(hex: "#4a6cf7"))
                    }
                    .padding(.horizontal, 32)
                    .padding(.bottom, 48)
                }
                .animation(.spring(response: 0.4), value: viewModel.authState)
            }
        }
    }
    
    // MARK: - 상태별 뷰
    @ViewBuilder
    private var authStateView: some View {
        switch viewModel.authState {
        case .authenticating:
            ProgressView()
                .scaleEffect(1.5)
                .tint(Color(hex: "#4a6cf7"))
            
        case .failed(let message):
            HStack(spacing: 8) {
                Image(systemName: "exclamationmark.circle.fill")
                    .foregroundColor(.red)
                Text(message)
                    .font(.caption)
                    .foregroundColor(.red)
            }
            .padding(.horizontal, 20)
            .multilineTextAlignment(.center)
            
        default:
            EmptyView()
        }
    }
}

// MARK: - 토큰 모델
struct AuthTokens: Codable {
    let accessToken: String
    let refreshToken: String
    let expiresAt: Date
    
    var isExpired: Bool {
        return Date() >= expiresAt
    }
    
    var isNearExpiry: Bool {
        // 만료 5분 전부터 갱신 시도
        return Date() >= expiresAt.addingTimeInterval(-300)
    }
}

// MARK: - 토큰 매니저
@MainActor
class TokenManager: ObservableObject {
    
    static let shared = TokenManager()
    private init() {}
    
    private let keychain = KeychainManager.shared
    private let tokenKey = "auth_tokens_v2"
    
    @Published var isLoggedIn = false
    
    // MARK: - 토큰 저장 (JSON 직렬화)
    func saveTokens(_ tokens: AuthTokens) throws {
        let encoder = JSONEncoder()
        encoder.dateEncodingStrategy = .iso8601
        
        let data = try encoder.encode(tokens)
        guard let jsonString = String(data: data, encoding: .utf8) else {
            throw KeychainError.invalidData
        }
        
        try keychain.save(jsonString, forKey: tokenKey)
        isLoggedIn = true
    }
    
    // MARK: - 토큰 로드 및 유효성 검사
    func loadValidTokens() async throws -> AuthTokens {
        guard let jsonString = try? keychain.read(forKey: tokenKey) else {
            throw KeychainError.itemNotFound
        }
        
        let decoder = JSONDecoder()
        decoder.dateDecodingStrategy = .iso8601
        
        guard let data = jsonString.data(using: .utf8),
              let tokens = try? decoder.decode(AuthTokens.self, from: data) else {
            throw KeychainError.invalidData
        }
        
        // 만료 임박 시 자동 갱신
        if tokens.isNearExpiry {
            return try await refreshTokens(refreshToken: tokens.refreshToken)
        }
        
        // 완전 만료 시 로그아웃
        if tokens.isExpired {
            logout()
            throw KeychainError.itemNotFound
        }
        
        return tokens
    }
    
    // MARK: - 토큰 갱신
    private func refreshTokens(refreshToken: String) async throws -> AuthTokens {
        // 실제 API 호출로 토큰 갱신
        // let newTokens = try await APIClient.shared.refreshToken(refreshToken)
        // try saveTokens(newTokens)
        // return newTokens
        
        // 예시용 더미 반환
        let newTokens = AuthTokens(
            accessToken: "new_access_token",
            refreshToken: refreshToken,
            expiresAt: Date().addingTimeInterval(3600)
        )
        try saveTokens(newTokens)
        return newTokens
    }
    
    // MARK: - 로그아웃
    func logout() {
        try? keychain.delete(forKey: tokenKey)
        isLoggedIn = false
    }
}

// MARK: - 생체 인증 변경 감지
class BiometricChangeDetector {
    
    private let userDefaults = UserDefaults.standard
    private let biometricStateKey = "biometric_domain_state"
    
    // MARK: - 현재 생체 상태 저장
    func saveBiometricState() {
        let context = LAContext()
        var error: NSError?
        
        guard context.canEvaluatePolicy(.deviceOwnerAuthenticationWithBiometrics, 
                                        error: &error) else { return }
        
        // domainState는 생체 정보가 변경될 때마다 바뀌는 Data
        if let domainState = context.evaluatedPolicyDomainState {
            userDefaults.set(domainState, forKey: biometricStateKey)
        }
    }
    
    // MARK: - 생체 정보 변경 여부 확인
    func hasBiometricChanged() -> Bool {
        let context = LAContext()
        var error: NSError?
        
        guard context.canEvaluatePolicy(.deviceOwnerAuthenticationWithBiometrics, 
                                        error: &error) else { return false }
        
        guard let currentState = context.evaluatedPolicyDomainState,
              let savedState = userDefaults.data(forKey: biometricStateKey) else {
            // 저장된 상태 없으면 처음 실행 → 저장하고 변경 없음으로 처리
            saveBiometricState()
            return false
        }
        
        // 상태가 다르면 생체 정보 변경됨!
        if currentState != savedState {
            print("⚠️ 생체 인증 정보가 변경되었습니다!")
            // 보안 조치: 저장된 민감 데이터 삭제 또는 재인증 요구
            return true
        }
        
        return false
    }
    
    // MARK: - 앱 실행 시 체크 로직
    func checkAndHandleBiometricChange(onChanged: () -> Void) {
        if hasBiometricChanged() {
            // 생체 정보 변경 감지 → 보안 조치
            onChanged()
            // 새 상태 저장
            saveBiometricState()
        }
    }
}

// 사용 예시
let detector = BiometricChangeDetector()
detector.checkAndHandleBiometricChange {
    // 생체 정보 변경됨 → 재로그인 요구
    print("🔒 보안을 위해 다시 로그인해주세요")
    TokenManager.shared.logout()
}

import XCTest
@testable import MyApp

// MARK: - Keychain 테스트
final class KeychainManagerTests: XCTestCase {
    
    var sut: KeychainManager!
    let testKey = "test_key_\(UUID().uuidString)"
    
    override func setUp() {
        super.setUp()
        sut = KeychainManager.shared
    }
    
    override func tearDown() {
        // 테스트 후 정리
        try? sut.delete(forKey: testKey)
        super.tearDown()
    }
    
    // MARK: - 저장 테스트
    func test_save_shouldSucceed() throws {
        // Given
        let testValue = "test_password_123"
        
        // When
        XCTAssertNoThrow(try sut.save(testValue, forKey: testKey))
        
        // Then
        let retrieved = try sut.read(forKey: testKey)
        XCTAssertEqual(retrieved, testValue)
    }
    
    // MARK: - 없는 키 읽기 테스트
    func test_read_nonExistentKey_shouldThrowItemNotFound() {
        // Given
        let nonExistentKey = "non_existent_\(UUID().uuidString)"
        
        // When & Then
        XCTAssertThrowsError(try sut.read(forKey: nonExistentKey)) { error in
            XCTAssertEqual(error as? KeychainError, KeychainError.itemNotFound)
        }
    }
    
    // MARK: - 삭제 테스트
    func test_delete_shouldRemoveItem() throws {
        // Given
        try sut.save("test_value", forKey: testKey)
        XCTAssertTrue(sut.exists(forKey: testKey))
        
        // When
        try sut.delete(forKey: testKey)
        
        // Then
        XCTAssertFalse(sut.exists(forKey: testKey))
    }
    
    // MARK: - 업데이트 테스트
    func test_save_existingKey_shouldUpdate() throws {
        // Given
        let originalValue = "original"
        let updatedValue = "updated"
        try sut.save(originalValue, forKey: testKey)
        
        // When
        try sut.save(updatedValue, forKey: testKey)
        
        // Then
        let retrieved = try sut.read(forKey: testKey)
        XCTAssertEqual(retrieved, updatedValue)
    }
}

// MARK: - 탈옥 감지 (기본 수준)
struct JailbreakDetector {
    
    static func isJailbroken() -> Bool {
        #if targetEnvironment(simulator)
        return false  // 시뮬레이터는 항상 false
        #else
        return checkSuspiciousFiles() || 
               checkSandboxViolation() || 
               checkDynamicLibraries()
        #endif
    }
    
    // 탈옥 관련 파일 존재 여부
    private static func checkSuspiciousFiles() -> Bool {
        let suspiciousPaths = [
            "/Applications/Cydia.app",
            "/Library/MobileSubstrate/MobileSubstrate.dylib",
            "/bin/bash",
            "/usr/sbin/sshd",
            "/etc/apt",
            "/private/var/lib/apt/",
            "/usr/bin/ssh"
        ]
        
        return suspiciousPaths.contains { path in
            FileManager.default.fileExists(atPath: path)
        }
    }
    
    // 샌드박스 외부 쓰기 시도
    private static func checkSandboxViolation() -> Bool {
        let testPath = "/private/jailbreak_test_\(UUID().uuidString)"
        do {
            try "test".write(toFile: testPath, atomically: true, encoding: .utf8)
            try FileManager.default.removeItem(atPath: testPath)
            return true  // 쓰기 성공 = 탈옥됨
        } catch {
            return false  // 쓰기 실패 = 정상
        }
    }
    
    // 의심스러운 동적 라이브러리 체크
    private static func checkDynamicLibraries() -> Bool {
        let suspiciousLibs = ["SubstrateLoader", "CydiaSubstrate", "SSLKillSwitch"]
        
        for i in 0..<_dyld_image_count() {
            if let imageName = _dyld_get_image_name(i) {
                let name = String(cString: imageName)
                if suspiciousLibs.contains(where: { name.contains($0) }) {
                    return true
                }
            }
        }
        return false
    }
}

// 사용 예시
if JailbreakDetector.isJailbroken() {
    // 탈옥 기기에서 앱 실행 제한
    print("⚠️ 보안 위협이 감지되었습니다")
    // 앱 종료 또는 기능 제한
}

// MARK: - 완성된 보안 인증 매니저
@MainActor
final class SecurityManager: ObservableObject {
    
    static let shared = SecurityManager()
    private init() {
        setupInitialState()
    }
    
    // MARK: - 상태
    @Published var isAuthenticated = false
    @Published var requiresReauth = false
    
    private let keychain = KeychainManager.shared
    private let biometric = BiometricAuthManager.shared
    private let changeDetector = BiometricChangeDetector()
    private let tokenManager = TokenManager.shared
    
    // 마지막 인증 시간 (세션 타임아웃용)
    private var lastAuthTime: Date?
    private let sessionTimeout: TimeInterval = 300  // 5분
    
    // MARK: - 초기 설정
    private func setupInitialState() {
        // 탈옥 감지
        if JailbreakDetector.isJailbroken() {
            print("🚨 탈옥 기기 감지 - 보안 기능 제한")
            // 실제 앱에서는 여기서 앱 종료 또는 기능 제한
        }
        
        // 생체 인증 변경 감지
        changeDetector.checkAndHandleBiometricChange {
            print("⚠️ 생체 인증 변경 감지 - 재로그인 필요")
            self.tokenManager.logout()
        }
    }
    
    // MARK: - 앱 실행 시 인증 플로우
    func performAppLaunchAuth() async {
        // 1. 세션 타임아웃 체크
        if let lastAuth = lastAuthTime,
           Date().timeIntervalSince(lastAuth) < sessionTimeout {
            isAuthenticated = true
            return
        }
        
        // 2. 저장된 토큰 확인
        guard let _ = try? await tokenManager.loadValidTokens() else {
            // 토큰 없음 → 로그인 화면으로
            isAuthenticated = false
            return
        }
        
        // 3. 생체 인증 실행
        await performBiometricAuth()
    }
    
    // MARK: - 생체 인증 실행
    func performBiometricAuth() async {
        let result = await biometric.authenticate(
            reason: "앱에 안전하게 접근하기 위해 인증이 필요합니다"
        )
        
        switch result {
        case .success:
            isAuthenticated = true
            lastAuthTime = Date()
            changeDetector.saveBiometricState()  // 인증 성공 시 상태 업데이트
            
        case .failure(let error):
            handleAuthFailure(error)
        }
    }
    
    // MARK: - 인증 실패 처리
    private func handleAuthFailure(_ error: AuthError) {
        switch error {
        case .biometryLockout:
            // 생체 잠금 → 기기 암호로 폴백
            Task { await performDevicePasscodeAuth() }
            
        case .biometryNotEnrolled:
            // 생체 미등록 → 기기 암호 사용
            Task { await performDevicePasscodeAuth() }
            
        case .userCancel:
            // 취소 → 인증 화면 유지
            isAuthenticated = false
            
        default:
            isAuthenticated = false
            requiresReauth = true
        }
    }
    
    // MARK: - 기기 암호 인증
    private func performDevicePasscodeAuth() async {
        let result = await biometric.authenticateWithFallback(
            reason: "기기 암호로 인증해주세요"
        )
        
        switch result {
        case .success:
            isAuthenticated = true
            lastAuthTime = Date()
        case .failure:
            isAuthenticated = false
        }
    }
    
    // MARK: - 앱 백그라운드 진입 시
    func handleAppBackground() {
        // 백그라운드 진입 시 인증 상태 유지 (타임아웃 전까지)
        // 민감한 화면은 블러 처리 필요
    }
    
    // MARK: - 앱 포그라운드 복귀 시
    func handleAppForeground() async {
        // 세션 타임아웃 체크
        if let lastAuth = lastAuthTime,
           Date().timeIntervalSince(lastAuth) >= sessionTimeout {
            isAuthenticated = false
            await performBiometricAuth()
        }
    }
    
    // MARK: - 로그아웃
    func logout() {
        tokenManager.logout()
        isAuthenticated = false
        lastAuthTime = nil
    }
}

// MARK: - App 레벨에서 사용
@main
struct MySecureApp: App {
    
    @StateObject private var securityManager = SecurityManager.shared
    @Environment(\.scenePhase) private var scenePhase
    
    var body: some Scene {
        WindowGroup {
            ContentView()
                .environmentObject(securityManager)
                .onChange(of: scenePhase) { _, newPhase in
                    switch newPhase {
                    case .background:
                        securityManager.handleAppBackground()
                    case .active:
                        Task { await securityManager.handleAppForeground() }
                    default:
                        break
                    }
                }
                .task {
                    await securityManager.performAppLaunchAuth()
                }
        }
    }
}

// ✅ 올바른 방법 - 백그라운드에서 Keychain 접근
func loadTokenAsync() async throws -> String {
    return try await Task.detached(priority: .userInitiated) {
        try KeychainManager.shared.read(forKey: "auth_token")
    }.value
}

// ❌ 잘못된 방법 - 메인 스레드에서 직접 접근
// let token = try KeychainManager.shared.read(forKey: "auth_token")
// → UI 블로킹 발생 가능!