import Foundation

/// Log levels for STT logging
enum STTLogLevel: Int, Comparable {
    case debug = 0
    case info = 1
    case warn = 2
    case error = 3

    static func < (lhs: STTLogLevel, rhs: STTLogLevel) -> Bool {
        return lhs.rawValue < rhs.rawValue
    }
}

/// Structured logging utility for STT module.
/// Mirrors Android's STTLogger.kt for consistency.
final class STTLogger {
    static var minLevel: STTLogLevel = .info

    static func d(_ tag: String, _ message: String) {
        log(.debug, tag, message)
    }

    static func i(_ tag: String, _ message: String) {
        log(.info, tag, message)
    }

    static func w(_ tag: String, _ message: String) {
        log(.warn, tag, message)
    }

    static func e(_ tag: String, _ message: String, error: Error? = nil) {
        if let error = error {
            log(.error, tag, "\(message): \(error.localizedDescription)")
        } else {
            log(.error, tag, message)
        }
    }

    private static func log(_ level: STTLogLevel, _ tag: String, _ message: String) {
        guard level >= minLevel else { return }

        let levelPrefix: String
        switch level {
        case .debug:
            levelPrefix = "D"
        case .info:
            levelPrefix = "I"
        case .warn:
            levelPrefix = "W"
        case .error:
            levelPrefix = "E"
        }

        NSLog("[STT.\(tag)] \(levelPrefix): \(message)")
    }
}

/// Module-specific loggers for convenience
enum STTLoggers {
    static func diarization(_ message: String, level: STTLogLevel = .info) {
        switch level {
        case .debug:
            STTLogger.d("Diarization", message)
        case .info:
            STTLogger.i("Diarization", message)
        case .warn:
            STTLogger.w("Diarization", message)
        case .error:
            STTLogger.e("Diarization", message)
        }
    }

    static func vad(_ message: String, level: STTLogLevel = .info) {
        switch level {
        case .debug:
            STTLogger.d("VAD", message)
        case .info:
            STTLogger.i("VAD", message)
        case .warn:
            STTLogger.w("VAD", message)
        case .error:
            STTLogger.e("VAD", message)
        }
    }

    static func recognition(_ message: String, level: STTLogLevel = .info) {
        switch level {
        case .debug:
            STTLogger.d("Recognition", message)
        case .info:
            STTLogger.i("Recognition", message)
        case .warn:
            STTLogger.w("Recognition", message)
        case .error:
            STTLogger.e("Recognition", message)
        }
    }

    static func audioCapture(_ message: String, level: STTLogLevel = .info) {
        switch level {
        case .debug:
            STTLogger.d("AudioCapture", message)
        case .info:
            STTLogger.i("AudioCapture", message)
        case .warn:
            STTLogger.w("AudioCapture", message)
        case .error:
            STTLogger.e("AudioCapture", message)
        }
    }

    static func denoiser(_ message: String, level: STTLogLevel = .info) {
        switch level {
        case .debug:
            STTLogger.d("Denoiser", message)
        case .info:
            STTLogger.i("Denoiser", message)
        case .warn:
            STTLogger.w("Denoiser", message)
        case .error:
            STTLogger.e("Denoiser", message)
        }
    }
}