val kmplitertVersion = "0.1.4" // Replace with latest

kotlin {
    sourceSets {
        commonMain.dependencies {
            // The core ML runtime engine
            implementation("io.github.leitingzi:kmplitert-core:$kmplitertVersion")
            
            // Optional: Image processing & File utilities
            implementation("io.github.leitingzi:kmplitert-tool:$kmplitertVersion")
        }
    }
}

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        // Required for LiteRTFileUtils to load models from assets
        LiteRTFileUtils.init(this)
    }
}

kotlin {
    val iosTargets = listOf(iosArm64(), iosSimulatorArm64())
    
    iosTargets.forEach { target ->
        target.binaries.framework {
            baseName = "SharedLib"
            isStatic = false // MUST BE FALSE
            
            // Link against the LiteRT dynamic library
            linkerOpts("-lLiteRt", "-lc++")
            
            // Configure rpath for the system to find the dylib inside the framework
            linkerOpts(
                "-Wl,-rpath,@executable_path/Frameworks",
                "-Wl,-rpath,@loader_path/Frameworks",
                "-Wl,-rpath,@loader_path/../../Frameworks"
            )
        }
    }
}

tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinNativeLink>().configureEach {
    val target = binary.target.konanTarget
    if (target.isApple) {
        doLast {
            val destination = destinationDirectory.get().asFile
            val frameworkDir = File(destination, "${binary.baseName}.framework")
            val frameworksFolder = File(frameworkDir, "Frameworks").apply { mkdirs() }
            
            // Path to where you store the prebuilt LiteRT binaries
            val libPath = File(project.rootDir, "native-libs/ios/${target.name}")
            
            copy {
                from(libPath)
                include("*.dylib")
                into(frameworksFolder)
            }
        }
    }
}

import io.github.kmplitert.core.*
import io.github.kmplitert.tool.LiteRTFileUtils

suspend fun simpleInference(modelBytes: ByteArray) {
    // 1. Prepare model file (cross-platform helper)
    val filePath = LiteRTFileUtils.createFileFromByteArray(modelBytes, "temp_model.tflite")
    
    // 2. Initialize Compiler
    val compiler = LiteRTCompiler(filePath, LiteRTAccelerator.CPU)
    compiler.init()

    // 3. Prepare I/O
    val inputs = compiler.getInputBuffers()
    val outputs = compiler.getOutputBuffers()

    // 4. Input 100°C
    inputs[0].writeFloat(floatArrayOf(100f))

    // 5. Run
    compiler.run(inputs, outputs)

    // 6. Output result
    val result = outputs[0].readFloat()
    println("Result: ${result[0]}°F")

    // 7. Cleanup
    compiler.close()
}

import io.github.kmplitert.core.*
import io.github.kmplitert.tool.*

suspend fun classifyImage(imageBytes: ByteArray, modelBytes: ByteArray) {
    val filePath = LiteRTFileUtils.createFileFromByteArray(modelBytes, "mobilenet.tflite")
    val compiler = LiteRTCompiler(filePath, LiteRTAccelerator.GPU)
    compiler.init()

    // Image Preprocessing Pipeline
    val processedData = LiteRtImage.fromBytes(imageBytes)
        .resize(224, 224) // Resize to model requirement
        .toRgb()          // Ensure RGB format
        .toInt8Array()    // Convert to Quantized Int8

    val inputs = compiler.getInputBuffers()
    val outputs = compiler.getOutputBuffers()

    // Write to native buffer
    inputs[0].writeInt8(processedData)

    // Inference
    compiler.run(inputs, outputs)

    // Post-processing
    val scores = outputs[0].readInt8()
    val topIndex = scores.indices.maxBy { scores[it] }
    
    println("Top Class Index: $topIndex")
    compiler.close()
}

val buffer = LiteRtImage.fromBytes(bytes)
    .resize(width, height)
    .toRgb() // or toGrayscale()
    .normalize(mean = 127.5f, std = 127.5f) // For float models
    .toFloatArray() // or writeInt8Buffer(tfBuffer)