repositories {
    mavenCentral()
}

dependencies {
    implementation("io.github.cardosofgui:frigg:1.1.0")
}

import android.app.Application
import com.br.frigg.FriggConverter

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        FriggConverter.initialize(this)
    }
}

import com.br.frigg.FriggConverter

suspend fun convertAudio() {
    val converter = FriggConverter()
    val wavPath = "/path/to/audio.wav"
    
    val result = converter.convertWavToMp3(wavPath, bitrate = 128)
    
    result.onSuccess { mp3Path ->
        println("Conversão bem-sucedida! MP3 salvo em: $mp3Path")
    }.onFailure { exception ->
        println("Erro na conversão: ${exception.message}")
        exception.printStackTrace()
    }
}

import com.br.frigg.FriggConverter
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch

fun convertAudioFile(wavPath: String) {
    val converter = FriggConverter()
    
    CoroutineScope(Dispatchers.IO).launch {
        val result = converter.convertWavToMp3(
            wavPath = wavPath,
            bitrate = 192 // Qualidade maior
        )
        
        result.onSuccess { mp3Path ->
            // Arquivo MP3 criado com sucesso
            // Faça algo com o arquivo MP3
        }.onFailure { exception ->
            // Trate o erro
            when (exception) {
                is com.br.frigg.FileNotFoundException -> {
                    // Arquivo não encontrado
                }
                is com.br.frigg.InvalidFileException -> {
                    // Arquivo inválido ou corrompido
                }
                is com.br.frigg.StorageException -> {
                    // Espaço insuficiente em disco
                }
                else -> {
                    // Outros erros
                }
            }
        }
    }
}

import com.br.frigg.FriggConverter

suspend fun convertWithFallback(wavPath: String): String {
    val converter = FriggConverter()
    
    return converter.convertWavToMp3(wavPath)
        .getOrElse { exception ->
            // Tratamento de erro personalizado
            throw exception
        }
}

import com.br.frigg.FriggConverter

suspend fun convertWithFold(wavPath: String): String {
    val converter = FriggConverter()
    
    return converter.convertWavToMp3(wavPath).fold(
        onSuccess = { mp3Path -> mp3Path },
        onFailure = { exception -> 
            throw exception
        }
    )
}

FriggException (classe base)
├── StorageException
├── WritePermissionException
├── InvalidFileException
├── FileNotFoundException
├── ReadPermissionException
├── DirectoryCreationException
├── NativeLibraryException
├── ConversionException
├── EmptyFileException
└── UnknownFriggException

import com.br.frigg.*
import com.br.frigg.FriggConverter

suspend fun convertWithDetailedErrorHandling(wavPath: String) {
    val converter = FriggConverter()
    
    converter.convertWavToMp3(wavPath).onFailure { exception ->
        when (exception) {
            is FileNotFoundException -> {
                println("Arquivo não encontrado: ${exception.filePath}")
            }
            is ReadPermissionException -> {
                println("Sem permissão para ler: ${exception.filePath}")
            }
            is InvalidFileException -> {
                println("Arquivo inválido: ${exception.filePath}")
                println("Motivo: ${exception.reason}")
            }
            is StorageException -> {
                println("Espaço insuficiente")
                println("Disponível: ${exception.availableSpace} bytes")
                println("Necessário: ${exception.requiredSpace} bytes")
            }
            is WritePermissionException -> {
                println("Sem permissão para escrever em: ${exception.path}")
            }
            is DirectoryCreationException -> {
                println("Erro ao criar diretório: ${exception.directoryPath}")
            }
            is NativeLibraryException -> {
                println("Erro ao carregar biblioteca nativa: ${exception.libraryName}")
            }
            is ConversionException -> {
                println("Erro na conversão")
                println("WAV: ${exception.wavPath}")
                println("MP3: ${exception.mp3Path}")
            }
            is EmptyFileException -> {
                println("Arquivo MP3 vazio: ${exception.filePath}")
            }
            is UnknownFriggException -> {
                println("Erro desconhecido: ${exception.message}")
                exception.cause?.printStackTrace()
            }
            else -> {
                println("Erro inesperado: ${exception.message}")
            }
        }
    }
}

open class FriggException(
    message: String,
    cause: Throwable? = null
) : Exception(message, cause)

open class StorageException(
    message: String,
    val availableSpace: Long,
    val requiredSpace: Long,
    cause: Throwable? = null
) : FriggException(message, cause)

open class WritePermissionException(
    message: String,
    val path: String,
    cause: Throwable? = null
) : FriggException(message, cause)

open class InvalidFileException(
    message: String,
    val filePath: String,
    val reason: String,
    cause: Throwable? = null
) : FriggException(message, cause)

open class FileNotFoundException(
    message: String,
    val filePath: String,
    cause: Throwable? = null
) : FriggException(message, cause)

open class ReadPermissionException(
    message: String,
    val filePath: String,
    cause: Throwable? = null
) : FriggException(message, cause)

open class DirectoryCreationException(
    message: String,
    val directoryPath: String,
    cause: Throwable? = null
) : FriggException(message, cause)

open class NativeLibraryException(
    message: String,
    val libraryName: String? = null,
    cause: Throwable? = null
) : FriggException(message, cause)

open class ConversionException(
    message: String,
    val wavPath: String,
    val mp3Path: String,
    cause: Throwable? = null
) : FriggException(message, cause)

open class EmptyFileException(
    message: String,
    val filePath: String,
    cause: Throwable? = null
) : FriggException(message, cause)

open class UnknownFriggException(
    message: String,
    override val cause: Throwable
) : FriggException(message, cause)