import Foundation
import OSLog

@available(iOS 15.0, macOS 10.15, tvOS 15.0, watchOS 8.0, *)
class OSLogStoreSynchronizer {
    let osLogStore: OSLogStore
    let pulseStore: LoggerStore

    var subsystemAllowList: [String] = [Bundle.main.bundleIdentifier].compactMap({ $0 })
    var mapLogLevel: (OSLogEntryLog.Level) -> LoggerStore.Level
    var onRead: ((Error?) async -> Void)? = nil

    var timer: DispatchSourceTimer?

    var lastLogStoreError: Error?

    var predicate: NSPredicate?
    var lastPosition: OSLogPosition?

    let queue = DispatchQueue(label: "com.github.kean.pulse.OSLogStoreSynchronizer")

    init(
        pulseStore: LoggerStore,
        subsystemAllowList: [String] = [Bundle.main.bundleIdentifier].compactMap({ $0 }),
        mapLogLevel: @escaping (OSLogEntryLog.Level) -> LoggerStore.Level = defaultOSLogLevelMapping,
        onRead: ((Error?) async -> Void)? = nil
    ) throws {
        self.osLogStore = try OSLogStore(scope: .currentProcessIdentifier)
        self.pulseStore = pulseStore
        self.mapLogLevel = mapLogLevel
        self.subsystemAllowList = subsystemAllowList
        self.onRead = onRead
    }

    deinit {
        timer?.cancel()
    }

    func readOSLogEntries(into pulseStore: LoggerStore) throws {
        var lastOSLogEntry: OSLogEntryLog?
        let entries = try osLogStore.getEntries(with: [], at: lastPosition, matching: predicate)
        for entry in entries {
            if let payload = entry as? OSLogEntryWithPayload,
               !subsystemAllowList.contains(payload.subsystem) && !subsystemAllowList.isEmpty {
                continue
            }
            switch entry {
            case let entry as OSLogEntryLog:
                pulseStore.storeMessage(
                    createdAt: entry.date,
                    label: entry.category,
                    level: mapLogLevel(entry.level),
                    message: entry.composedMessage,
                    metadata: ["thread_id": .stringConvertible(entry.threadIdentifier)],
                    file: "<unknown>",
                    function: "<unknown>",
                    line: 0
                )
                lastOSLogEntry = entry

            default:
                continue
            }
        }
        if let lastOSLogEntry {
            /// NOTE: lastPosition doesn't seem to filter the entries retrieved, we provide it anyway, but rely upon `predicate`
            self.predicate = NSPredicate(format: "date > %@", lastOSLogEntry.date as NSDate)
            self.lastPosition = osLogStore.position(date: lastOSLogEntry.date)
        }
        print("Did read")
    }

    func startSyncing(every interval: TimeInterval = 30) {
        let timer = DispatchSource.makeTimerSource(queue: queue)
        self.timer = timer
        timer.schedule(wallDeadline: .now(), repeating: interval)
        timer.setEventHandler { [weak self] in
            guard let self else { return }
            do {
                try readOSLogEntries(into: pulseStore)
                if let onRead {
                    Task {
                        await onRead(nil)
                    }
                }
            } catch {
                lastLogStoreError = error
                if let onRead {
                    Task {
                        await onRead(error)
                    }
                }
            }
        }
        timer.resume()
    }

    func stop() {
        timer?.cancel()
    }

    static func defaultOSLogLevelMapping(_ level: OSLogEntryLog.Level) -> LoggerStore.Level {
        switch level {
        case .undefined: return .trace
        case .debug: return .debug
        case .info: return .info
        case .notice: return .notice
        case .error: return .error
        case .fault: return .critical
        @unknown default: return .info
        }
    }
}