import Foundation

struct SourceScanProgress: Sendable {
    var source: Int64
    var files = 0
    var indexed = 0
    var generated = 0
    var cached = 0
    var issues = 0
    var current = "Starting…"
    var messages = [String]()
    var cancelled = false
    var finished = false
}

/// One utility-priority worker/SQLite connection. Audio stays on the source volume;
/// ZIP members use managed media because temporary extraction cannot be referenced.
enum LibraryScanner {
    static func scan(_ source: MediaLocation,database: URL,media: URL,cache: URL,forceWaveforms: Bool = false,cancelled: () -> Bool = { false },progress: (SourceScanProgress) -> Void = { _ in }) throws -> SourceScanProgress {
        var root = URL(fileURLWithPath:source.path)
        if let bookmark = source.bookmark,!bookmark.isEmpty {
            var stale = false
            if let resolved = try? URL(resolvingBookmarkData:bookmark,options:[.withSecurityScope,.withoutUI],relativeTo:nil,bookmarkDataIsStale:&stale) { root = resolved }
        }
        let scoped = root.startAccessingSecurityScopedResource();defer { if scoped { root.stopAccessingSecurityScopedResource() } }
        var directory: ObjCBool = false
        guard FileManager.default.fileExists(atPath:root.path,isDirectory:&directory),directory.boolValue else { throw LibraryError.message("Drive or folder is unavailable. Reconnect it and scan again.") }
        let db = try Library(url:database),importer = Importer(media:media)
        let snapshot = try db.sourceSnapshot(source.id)
        var songs = Dictionary(uniqueKeysWithValues:try db.songs().map { ($0.id,$0) })
        var state = SourceScanProgress(source:source.id),lastReport = Date.distantPast
        var seenSongs = Set<Int64>()
        var enumerationMessages = [String]()
        guard let enumerator = FileManager.default.enumerator(at:root,includingPropertiesForKeys:[.isRegularFileKey,.isSymbolicLinkKey],options:[.skipsHiddenFiles,.skipsPackageDescendants],errorHandler:{ url,error in
            if enumerationMessages.count < 20 { enumerationMessages.append(url.lastPathComponent+": "+error.localizedDescription) };return true
        }) else { throw LibraryError.message("Cannot read this folder") }
        for case let file as URL in enumerator {
            if cancelled() { state.cancelled = true;break }
            guard ["mp3","wav","m4a","mp4","m4v","mov","zip"].contains(file.pathExtension.lowercased()) else { continue }
            let values = try? file.resourceValues(forKeys:[.isRegularFileKey,.isSymbolicLinkKey])
            guard values?.isRegularFile == true,values?.isSymbolicLink != true else { continue }
            state.files += 1;state.current = file.lastPathComponent
            do {
                let attributes = try FileManager.default.attributesOfItem(atPath:file.path)
                let size = (attributes[.size] as? NSNumber)?.int64Value ?? 0,modified = (attributes[.modificationDate] as? Date)?.timeIntervalSince1970 ?? 0
                let ids: [Int64]
                if let old = snapshot[file.path],old.size == size,old.modified == modified,!old.songs.isEmpty,old.songs.allSatisfy({ id in songs[id].map { FileManager.default.fileExists(atPath:$0.audio) } ?? false }) {
                    ids = old.songs
                } else {
                    ids = try importer.run([file],library:db,copyMedia:false,cancelled:cancelled)
                    try db.recordSourceFile(source:source.id,path:file.path,size:size,modified:modified,songs:ids)
                    // Refresh after deduplication/relocation, without sharing the UI connection.
                    for id in ids { if let song = try db.song(id) { songs[id] = song } }
                }
                seenSongs.formUnion(ids);state.indexed = seenSongs.count
                for id in ids {
                    if cancelled() { throw CancellationError() }
                    guard let song = songs[id] else { continue }
                    let audio = URL(fileURLWithPath:song.audio)
                    if !forceWaveforms,(try? WaveformCache.load(audio:audio,directory:cache)) != nil { state.cached += 1 }
                    else {
                        let analysis = try AudioWaveform.analyse(url:audio,cancelled:cancelled)
                        try WaveformCache.save(analysis,audio:audio,directory:cache);state.generated += 1
                    }
                }
            } catch is CancellationError { state.cancelled = true;break }
            catch {
                state.issues += 1
                if state.messages.count < 100 { state.messages.append(file.lastPathComponent+": "+error.localizedDescription) }
            }
            if Date().timeIntervalSince(lastReport) >= 0.12 { progress(state);lastReport = Date() }
        }
        state.issues += enumerationMessages.count;state.messages += enumerationMessages
        state.finished = true
        state.current = state.cancelled ? "Cancelled — completed work kept" : "Scan complete"
        if !FileManager.default.fileExists(atPath:root.path) { state.issues += 1;state.messages.append("The source became unavailable during the scan") }
        let message = state.cancelled ? "Cancelled; completed work kept" : state.issues > 0 ? "\(state.issues) file/read issues; see scan details" : ""
        try db.finishSourceScan(source.id,path:root.path,message:message)
        progress(state);return state
    }
}

struct WaveformJobProgress: Sendable {
    var total: Int
    var processed = 0
    var generated = 0
    var cached = 0
    var skipped = 0
    var issues = 0
    var current = "Preparing waveforms…"
    var messages = [String]()
    var cancelled = false
    var finished = false
}
/// Prepares existing library media without importing, playing or modifying track metadata.
enum WaveformBatch {
    static func run(songs: [Song],locations: [MediaLocation],cache: URL,force: Bool = false,cancelled: () -> Bool = { false },progress: (WaveformJobProgress) -> Void = { _ in }) -> WaveformJobProgress {
        var accessed = [URL]()
        for location in locations {
            var url = URL(fileURLWithPath:location.path)
            if let bookmark = location.bookmark { var stale = false;if let resolved = try? URL(resolvingBookmarkData:bookmark,options:[.withSecurityScope,.withoutUI],relativeTo:nil,bookmarkDataIsStale:&stale) { url = resolved } }
            if url.startAccessingSecurityScopedResource() { accessed.append(url) }
        }
        defer { for url in accessed { url.stopAccessingSecurityScopedResource() } }
        var ids = Set<Int64>(),analysedPaths = Set<String>()
        let tracks = songs.filter{ids.insert($0.id).inserted}
        var state = WaveformJobProgress(total:tracks.count),lastReport = Date.distantPast
        for song in tracks {
            if cancelled() { state.cancelled = true;break }
            state.current = song.title
            if song.audio.hasPrefix("showscreen:") { state.skipped += 1;state.processed += 1;continue }
            let url = URL(fileURLWithPath:song.audio),path = url.standardizedFileURL.path
            let scoped = url.startAccessingSecurityScopedResource()
            do {
                if (!force || analysedPaths.contains(path)),(try? WaveformCache.load(audio:url,directory:cache)) != nil { state.cached += 1 }
                else {
                    let value = try AudioWaveform.analyse(url:url,cancelled:cancelled)
                    guard value.levels.count == 4096,value.bands.count == 4096 else { throw LibraryError.message("No audio samples available for waveform analysis") }
                    if cancelled() { throw CancellationError() }
                    try WaveformCache.save(value,audio:url,directory:cache);state.generated += 1
                }
                analysedPaths.insert(path)
            } catch is CancellationError {
                if scoped { url.stopAccessingSecurityScopedResource() };state.cancelled = true;break
            } catch {
                state.issues += 1
                if state.messages.count < 100 { state.messages.append(song.title+": "+error.localizedDescription) }
            }
            if scoped { url.stopAccessingSecurityScopedResource() }
            state.processed += 1
            if Date().timeIntervalSince(lastReport) >= 0.12 { progress(state);lastReport = Date() }
        }
        state.finished = true;state.current = state.cancelled ? "Cancelled · completed waveforms kept" : (state.issues > 0 ? "Waveform analysis finished with issues" : "Waveforms ready")
        progress(state);return state
    }
}