Profile manager

@MainActor
final class ProfileManager: ObservableObject {
    let context: ModelContext
    @Published var profiles: [Profile] = []
    
    // Ephemeral profiles (one per incognito window)
    private var ephemeralProfiles: [UUID: Profile] = [:]  // windowId -> profile
}

func loadProfiles() {
    do {
        let descriptor = FetchDescriptor<ProfileEntity>(
            sortBy: [SortDescriptor(\.index, order: .forward)]
        )
        let entities = try context.fetch(descriptor)
        self.profiles = entities.map { e in
            Profile(id: e.id, name: e.name, icon: e.icon)
        }
        // Normalize indices if not sequential 0..n-1
        let expected = Array(0..<entities.count)
        let actual = entities.map { $0.index }
        if actual != expected { persistProfiles() }
    } catch {
        print("[ProfileManager] Failed to load profiles: \(error)")
        self.profiles = []
    }
}

@discardableResult
func createProfile(name: String, icon: String = "person.crop.circle") -> Profile {
    let nextIndex = profiles.count
    let profile = Profile(name: name, icon: icon)
    let entity = ProfileEntity(id: profile.id, name: name, icon: icon, index: nextIndex)
    
    context.insert(entity)
    do { try context.save() } catch { 
        print("[ProfileManager] Save failed during create: \(error)") 
    }
    
    profiles.append(profile)
    return profile
}

func deleteProfile(_ profile: Profile) -> Bool {
    guard profiles.count > 1 else { return false }  // Prevent deleting last profile
    
    // Remove from SwiftData first
    do {
        let pid = profile.id
        let predicate = #Predicate<ProfileEntity> { $0.id == pid }
        if let entity = try context.fetch(FetchDescriptor<ProfileEntity>(predicate: predicate)).first {
            context.delete(entity)
        }
        try context.save()
    } catch {
        print("[ProfileManager] Delete failed: \(error)")
        return false
    }
    
    // Remove from runtime and reindex
    if let idx = profiles.firstIndex(where: { $0.id == profile.id }) {
        profiles.remove(at: idx)
    }
    persistProfiles()
    return true
}

func persistProfiles() {
    do {
        // Fetch all existing entities
        let all = try context.fetch(FetchDescriptor<ProfileEntity>())
        var byId: [UUID: ProfileEntity] = Dictionary(uniqueKeysWithValues: all.map { ($0.id, $0) })
        
        // Update or insert to match runtime profiles order
        for (index, p) in profiles.enumerated() {
            if let e = byId[p.id] {
                e.name = p.name
                e.icon = p.icon
                e.index = index
            } else {
                let e = ProfileEntity(id: p.id, name: p.name, icon: p.icon, index: index)
                context.insert(e)
                byId[p.id] = e
            }
        }
        
        // Remove entities not present in runtime array
        let keep = Set(profiles.map { $0.id })
        for (id, e) in byId where !keep.contains(id) { 
            context.delete(e) 
        }
        
        try context.save()
    } catch {
        print("[ProfileManager] Persist failed: \(error)")
    }
}

func createEphemeralProfile(for windowId: UUID) -> Profile {
    let profile = Profile.createEphemeral()
    ephemeralProfiles[windowId] = profile
    print("🔒 [ProfileManager] Created ephemeral profile for window: \(windowId)")
    return profile
}

@Observable
class Profile: Identifiable {
    let id: UUID
    var name: String
    var icon: String
    var isEphemeral: Bool = false
    
    private var dataStore: WKWebsiteDataStore?
    
    var websiteDataStore: WKWebsiteDataStore {
        if let store = dataStore { return store }
        
        if isEphemeral {
            let store = WKWebsiteDataStore.nonPersistent()
            dataStore = store
            return store
        } else {
            let store = WKWebsiteDataStore(forIdentifier: id)
            dataStore = store
            return store
        }
    }
    
    static func createEphemeral() -> Profile {
        let profile = Profile(name: "Incognito", icon: "eye.slash")
        profile.isEphemeral = true
        return profile
    }
}

func removeEphemeralProfile(for windowId: UUID) async {
    guard let profile = ephemeralProfiles[windowId] else { return }
    
    print("🔒 [ProfileManager] Removing ephemeral profile: \(profile.id) for window: \(windowId)")
    
    // Remove from tracking immediately
    ephemeralProfiles.removeValue(forKey: windowId)
    
    // Destroy the data store with timeout protection
    await withCheckedContinuation { (continuation: CheckedContinuation<Void, Never>) in
        var resumed = false
        let resumeSafely: () -> Void = {
            guard !resumed else { return }
            resumed = true
            continuation.resume()
        }
        
        // Timeout after 5 seconds
        Task {
            try? await Task.sleep(nanoseconds: 5_000_000_000)
            if !resumed {
                print("⚠️ [ProfileManager] Timeout destroying ephemeral data store")
                resumeSafely()
            }
        }
        
        profile.destroyEphemeralDataStore {
            resumeSafely()
        }
    }
    
    print("🔒 [ProfileManager] Ephemeral profile removed: \(profile.id)")
}

// In BrowserConfig.swift
func webViewConfiguration(for profile: Profile) -> WKWebViewConfiguration {
    let config = webViewConfiguration.copy() as! WKWebViewConfiguration
    config.websiteDataStore = profile.websiteDataStore
    return config
}

// In ExtensionManager.swift
private func getExtensionDataStore(for profileId: UUID) -> WKWebsiteDataStore {
    if let store = profileExtensionStores[profileId] {
        return store
    }
    let store = WKWebsiteDataStore(forIdentifier: profileId)
    profileExtensionStores[profileId] = store
    return store
}

func switchProfile(_ profileId: UUID) {
    guard let controller = extensionController else { return }
    let store = getExtensionDataStore(for: profileId)
    controller.configuration.defaultWebsiteDataStore = store
    currentProfileId = profileId
}

// 1. BrowserManager triggers the switch
func switchProfile(_ profile: Profile) {
    currentProfile = profile
    
    // 2. Update extension data store
    if #available(macOS 15.4, *) {
        ExtensionManager.shared.switchProfile(profile.id)
    }
    
    // 3. Reload tabs to use new profile's data store
    for tab in tabManager.allTabs() {
        tab.reloadWithProfile(profile)
    }
    
    // 4. Update window states
    for (_, windowState) in windowRegistry?.windows ?? [:] {
        windowState.profileId = profile.id
    }
}

func ensureDefaultProfile() {
    if profiles.isEmpty {
        _ = createProfile(name: "Default", icon: "person.crop.circle")
    }
}

func ephemeralProfile(for windowId: UUID) -> Profile? {
    return ephemeralProfiles[windowId]
}

func isEphemeralProfile(_ profileId: UUID) -> Bool {
    return ephemeralProfiles.values.contains { $0.id == profileId }
}

// In TabManager
func createSpace(name: String, icon: String, gradient: SpaceGradient) -> Space {
    let profileId = browserManager?.currentProfile?.id 
                    ?? browserManager?.profileManager.profiles.first?.id
    guard let profileId = profileId else {
        fatalError("TabManager.createSpace requires at least one profile")
    }
    let space = Space(name: name, icon: icon, gradient: gradient, profileId: profileId)
    // ...
}

// Global pinned tabs are stored per profile
var pinnedTabs: [Tab] {
    guard let pid = browserManager?.currentProfile?.id else { return [] }
    return Array(pinnedByProfile[pid] ?? []).sorted { $0.index < $1.index }
}