Settings and Preferences

private func getAppVersion() -> String {
    let version = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "Unknown"
    let build = Bundle.main.infoDictionary?["CFBundleVersion"] as? String ?? "Unknown"
    return "v\(version) (\(build))"
}

if !defaultBrowserManager.isDefault {
    HStack {
        Text("Born for your Mac. Make Ora your default browser.")
        Spacer()
        Button("Set Ora as default") { 
            DefaultBrowserManager.requestSetAsDefault() 
        }
    }
}

Toggle("Auto Picture-in-Picture on tab switch", isOn: $settings.autoPiPEnabled)

Toggle("Automatically check for updates", isOn: $settings.autoUpdateEnabled)

Button("Check for Updates") {
    updateService.checkForUpdates()
}

Toggle("Block third-party trackers", isOn: $settings.blockThirdPartyTrackers)
Toggle("Block fingerprinting", isOn: $settings.blockFingerprinting)
Toggle("Ad Blocking", isOn: $settings.adBlocking)

enum CookiesPolicy: String, CaseIterable, Identifiable, Codable {
    case allowAll = "Allow all"
    case blockThirdParty = "Block third-party"
    case blockAll = "Block all"
    
    var id: String {
        rawValue
    }
}

struct SitePermissionSettings: Codable, Hashable, Identifiable {
    var id: String { host }
    
    let host: String
    var camera: Bool
    var microphone: Bool
    var location: Bool
    var notifications: Bool
}

enum SettingsTab: Hashable {
    case general, spaces, privacySecurity, shortcuts, searchEngines
    
    var symbol: String {
        switch self {
        case .shortcuts: return "command"
        // ...
        }
    }
}

private func handleKeyCapture(_ event: NSEvent) {
    guard let editingShortcut else { return }
    if KeyChord(fromEvent: event) != nil {
        shortcutManager.setCustomShortcut(for: editingShortcut, event: event)
        cancelEditing()
    }
}

@Published var customKeyboardShortcuts: [String: KeyChord] {
    didSet { saveCodable(customKeyboardShortcuts, forKey: customKeyboardShortcutsKey) }
}

// Conventional Search Engines
let conventionalEngines = searchEngineService.builtInSearchEngines.filter {
    !$0.isAIChat
}

// AI Search Engines
let aiEngines = searchEngineService.builtInSearchEngines.filter(\.isAIChat)

struct CustomSearchEngine: Codable, Identifiable, Hashable {
    let id: String
    let name: String
    let searchURL: String
    let aliases: [String]
    let faviconData: Data?
    let faviconBackgroundColorData: Data?
    let isAIChat: Bool
}

private func saveSearchEngine() {
    let aliasesList = newEngineAliases
        .split(separator: ",")
        .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
        .filter { !$0.isEmpty }
    
    CustomSearchEngine.createWithFavicon(
        name: newEngineName,
        searchURL: newEngineURL,
        aliases: aliasesList,
        isAIChat: newEngineIsAI
    ) { [weak settings] engine in
        settings?.addCustomSearchEngine(engine)
    }
}

@Published var globalDefaultSearchEngine: String? {
    didSet { defaults.set(globalDefaultSearchEngine, forKey: globalDefaultSearchEngineKey) }
}

func defaultSearchEngineId(for containerId: UUID) -> String? {
    defaults.string(forKey: keyForDefaultSearch(for: containerId))
}

func setDefaultSearchEngineId(_ id: String?, for containerId: UUID) {
    defaults.set(id, forKey: keyForDefaultSearch(for: containerId))
    objectWillChange.send()
}

class SettingsStore: ObservableObject {
    static let shared = SettingsStore()
    private let defaults = UserDefaults.standard
    
    // Settings are automatically persisted when changed
    @Published var autoUpdateEnabled: Bool {
        didSet { defaults.set(autoUpdateEnabled, forKey: autoUpdateKey) }
    }
}

private func saveCodable(_ value: some Encodable, forKey key: String) {
    let encoder = JSONEncoder()
    if let data = try? encoder.encode(value) {
        defaults.set(data, forKey: key)
    }
}

private static func loadCodable<T: Decodable>(_ type: T.Type, key: String) -> T? {
    let defaults = UserDefaults.standard
    guard let data = defaults.data(forKey: key) else { return nil }
    return try? JSONDecoder().decode(T.self, from: data)
}