// build.gradle.kts (shared module)
kotlin {
    sourceSets {
        commonMain.dependencies {
            implementation("co.crackn:kompressor:0.1.0")
        }
    }
}

val kompressor = createKompressor()

val result = kompressor.image.compress(
    inputPath  = "/path/to/photo.jpg",
    outputPath = "/path/to/photo_compressed.jpg",
)

result.onSuccess { println("Compressed: ${it.compressionRatio} ratio in ${it.durationMs}ms") }
    .onFailure { println("Error: ${it.message}") }

val result = kompressor.video.compress(
    inputPath  = "/path/to/video.mp4",
    outputPath = "/path/to/out.mp4",
    onProgress = { fraction -> updateProgressBar(fraction) },
)

result.onSuccess { println("Done — ratio ${it.compressionRatio}") }
    .onFailure { println("Error: ${it.message}") }

val result = kompressor.audio.compress(
    inputPath  = "/path/to/recording.wav",
    outputPath = "/path/to/recording.m4a",
)

result.onSuccess { println("${it.outputSize / 1000} KB") }
    .onFailure { println("Error: ${it.message}") }

// 1. Read the source's track metadata (codec, resolution, bit depth, HDR, etc.)
val info: SourceMediaInfo = kompressor.probe(inputPath).getOrThrow()

// 2. Ask the device whether it can actually compress this (required decoder
//    + required encoder + resolution / fps / bit depth / HDR caps).
when (val verdict = kompressor.canCompress(info)) {
    Supportability.Supported ->
        kompressor.video.compress(inputPath, outputPath)

    is Supportability.Unsupported ->
        showError("Can't compress: ${verdict.reasons.joinToString()}")

    is Supportability.Unknown ->
        // Probe couldn't verify something (e.g. bit depth). Warn and
        // optionally let the user attempt compression anyway.
        showWarning(verdict.reasons)
}

result.onFailure { err ->
    when (err) {
        is AudioCompressionError.UnsupportedSourceFormat ->
            showConvertFirstBanner(err.details)
        is AudioCompressionError.UnsupportedConfiguration ->
            fallbackToMono()
        is AudioCompressionError.IoFailed ->
            showStorageError(err.details)
        is AudioCompressionError.DecodingFailed,
        is AudioCompressionError.EncodingFailed,
        is AudioCompressionError.Unknown ->
            reportToCrashlytics(err)
        else -> reportToCrashlytics(err)
    }
}

val config = ImageCompressionConfig(
    format  = ImageFormat.JPEG,
    quality = 80,              // 0–100
    maxWidth  = 1920,
    maxHeight = 1080,
    keepAspectRatio = true,
)

val result = kompressor.image.compress(inputPath, outputPath, config)

kompressor.image.compress(inputPath, outputPath, ImagePresets.THUMBNAIL)
kompressor.image.compress(inputPath, outputPath, ImagePresets.WEB)
kompressor.image.compress(inputPath, outputPath, ImagePresets.HIGH_QUALITY)

val result = kompressor.audio.compress(
    inputPath  = inputPath,
    outputPath = outputPath,
    onProgress = { fraction -> println("Progress: ${(fraction * 100).toInt()}%") },
)

val job = scope.launch {
    kompressor.image.compress(inputPath, outputPath)
}

job.cancel() // compression is cancelled

val config = VideoCompressionConfig(
    codec            = VideoCodec.H264,
    maxResolution    = MaxResolution.HD_720,
    videoBitrate     = 1_200_000,
    audioBitrate     = 128_000,
    maxFrameRate     = 30,
    keyFrameInterval = 2,
)

val result = kompressor.video.compress(inputPath, outputPath, config)

val config = AudioCompressionConfig(
    bitrate    = 128_000,
    sampleRate = 44100,
    channels   = AudioChannels.STEREO,
)

val result = kompressor.audio.compress(inputPath, outputPath, config)

// commonMain
expect fun createKompressor(): Kompressor

interface Kompressor {
    val image: ImageCompressor
    val video: VideoCompressor
    val audio: AudioCompressor

    /** Read the source's track metadata (codec, resolution, HDR, bit depth, ...). */
    suspend fun probe(inputPath: String): Result<SourceMediaInfo>

    /** Advisory verdict: does the device have the decoders + encoders to handle [info]? */
    fun canCompress(info: SourceMediaInfo): Supportability
}

interface ImageCompressor {
    suspend fun compress(
        inputPath: String,
        outputPath: String,
        config: ImageCompressionConfig = ImageCompressionConfig(),
    ): Result<CompressionResult>
}

interface VideoCompressor {
    suspend fun compress(
        inputPath: String,
        outputPath: String,
        config: VideoCompressionConfig = VideoCompressionConfig(),
        onProgress: suspend (Float) -> Unit = {},
    ): Result<CompressionResult>
}

interface AudioCompressor {
    suspend fun compress(
        inputPath: String,
        outputPath: String,
        config: AudioCompressionConfig = AudioCompressionConfig(),
        onProgress: suspend (Float) -> Unit = {},
    ): Result<CompressionResult>
}

data class CompressionResult(
    val inputSize: Long,        // bytes
    val outputSize: Long,       // bytes
    val durationMs: Long,       // milliseconds
) {
    val compressionRatio: Float        // outputSize / inputSize (< 1.0 = smaller)
    val isSmallerThanOriginal: Boolean // outputSize < inputSize
}

sealed class Supportability {
    object Supported                                        : Supportability()
    data class Unsupported(val reasons: List<String>)       : Supportability()  // hard blocker
    data class Unknown(val reasons: List<String>)           : Supportability()  // probe couldn't verify
}

sealed class AudioCompressionError(
    message: String,
    cause: Throwable? = null,
) : Exception(message, cause) {
    class UnsupportedSourceFormat(val details: String, cause: Throwable? = null) :
        AudioCompressionError("Unsupported source format: $details", cause)
    class DecodingFailed(val details: String, cause: Throwable? = null) :
        AudioCompressionError("Decoding failed: $details", cause)
    class EncodingFailed(val details: String, cause: Throwable? = null) :
        AudioCompressionError("Encoding failed: $details", cause)
    class IoFailed(val details: String, cause: Throwable? = null) :
        AudioCompressionError("IO failed: $details", cause)
    class UnsupportedConfiguration(val details: String, cause: Throwable? = null) :
        AudioCompressionError("Unsupported configuration: $details", cause)
    class Unknown(val details: String, cause: Throwable? = null) :
        AudioCompressionError("Compression failed: $details", cause)
}
// VideoCompressionError mirrors this shape without UnsupportedConfiguration.