VAULT ARCHITECTURE

import Foundation
import CryptoKit

@MainActor
class VaultCrypto: ObservableObject {
    private var vaultKey: SymmetricKey?
    private var fadeKey: SymmetricKey?
    
    private let vaultKeyName = "com.nu11vlt.vaultKey"
    private let fadeKeyName = "com.nu11vlt.fadeKey"
    private let decoyKeyName = "com.nu11vlt.vaultKey.decoy"
    
    /// Setup or load the vault encryption key (256-bit)
    func setupVaultKey() -> Bool {
        if let existingKey = KeychainHelper.loadKey(forName: vaultKeyName) {
            self.vaultKey = existingKey
            return true
        } else {
            let newKey = SymmetricKey(size: .bits256)
            if KeychainHelper.saveKey(newKey, forName: vaultKeyName) {
                self.vaultKey = newKey
                return true
            }
            return false
        }
    }
    
    /// Encrypt image data with ChaCha20-Poly1305 AEAD
    func encryptVaultImage(_ imageData: Data) throws -> Data {
        guard let key = vaultKey else {
            throw CryptoError.keyNotAvailable
        }
        
        // ChaCha20-Poly1305 provides:
        // - Confidentiality (encryption)
        // - Authenticity (HMAC)
        // - Integrity (tampering detection)
        let sealedBox = try ChaChaPoly.seal(imageData, using: key)
        
        return sealedBox.combined // Nonce + Ciphertext + Tag
    }
    
    /// Decrypt image data from vault storage
    func decryptVaultImage(_ encryptedData: Data) throws -> Data {
        guard let key = vaultKey else {
            throw CryptoError.keyNotAvailable
        }
        
        let sealedBox = try ChaChaPoly.SealedBox(combined: encryptedData)
        let decryptedData = try ChaChaPoly.open(sealedBox, using: key)
        
        return decryptedData
    }
    
    /// Switch to decoy vault (Panic PIN triggered)
    func switchToDecoyVault() {
        if let decoyKey = KeychainHelper.loadKey(forName: decoyKeyName) {
            self.vaultKey = decoyKey
            // Adversary sees decoy photos with zero indicators
        }
    }
}

/// Validate PIN and determine which vault to unlock
func validatePINAndUnlock(_ pin: String) -> UnlockResult {
    // Check panic PIN first (adversary doesn't know it exists)
    if PanicPINManager.shared.hasPanicPINConfigured && 
       PanicPINManager.shared.validatePanicPIN(pin) {
        
        #if DEBUG
        print("[AUTH] Panic PIN detected - loading decoy vault")
        #endif
        
        // Switch to decoy vault silently
        self.unlockResult = .decoyVault
        self.isUnlocked = true
        return .decoyVault
    }
    
    // Check real PIN (Two-Factor authentication)
    if TwoFactorManager.shared.validatePIN(pin) {
        #if DEBUG
        print("[AUTH] Real PIN validated - loading real vault")
        #endif
        
        self.unlockResult = .realVault
        self.isUnlocked = true
        return .realVault
    }
    
    // PIN validation failed
    self.unlockResult = .failed
    return .failed
}

enum UnlockResult {
    case realVault   // Load real photos (VaultPhoto models)
    case decoyVault  // Load innocent photos (DecoyPhoto models)
    case failed      // Authentication failed
}

@MainActor
class SkeletonSwitchManager: ObservableObject {
    @Published var isEnabled: Bool = false
    @Published var checkInInterval: TimeInterval = 604800 // 7 days default
    
    /// Called when app launches - check if deadline exceeded
    func appDidLaunch() -> Bool {
        guard isEnabled else { return true }
        
        let lastCheckIn = getLastCheckIn()
        let elapsed = Date().timeIntervalSince(lastCheckIn)
        
        // Deadline exceeded - nuke everything
        if elapsed > checkInInterval {
            #if DEBUG
            print("[SKELETON] ☠️ Check-in deadline exceeded. Wiping vault.")
            #endif
            
            nukeEverything()
            return false // Tell app to show "Vault Wiped" screen
        }
        
        return true
    }
    
    /// User successfully authenticated - reset timer
    func checkIn() {
        guard isEnabled else { return }
        
        KeychainHelper.set(
            Date().timeIntervalSince1970.description, 
            for: "com.nu11vlt.skeletonLastCheckIn"
        )
        
        #if DEBUG
        print("[SKELETON] ✓ Check-in successful. Timer reset.")
        #endif
    }
    
    /// The Nuclear Option ☢️
    private func nukeEverything() {
        // 1. Wipe encryption keys (makes photos unrecoverable)
        VaultCrypto.shared.wipeAllKeys()
        
        // 2. Delete all photo files from disk
        VaultManager.shared.nukeFileSystem()
        
        // 3. Wipe SwiftData database
        // (handled by app showing VaultWipedView)
        
        #if DEBUG
        print("[SKELETON] ☢️ Vault nuked. No recovery possible.")
        #endif
    }
}