import Compression
import Foundation

// MARK: - Smart Start Catalog Runtime

struct SmartStartSummary: Equatable {
    let matchedAppCount: Int
    let assignedTagCount: Int
    let createdTagCount: Int
    let backupPath: String?
}

enum SmartStartRunMode: Equatable {
    case none
    case autoApplied
    case suggestionOnly
}

struct SmartStartRunResult {
    let mode: SmartStartRunMode
    let store: TagDatabase.Store
    let draft: SmartCategorizationDraft?
    let summary: SmartStartSummary?
}

private struct SmartStartCatalogEntry {
    let entryID: String
    let rank: Int
    let name: String
    let normalizedName: String
    let bundleIdentifier: String?
    let categoryIDs: [SmartCategoryID]
    let localizedNote: SmartStartLocalizedNote?
    let sourceEvidence: [String]
}

private struct SmartStartLocalizedNote {
    let note: String
    let languageCode: String
    let provenance: SmartDefaultNoteProvenance
}

private struct SmartStartBaseCatalog: Decodable {
    let resourceFormatVersion: Int
    let catalogContentVersion: Int
    let noteLimit: Int?
    let supportedLanguages: [String]
    let fallbackLanguages: [String]
    let entries: [SmartStartBaseCatalogEntry]
}

private struct SmartStartBaseCatalogEntry: Decodable {
    let entryID: String
    let rank: Int?
    let name: String
    let normalizedName: String?
    let bundleIdentifier: String?
    let defaultTag: [String]
    let sourceEvidence: [String]?
}

private struct SmartStartNotesCatalog: Decodable {
    let resourceFormatVersion: Int
    let catalogContentVersion: Int
    let notesVersion: Int
    let language: String
    let entries: [SmartStartNoteEntry]
}

private struct SmartStartNoteEntry: Decodable {
    let entryID: String
    let note: String
}

private struct SmartStartBaseSnapshot {
    let catalogContentVersion: Int
    let supportedLanguages: [String]
    let fallbackLanguages: [String]
    let entries: [SmartStartBaseCatalogEntry]
    let bundleIndex: [String: SmartStartBaseCatalogEntry]
    let nameIndex: [String: SmartStartBaseCatalogEntry]
    let entryIndex: [String: SmartStartBaseCatalogEntry]
}

private struct SmartStartNotesSnapshot {
    let languageCode: String
    let notesVersion: Int
    let notes: [String: String]
}

private struct SmartStartCatalogSnapshot {
    let entries: [SmartStartCatalogEntry]
    let bundleIndex: [String: SmartStartCatalogEntry]
    let nameIndex: [String: SmartStartCatalogEntry]
    let entryIndex: [String: SmartStartCatalogEntry]
}

enum SmartStartService {
    static let catalogVersion = 2
    private static let catalogCacheLock = NSLock()
    private static var cachedBaseSnapshot: SmartStartBaseSnapshot?
    private static var cachedCatalogSnapshots: [String: SmartStartCatalogSnapshot] = [:]
    private static var cachedNotesSnapshots: [String: SmartStartNotesSnapshot] = [:]

    static let systemInitialSchemeCreatedAt: Date = {
        var components = DateComponents()
        components.calendar = Calendar(identifier: .gregorian)
        components.timeZone = TimeZone(identifier: "Asia/Hong_Kong")
        components.year = 2026
        components.month = 5
        components.day = 18
        components.hour = 0
        components.minute = 0
        components.second = 0
        return components.date ?? Date(timeIntervalSince1970: 0)
    }()

    static var systemInitialSchemeName: String {
        TagDatabase.schemeName(prefixKey: "scheme.systemSmartStart", at: systemInitialSchemeCreatedAt)
    }

    static func runIfNeeded(
        apps: [AppInfo],
        store initialStore: TagDatabase.Store
    ) -> SmartStartRunResult {
        guard shouldRun(for: initialStore) else {
            return SmartStartRunResult(mode: .none, store: initialStore, draft: nil, summary: nil)
        }

        let draft = makeDraft(apps: apps)
        guard !draft.assignments.isEmpty else {
            var store = initialStore
            store.smartStart.catalogVersion = catalogVersion
            store.smartStart.lastRunAt = Date()
            store.smartStart.lastMode = "no_matches"
            TagDatabase.save(store)
            return SmartStartRunResult(mode: .none, store: store, draft: nil, summary: nil)
        }

        if shouldAutoApply(to: initialStore) {
            let applied = applyDraft(draft, to: initialStore, mode: "auto_applied")
            return SmartStartRunResult(
                mode: .autoApplied,
                store: applied.store,
                draft: draft,
                summary: applied.summary
            )
        }

        var store = initialStore
        store.smartStart.catalogVersion = catalogVersion
        store.smartStart.lastRunAt = Date()
        store.smartStart.lastSuggestionAt = Date()
        store.smartStart.lastMode = "suggestion_only"
        store.smartStart.lastMatchedAppCount = draft.assignments.count
        store.smartStart.lastAssignedTagCount = draft.assignments.reduce(0) { $0 + $1.categoryIDs.count }
        TagDatabase.save(store)

        let summary = SmartStartSummary(
            matchedAppCount: draft.assignments.count,
            assignedTagCount: draft.assignments.reduce(0) { $0 + $1.categoryIDs.count },
            createdTagCount: 0,
            backupPath: nil
        )

        return SmartStartRunResult(mode: .suggestionOnly, store: store, draft: draft, summary: summary)
    }

    static func applySuggestion(_ draft: SmartCategorizationDraft) -> SmartStartRunResult {
        let applied = applyDraft(draft, to: TagDatabase.load(), mode: "manual_applied")
        return SmartStartRunResult(
            mode: .autoApplied,
            store: applied.store,
            draft: draft,
            summary: applied.summary
        )
    }

    static func applySystemInitialScheme(apps: [AppInfo]) -> SmartStartRunResult {
        let draft = makeDraft(apps: apps)
        guard !draft.assignments.isEmpty else {
            return SmartStartRunResult(mode: .none, store: TagDatabase.load(), draft: draft, summary: nil)
        }

        let applied = applyDraft(
            draft,
            to: TagDatabase.loadWithEnsuredCategoryScheme(),
            mode: "settings_system_applied",
            replaceExistingScheme: true
        )
        return SmartStartRunResult(
            mode: .autoApplied,
            store: applied.store,
            draft: draft,
            summary: applied.summary
        )
    }

    @discardableResult
    static func relocalizeDefaultNotesForCurrentLanguage(apps: [AppInfo]) -> Bool {
        let catalog = loadCatalogSnapshot()
        guard !catalog.entries.isEmpty else { return false }

        var store = TagDatabase.load()
        var changed = false
        let appPaths = Set(apps.map { $0.path.path })

        for path in appPaths {
            guard let currentNote = normalizedNote(store.appNotes[path]) else { continue }
            guard let metadata = store.appNoteMetadata[path] else { continue }

            let currentFingerprint = TagDatabase.noteFingerprint(currentNote)
            let localizedNote: SmartStartLocalizedNote?
            switch metadata.origin {
            case .catalogDefault:
                guard let currentCatalog = metadata.catalog,
                      currentCatalog.noteFingerprint == currentFingerprint,
                      let matched = catalog.entryIndex[currentCatalog.entryID]
                else { continue }
                localizedNote = matched.localizedNote
            case .appleDefault, .manual:
                continue
            }

            guard let localizedNote, localizedNote.note != currentNote else { continue }

            store.appNotes[path] = localizedNote.note
            store.appNoteMetadata[path] = TagDatabase.AppNoteMetadata(
                origin: .catalogDefault,
                catalog: localizedNote.provenance,
                noteFingerprint: localizedNote.provenance.noteFingerprint
            )
            changed = true
        }

        if changed {
            TagDatabase.save(store)
        }
        return changed
    }

    static func restoreBackup(at path: String) -> Bool {
        let url = URL(fileURLWithPath: path)
        guard let data = try? Data(contentsOf: url),
              var store = try? JSONDecoder().decode(TagDatabase.Store.self, from: data)
        else { return false }

        let now = Date()
        if store.categoryScheme.currentName == nil {
            store.categoryScheme.currentName = TagDatabase.schemeName(prefixKey: "scheme.beforeSmartStart", at: now)
            store.categoryScheme.currentCreatedAt = now
        }
        store.categoryScheme.lastChangedAt = now
        store.smartStart.catalogVersion = catalogVersion
        store.smartStart.lastRunAt = now
        store.smartStart.lastMode = "restored_from_backup"
        store.smartStart.lastBackupPath = path
        TagDatabase.save(store)
        return true
    }

    static func makeDraft(apps: [AppInfo]) -> SmartCategorizationDraft {
        let catalog = loadCatalogSnapshot()

        var seenAssignments = Set<String>()
        var assignments: [SmartAppCategorizationAssignment] = []
        var unassigned: [SmartUnassignedApp] = []

        for app in apps {
            if let appleCategorization = AppleDefaultAppCatalog.categorization(for: app) {
                let key = app.bundleIdentifier?.lowercased() ?? app.path.path
                guard seenAssignments.insert(key).inserted else { continue }

                assignments.append(SmartAppCategorizationAssignment(
                    appName: app.name,
                    bundleIdentifier: app.bundleIdentifier,
                    path: app.path.path,
                    categoryIDs: appleCategorization.categoryIDs,
                    confidence: 0.92,
                    source: .localCatalog,
                    reason: "Matched Apple default app catalog entry: \(appleCategorization.canonicalName)",
                    provenance: appleCategorization.provenance
                ))
                continue
            }

            let matched = match(
                app: app,
                bundleIndex: catalog.bundleIndex,
                nameIndex: catalog.nameIndex
            )
            guard let matched else {
                unassigned.append(SmartUnassignedApp(
                    appName: app.name,
                    bundleIdentifier: app.bundleIdentifier,
                    path: app.path.path,
                    reason: "No local Smart Start catalog match"
                ))
                continue
            }

            let key = app.bundleIdentifier?.lowercased() ?? app.path.path
            guard seenAssignments.insert(key).inserted else { continue }

            assignments.append(SmartAppCategorizationAssignment(
                appName: app.name,
                bundleIdentifier: app.bundleIdentifier,
                path: app.path.path,
                categoryIDs: matched.categoryIDs,
                confidence: confidence(for: matched),
                source: .localCatalog,
                reason: "Matched Smart Start catalog entry: \(matched.name)",
                provenance: matched.sourceEvidence,
                defaultNote: matched.localizedNote?.note,
                defaultNoteCandidates: matched.localizedNote.map { [$0.note] } ?? [],
                defaultNoteProvenance: matched.localizedNote?.provenance
            ))
        }

        return SmartCategorizationDraft(
            draftSource: .localSmartStart,
            assignments: assignments.sorted {
                $0.appName.localizedStandardCompare($1.appName) == .orderedAscending
            },
            unassigned: unassigned
        )
    }

    private static func shouldRun(for store: TagDatabase.Store) -> Bool {
        store.smartStart.catalogVersion < catalogVersion
            || (store.smartStart.lastRunAt == nil
                && store.smartStart.lastAppliedAt == nil
                && store.smartStart.lastSuggestionAt == nil)
    }

    private static func shouldAutoApply(to store: TagDatabase.Store) -> Bool {
        !store.hasUserTagAssignments
    }

    private static func applyDraft(
        _ draft: SmartCategorizationDraft,
        to initialStore: TagDatabase.Store,
        mode: String,
        replaceExistingScheme: Bool = false
    ) -> (store: TagDatabase.Store, summary: SmartStartSummary) {
        var normalizedInitialStore = initialStore
        _ = TagDatabase.normalizeCategorySchemeMetadata(&normalizedInitialStore)
        var store = normalizedInitialStore
        let now = Date()
        let backupURL = TagDatabase.backup(normalizedInitialStore, reason: "smart-start-\(mode)")
        let usedCategoryIDs = orderedUsedCategoryIDs(in: draft)
        let systemCategoryIDsToCreate = replaceExistingScheme
            ? SmartCategoryDefaults.orderedIDs
            : usedCategoryIDs
        var createdTagCount = 0

        if replaceExistingScheme {
            store.tags = [:]
            store.appTags = [:]
            store.tagOrder = []
            store.containerAppOrder = [:]
            store.disabledSystemCategoryIDs = []
        }

        for categoryID in systemCategoryIDsToCreate {
            guard replaceExistingScheme || !store.disabledSystemCategoryIDs.contains(categoryID) else {
                continue
            }
            if let result = TagDatabase.ensureSystemTag(for: categoryID, in: &store) {
                if var tagDef = store.tags[result.name] {
                    tagDef.color = categoryID.defaultColorIndex
                    store.tags[result.name] = tagDef
                }
                if result.created {
                    createdTagCount += 1
                }
                if !store.tagOrder.contains(result.name) {
                    store.tagOrder.append(result.name)
                }
            }
        }

        var assignedTagCount = 0
        var uncommonPaths = Set(store.uncommonAppPaths)
        for assignment in draft.assignments {
            guard let path = assignment.path, !path.isEmpty else { continue }
            var currentTags = store.appTags[path] ?? []
            for categoryID in assignment.categoryIDs {
                guard replaceExistingScheme || !store.disabledSystemCategoryIDs.contains(categoryID) else {
                    continue
                }
                guard let tagName = TagDatabase.systemTagName(for: categoryID, in: store) else {
                    continue
                }
                guard store.tags[tagName] != nil else { continue }
                if !currentTags.contains(tagName) {
                    currentTags.append(tagName)
                    assignedTagCount += 1
                }
            }
            if currentTags.isEmpty {
                store.appTags.removeValue(forKey: path)
            } else {
                store.appTags[path] = currentTags
            }

            if let defaultNote = assignment.defaultNote?.trimmingCharacters(in: .whitespacesAndNewlines),
               !defaultNote.isEmpty {
                let currentNote = store.appNotes[path]?.trimmingCharacters(in: .whitespacesAndNewlines)
                let normalizedCurrentNote = normalizedNote(currentNote)
                let existingMetadata = store.appNoteMetadata[path]
                let isManualOverride = existingMetadata?.origin == .manual
                let currentMatchesCatalogDefault = existingMetadata?.origin == .catalogDefault
                    && normalizedCurrentNote.map { TagDatabase.noteFingerprint($0) } == existingMetadata?.catalog?.noteFingerprint
                let knownDefaultNotes = Set(assignment.defaultNoteCandidates.compactMap(normalizedNote))
                let shouldSeedNote = !isManualOverride
                    && (
                        currentNote?.isEmpty != false
                        || currentMatchesCatalogDefault
                        || normalizedCurrentNote.map { knownDefaultNotes.contains($0) } == true
                    )

                if shouldSeedNote {
                    store.appNotes[path] = String(defaultNote.prefix(TagDatabase.maxAppNoteLength))
                    if let provenance = assignment.defaultNoteProvenance {
                        store.appNoteMetadata[path] = TagDatabase.AppNoteMetadata(
                            origin: .catalogDefault,
                            catalog: provenance,
                            noteFingerprint: provenance.noteFingerprint
                        )
                    }
                    if currentNote?.isEmpty != false {
                        uncommonPaths.insert(path)
                        if store.uncommonSources[path] == nil {
                            store.uncommonSources[path] = .auto
                        }
                    }
                }
            }
        }

        store.uncommonAppPaths = uncommonPaths.sorted()
        store.smartStart.catalogVersion = catalogVersion
        store.smartStart.lastRunAt = now
        store.smartStart.lastAppliedAt = now
        store.smartStart.lastBackupPath = backupURL?.path
        store.smartStart.lastMode = mode
        store.smartStart.lastMatchedAppCount = draft.assignments.count
        store.smartStart.lastAssignedTagCount = assignedTagCount
        store.categoryScheme.previousName = normalizedInitialStore.categoryScheme.currentName
            ?? TagDatabase.schemeName(prefixKey: "scheme.beforeSmartStart", at: now)
        store.categoryScheme.previousCreatedAt = normalizedInitialStore.categoryScheme.currentCreatedAt
        store.categoryScheme.previousBackupPath = backupURL?.path
        store.categoryScheme.currentName = replaceExistingScheme
            ? Self.systemInitialSchemeName
            : TagDatabase.schemeName(prefixKey: "scheme.smartStart", at: Self.systemInitialSchemeCreatedAt)
        store.categoryScheme.currentCreatedAt = replaceExistingScheme
            ? Self.systemInitialSchemeCreatedAt
            : Self.systemInitialSchemeCreatedAt
        store.categoryScheme.lastChangedAt = now
        TagDatabase.save(store)

        return (
            store,
            SmartStartSummary(
                matchedAppCount: draft.assignments.count,
                assignedTagCount: assignedTagCount,
                createdTagCount: createdTagCount,
                backupPath: backupURL?.path
            )
        )
    }

    private static func orderedUsedCategoryIDs(in draft: SmartCategorizationDraft) -> [SmartCategoryID] {
        let used = Set(draft.assignments.flatMap(\.categoryIDs))
        return SmartCategoryDefaults.orderedIDs.filter { used.contains($0) }
    }

    private static func match(
        app: AppInfo,
        bundleIndex: [String: SmartStartCatalogEntry],
        nameIndex: [String: SmartStartCatalogEntry]
    ) -> SmartStartCatalogEntry? {
        if let bundleIdentifier = app.bundleIdentifier?.lowercased(),
           let bundleMatch = bundleIndex[bundleIdentifier] {
            return bundleMatch
        }
        return nameIndex[normalizedName(app.name)]
    }

    private static func confidence(for entry: SmartStartCatalogEntry) -> Double {
        if entry.rank <= 300 { return 0.86 }
        if entry.categoryIDs.count > 1 { return 0.74 }
        return 0.68
    }

    private static func loadCatalogSnapshot() -> SmartStartCatalogSnapshot {
        let languageCode = L10n.currentCode
        catalogCacheLock.lock()
        if let snapshot = cachedCatalogSnapshots[languageCode] {
            catalogCacheLock.unlock()
            return snapshot
        }
        catalogCacheLock.unlock()

        guard let base = loadBaseSnapshot() else {
            return SmartStartCatalogSnapshot(entries: [], bundleIndex: [:], nameIndex: [:], entryIndex: [:])
        }
        let snapshot = makeCatalogSnapshot(base: base, languageCode: languageCode)

        catalogCacheLock.lock()
        if let cached = cachedCatalogSnapshots[languageCode] {
            catalogCacheLock.unlock()
            return cached
        }
        cachedCatalogSnapshots[languageCode] = snapshot
        catalogCacheLock.unlock()
        return snapshot
    }

    private static func makeCatalogSnapshot(
        base: SmartStartBaseSnapshot,
        languageCode: String
    ) -> SmartStartCatalogSnapshot {
        let localizedNotes = loadLocalizedNotes(
            for: languageFallbacks(preferredCode: languageCode, base: base)
        )
        let entries = base.entries.compactMap { entry -> SmartStartCatalogEntry? in
            let tagIDs = entry.defaultTag
                .compactMap { SmartCategoryID(rawValue: $0) }
                .compactMap(\.smartStartDefaultCategoryID)
            guard !tagIDs.isEmpty else { return nil }

            return SmartStartCatalogEntry(
                entryID: entry.entryID,
                rank: entry.rank ?? Int.max,
                name: entry.name,
                normalizedName: entry.normalizedName.flatMap {
                    $0.isEmpty ? nil : $0
                } ?? normalizedName(entry.name),
                bundleIdentifier: normalizedBundleIdentifier(entry.bundleIdentifier),
                categoryIDs: uniqueOrdered(tagIDs),
                localizedNote: localizedNotes[entry.entryID],
                sourceEvidence: entry.sourceEvidence ?? []
            )
        }

        var bundleIndex: [String: SmartStartCatalogEntry] = [:]
        var nameIndex: [String: SmartStartCatalogEntry] = [:]
        var entryIndex: [String: SmartStartCatalogEntry] = [:]

        for entry in entries {
            entryIndex[entry.entryID] = entry
            if let bundleIdentifier = entry.bundleIdentifier?.lowercased(), !bundleIdentifier.isEmpty {
                if bundleIndex[bundleIdentifier].map({ $0.rank <= entry.rank }) != true {
                    bundleIndex[bundleIdentifier] = entry
                }
            }

            if nameIndex[entry.normalizedName].map({ $0.rank <= entry.rank }) != true {
                nameIndex[entry.normalizedName] = entry
            }
        }

        return SmartStartCatalogSnapshot(
            entries: entries,
            bundleIndex: bundleIndex,
            nameIndex: nameIndex,
            entryIndex: entryIndex
        )
    }

    private static func loadBaseSnapshot() -> SmartStartBaseSnapshot? {
        catalogCacheLock.lock()
        if let snapshot = cachedBaseSnapshot {
            catalogCacheLock.unlock()
            return snapshot
        }
        catalogCacheLock.unlock()

        guard let url = Bundle.main.url(
            forResource: "SmartStartUltimateDefaultCatalog.base",
            withExtension: "json"
        ),
              let data = try? Data(contentsOf: url),
              let catalog = try? JSONDecoder().decode(SmartStartBaseCatalog.self, from: data),
              catalog.resourceFormatVersion == 1
        else { return nil }

        var bundleIndex: [String: SmartStartBaseCatalogEntry] = [:]
        var nameIndex: [String: SmartStartBaseCatalogEntry] = [:]
        var entryIndex: [String: SmartStartBaseCatalogEntry] = [:]
        for entry in catalog.entries {
            entryIndex[entry.entryID] = entry
            if let bundleIdentifier = normalizedBundleIdentifier(entry.bundleIdentifier)?.lowercased(),
               !bundleIdentifier.isEmpty,
               bundleIndex[bundleIdentifier].map({ ($0.rank ?? Int.max) <= (entry.rank ?? Int.max) }) != true {
                bundleIndex[bundleIdentifier] = entry
            }
            let name = entry.normalizedName.flatMap { $0.isEmpty ? nil : $0 } ?? normalizedName(entry.name)
            if nameIndex[name].map({ ($0.rank ?? Int.max) <= (entry.rank ?? Int.max) }) != true {
                nameIndex[name] = entry
            }
        }

        let snapshot = SmartStartBaseSnapshot(
            catalogContentVersion: catalog.catalogContentVersion,
            supportedLanguages: catalog.supportedLanguages,
            fallbackLanguages: catalog.fallbackLanguages,
            entries: catalog.entries,
            bundleIndex: bundleIndex,
            nameIndex: nameIndex,
            entryIndex: entryIndex
        )

        catalogCacheLock.lock()
        if let cached = cachedBaseSnapshot {
            catalogCacheLock.unlock()
            return cached
        }
        cachedBaseSnapshot = snapshot
        catalogCacheLock.unlock()
        return snapshot
    }

    private static func loadLocalizedNotes(for languageCodes: [String]) -> [String: SmartStartLocalizedNote] {
        var result: [String: SmartStartLocalizedNote] = [:]
        for languageCode in languageCodes {
            guard let notes = loadNotesSnapshot(languageCode: languageCode) else { continue }
            for (entryID, note) in notes.notes where result[entryID] == nil {
                let fingerprint = TagDatabase.noteFingerprint(note)
                result[entryID] = SmartStartLocalizedNote(
                    note: note,
                    languageCode: notes.languageCode,
                    provenance: SmartDefaultNoteProvenance(
                        entryID: entryID,
                        languageCode: notes.languageCode,
                        notesVersion: notes.notesVersion,
                        noteFingerprint: fingerprint
                    )
                )
            }
        }
        return result
    }

    private static func loadNotesSnapshot(languageCode: String) -> SmartStartNotesSnapshot? {
        catalogCacheLock.lock()
        if let snapshot = cachedNotesSnapshots[languageCode] {
            catalogCacheLock.unlock()
            return snapshot
        }
        catalogCacheLock.unlock()

        guard let data = loadNotesCatalogData(languageCode: languageCode),
              let catalog = try? JSONDecoder().decode(SmartStartNotesCatalog.self, from: data),
              catalog.resourceFormatVersion == 1
        else { return nil }

        let notes = Dictionary(uniqueKeysWithValues: catalog.entries.compactMap { entry in
            normalizedNote(entry.note).map { (entry.entryID, $0) }
        })
        let snapshot = SmartStartNotesSnapshot(
            languageCode: catalog.language,
            notesVersion: catalog.notesVersion,
            notes: notes
        )

        catalogCacheLock.lock()
        if let cached = cachedNotesSnapshots[languageCode] {
            catalogCacheLock.unlock()
            return cached
        }
        cachedNotesSnapshots[languageCode] = snapshot
        catalogCacheLock.unlock()
        return snapshot
    }

    private static func loadNotesCatalogData(languageCode: String) -> Data? {
        let resourceName = "SmartStartUltimateDefaultCatalog.notes.\(languageCode)"

        if let url = Bundle.main.url(forResource: resourceName, withExtension: "json.deflate"),
           let compressedData = try? Data(contentsOf: url),
           let data = inflatedDeflateData(from: compressedData) {
            return data
        }

        guard let url = Bundle.main.url(forResource: resourceName, withExtension: "json") else {
            return nil
        }
        return try? Data(contentsOf: url)
    }

    private static func inflatedDeflateData(from compressedData: Data) -> Data? {
        guard !compressedData.isEmpty else { return Data() }

        let maxOutputSize = 16 * 1024 * 1024
        var outputSize = max(compressedData.count * 8, 64 * 1024)

        while outputSize <= maxOutputSize {
            let decoded = compressedData.withUnsafeBytes { sourceBuffer -> Data? in
                guard let sourcePointer = sourceBuffer.bindMemory(to: UInt8.self).baseAddress else {
                    return nil
                }

                let destinationPointer = UnsafeMutablePointer<UInt8>.allocate(capacity: outputSize)
                defer { destinationPointer.deallocate() }

                let decodedCount = compression_decode_buffer(
                    destinationPointer,
                    outputSize,
                    sourcePointer,
                    compressedData.count,
                    nil,
                    COMPRESSION_ZLIB
                )

                guard decodedCount > 0 else { return nil }
                return Data(bytes: destinationPointer, count: decodedCount)
            }

            if let decoded {
                return decoded
            }
            outputSize *= 2
        }

        return nil
    }

    private static func languageFallbacks(
        preferredCode: String,
        base: SmartStartBaseSnapshot
    ) -> [String] {
        var codes: [String] = []
        func append(_ code: String) {
            guard !code.isEmpty,
                  base.supportedLanguages.contains(code),
                  !codes.contains(code)
            else { return }
            codes.append(code)
        }

        append(preferredCode)
        switch preferredCode {
        case "ar-Najdi":
            append("ar")
        case "nn":
            append("nb")
            append("no")
        case "no":
            append("nb")
            append("nn")
        case "nb":
            append("no")
            append("nn")
        default:
            break
        }
        for code in base.fallbackLanguages {
            append(code)
        }
        append("en")
        append("zh-Hans")
        append("zh-Hant")
        return codes
    }

    private static func normalizedNote(_ value: String?) -> String? {
        guard let value else { return nil }
        let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
        guard !trimmed.isEmpty else { return nil }
        return String(trimmed.prefix(TagDatabase.maxAppNoteLength))
    }

    private static func normalizedBundleIdentifier(_ value: String?) -> String? {
        guard let value = value?.trimmingCharacters(in: .whitespacesAndNewlines),
              !value.isEmpty,
              !["null", "nil", "undefined"].contains(value.lowercased())
        else { return nil }
        return value
    }

    private static func uniqueOrdered(_ ids: [SmartCategoryID]) -> [SmartCategoryID] {
        var seen = Set<SmartCategoryID>()
        return ids.filter { seen.insert($0).inserted }
    }

    private static func splitPipe(_ value: String) -> [String] {
        value
            .split(separator: "|")
            .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
            .filter { !$0.isEmpty }
    }

    private static func normalizedName(_ value: String) -> String {
        value
            .folding(options: [.diacriticInsensitive, .caseInsensitive], locale: .current)
            .lowercased()
            .replacingOccurrences(of: "&", with: " and ")
            .components(separatedBy: CharacterSet.alphanumerics.inverted)
            .filter { !$0.isEmpty }
            .joined(separator: "-")
    }

    private static func parseCSV(_ csv: String) -> [[String]] {
        var rows: [[String]] = []
        var row: [String] = []
        var field = ""
        var quoted = false
        var index = csv.startIndex

        while index < csv.endIndex {
            let character = csv[index]

            if quoted {
                if character == "\"" {
                    let next = csv.index(after: index)
                    if next < csv.endIndex, csv[next] == "\"" {
                        field.append("\"")
                        index = next
                    } else {
                        quoted = false
                    }
                } else {
                    field.append(character)
                }
            } else {
                switch character {
                case "\"":
                    quoted = true
                case ",":
                    row.append(field)
                    field = ""
                case "\n":
                    row.append(field)
                    rows.append(row)
                    row = []
                    field = ""
                case "\r":
                    break
                default:
                    field.append(character)
                }
            }

            index = csv.index(after: index)
        }

        if !field.isEmpty || !row.isEmpty {
            row.append(field)
            rows.append(row)
        }

        return rows
    }
}