package com.sherpaonnxofflinestt.utils

import android.util.Log

/**
 * Structured logging utility for STT module.
 * Provides consistent logging format with configurable log levels.
 *
 * Features:
 * - Configurable minimum log level
 * - Structured log format with timestamps
 * - Support for throwable logging
 * - Module-specific tags for easy filtering
 */
object STTLogger {

    /**
     * Log levels in increasing severity order
     */
    enum class Level(val priority: Int) {
        DEBUG(Log.DEBUG),
        INFO(Log.INFO),
        WARN(Log.WARN),
        ERROR(Log.ERROR)
    }

    /**
     * Minimum log level to output. Messages below this level are ignored.
     * Default is INFO to reduce noise in production.
     */
    @Volatile
    var minLevel: Level = Level.INFO

    /**
     * Enable/disable logging globally.
     */
    @Volatile
    var enabled: Boolean = true

    /**
     * Tag prefix for all STT logs
     */
    private const val TAG_PREFIX = "STT."

    // =====================
    // Convenience methods
    // =====================

    /**
     * Log debug message
     */
    fun d(tag: String, msg: String) {
        log(Level.DEBUG, tag, msg)
    }

    /**
     * Log debug message with format arguments
     */
    fun d(tag: String, format: String, vararg args: Any?) {
        log(Level.DEBUG, tag, format.format(*args))
    }

    /**
     * Log info message
     */
    fun i(tag: String, msg: String) {
        log(Level.INFO, tag, msg)
    }

    /**
     * Log info message with format arguments
     */
    fun i(tag: String, format: String, vararg args: Any?) {
        log(Level.INFO, tag, format.format(*args))
    }

    /**
     * Log warning message
     */
    fun w(tag: String, msg: String) {
        log(Level.WARN, tag, msg)
    }

    /**
     * Log warning message with format arguments
     */
    fun w(tag: String, format: String, vararg args: Any?) {
        log(Level.WARN, tag, format.format(*args))
    }

    /**
     * Log warning with throwable
     */
    fun w(tag: String, msg: String, t: Throwable) {
        log(Level.WARN, tag, msg, t)
    }

    /**
     * Log error message
     */
    fun e(tag: String, msg: String) {
        log(Level.ERROR, tag, msg)
    }

    /**
     * Log error message with format arguments
     */
    fun e(tag: String, format: String, vararg args: Any?) {
        log(Level.ERROR, tag, format.format(*args))
    }

    /**
     * Log error with throwable
     */
    fun e(tag: String, msg: String, t: Throwable?) {
        log(Level.ERROR, tag, msg, t)
    }

    // =====================
    // Core logging methods
    // =====================

    /**
     * Core log method with optional throwable
     */
    fun log(level: Level, tag: String, msg: String, t: Throwable? = null) {
        if (!enabled) return
        if (level.priority < minLevel.priority) return

        val fullTag = "$TAG_PREFIX$tag"

        when (level) {
            Level.DEBUG -> {
                if (t != null) Log.d(fullTag, msg, t) else Log.d(fullTag, msg)
            }
            Level.INFO -> {
                if (t != null) Log.i(fullTag, msg, t) else Log.i(fullTag, msg)
            }
            Level.WARN -> {
                if (t != null) Log.w(fullTag, msg, t) else Log.w(fullTag, msg)
            }
            Level.ERROR -> {
                if (t != null) Log.e(fullTag, msg, t) else Log.e(fullTag, msg)
            }
        }
    }

    // =====================
    // Module-specific loggers
    // =====================

    /**
     * Logger for DiarizationManager
     */
    object Diarization {
        private const val TAG = "Diarization"

        fun d(msg: String) = STTLogger.d(TAG, msg)
        fun i(msg: String) = STTLogger.i(TAG, msg)
        fun w(msg: String) = STTLogger.w(TAG, msg)
        fun w(msg: String, t: Throwable) = STTLogger.w(TAG, msg, t)
        fun e(msg: String) = STTLogger.e(TAG, msg)
        fun e(msg: String, t: Throwable?) = STTLogger.e(TAG, msg, t)
    }

    /**
     * Logger for VADManager
     */
    object VAD {
        private const val TAG = "VAD"

        fun d(msg: String) = STTLogger.d(TAG, msg)
        fun i(msg: String) = STTLogger.i(TAG, msg)
        fun w(msg: String) = STTLogger.w(TAG, msg)
        fun e(msg: String) = STTLogger.e(TAG, msg)
        fun e(msg: String, t: Throwable?) = STTLogger.e(TAG, msg, t)
    }

    /**
     * Logger for STTRecognitionManager
     */
    object Recognition {
        private const val TAG = "Recognition"

        fun d(msg: String) = STTLogger.d(TAG, msg)
        fun i(msg: String) = STTLogger.i(TAG, msg)
        fun w(msg: String) = STTLogger.w(TAG, msg)
        fun e(msg: String) = STTLogger.e(TAG, msg)
        fun e(msg: String, t: Throwable?) = STTLogger.e(TAG, msg, t)
    }

    /**
     * Logger for DenoiserManager
     */
    object Denoiser {
        private const val TAG = "Denoiser"

        fun d(msg: String) = STTLogger.d(TAG, msg)
        fun i(msg: String) = STTLogger.i(TAG, msg)
        fun w(msg: String) = STTLogger.w(TAG, msg)
        fun e(msg: String) = STTLogger.e(TAG, msg)
        fun e(msg: String, t: Throwable?) = STTLogger.e(TAG, msg, t)
    }

    /**
     * Logger for AudioRecordingManager
     */
    object Audio {
        private const val TAG = "Audio"

        fun d(msg: String) = STTLogger.d(TAG, msg)
        fun i(msg: String) = STTLogger.i(TAG, msg)
        fun w(msg: String) = STTLogger.w(TAG, msg)
        fun e(msg: String) = STTLogger.e(TAG, msg)
        fun e(msg: String, t: Throwable?) = STTLogger.e(TAG, msg, t)
    }

    /**
     * Logger for EventEmissionManager
     */
    object Events {
        private const val TAG = "Events"

        fun d(msg: String) = STTLogger.d(TAG, msg)
        fun i(msg: String) = STTLogger.i(TAG, msg)
        fun w(msg: String) = STTLogger.w(TAG, msg)
        fun e(msg: String) = STTLogger.e(TAG, msg)
    }

    /**
     * Logger for StreamingStateManager
     */
    object Streaming {
        private const val TAG = "Streaming"

        fun d(msg: String) = STTLogger.d(TAG, msg)
        fun i(msg: String) = STTLogger.i(TAG, msg)
        fun w(msg: String) = STTLogger.w(TAG, msg)
    }

    /**
     * Logger for PyannoteSegmentationManager
     */
    object Pyannote {
        private const val TAG = "Pyannote"

        fun d(msg: String) = STTLogger.d(TAG, msg)
        fun i(msg: String) = STTLogger.i(TAG, msg)
        fun w(msg: String) = STTLogger.w(TAG, msg)
        fun e(msg: String) = STTLogger.e(TAG, msg)
        fun e(msg: String, t: Throwable?) = STTLogger.e(TAG, msg, t)
    }

    // =====================
    // Configuration helpers
    // =====================

    /**
     * Set log level from string (e.g., from JS config).
     * Valid values: "debug", "info", "warn", "error"
     */
    fun setLevelFromString(level: String) {
        minLevel = when (level.lowercase()) {
            "debug" -> Level.DEBUG
            "info" -> Level.INFO
            "warn", "warning" -> Level.WARN
            "error" -> Level.ERROR
            else -> {
                Log.w("$TAG_PREFIX.Config", "Unknown log level: $level, defaulting to INFO")
                Level.INFO
            }
        }
    }

    /**
     * Enable debug logging (sets minLevel to DEBUG)
     */
    fun enableDebug() {
        minLevel = Level.DEBUG
    }

    /**
     * Set production mode (sets minLevel to WARN)
     */
    fun enableProductionMode() {
        minLevel = Level.WARN
    }
}