val kmplitertVersion = "0.2.0" // Replace with latest

kotlin {
    sourceSets {
        commonMain.dependencies {
            // The core ML runtime engine
            implementation("io.github.leitingzi:kmplitert-core:$kmplitertVersion")
            
            // Optional: Image/Audio 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 {
    listOf(
        iosArm64(),
        iosSimulatorArm64()
    ).forEach { iosTarget ->
        iosTarget.binaries.framework {
            baseName = "AppCore"
            isStatic = false // MUST BE FALSE to allow dynamic linking with LiteRT

            // Resolve path to the LiteRT binaries based on the target architecture
            val targetDir = when (iosTarget.konanTarget) {
                KonanTarget.IOS_ARM64 -> "ios/arm64"
                KonanTarget.IOS_SIMULATOR_ARM64 -> "ios/sim-arm64"
                else -> null
            } ?: return@framework

            val libPath = "$projectDir/src/nativeInterop/lib/litert/$targetDir"
            
            // Link against the LiteRT dynamic library
            linkerOpts("-L$libPath", "-lLiteRt", "-lc++")

            // Configure rpath for the system to find the dylib inside the framework
            linkerOpts("-Wl,-rpath,@executable_path/Frameworks")
            linkerOpts("-Wl,-rpath,@loader_path/Frameworks")

            // Copy the dylibs into the framework output directory using a dedicated Copy task
            val bundleTaskName = "bundleLiteRtTo${iosTarget.name.replaceFirstChar { it.uppercase() }}${name.replaceFirstChar { it.uppercase() }}"
            val bundleTask = tasks.register<Copy>(bundleTaskName) {
                description = "Package LiteRT dynamic libraries into the framework."
                from(libPath)
                include("*.dylib")
                into(linkTaskProvider.flatMap {
                    it.destinationDirectory.map { dir ->
                        dir.asFile.resolve("${baseName}.framework/Frameworks")
                    }
                })
            }

            // Ensure Xcode assembly tasks depend on our bundling task
            tasks.matching {
                (it.name.startsWith("assemble") || it.name.startsWith("embedAndSign")) && 
                it.name.contains(iosTarget.name, ignoreCase = true) &&
                it.name.contains("AppleFrameworkForXcode")
            }.configureEach {
                dependsOn(bundleTask)
            }
        }
    }
}

import io.github.kmplitert.core.*
import io.github.kmplitert.tool.*
import io.github.kmplitert.tool.image.LiteRtImage
import io.github.kmplitert.tool.expand.*

// I: Input, T: Transformed, O: Output
class MyClassifier : LiteRTHandler<LiteRtImage, LiteRtImage, List<LiteRTExt.Category>>() {
    private val labels = listOf("Cat", "Dog", "Bird")

    override suspend fun init() {
        // Setup compiler with model path and accelerator
        setupCompiler("path/to/model.tflite", LiteRTAccelerator.CPU)
    }

    override suspend fun transform(input: LiteRtImage): LiteRtImage {
        // 1. Resize and transform image format
        return input.resize(224, 224).toRgb()
    }

    override suspend fun feed(data: LiteRtImage, inputBuffers: List<TFBuffer>) {
        // 2. Normalize and write directly to native buffer
        data.writeFloatBuffer(inputBuffers[0], mean = 127.5f, std = 127.5f)
    }

    override suspend fun postprocess(outputBuffers: List<TFBuffer>): List<LiteRTExt.Category> {
        // 3. Read output and convert to high-level Category models
        val scores = outputBuffers[0].readFloat()
        return scores.toCategories(labels, threshold = 0.5f)
    }
    
    suspend fun classify(image: LiteRtImage) = runTask(image)
}

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

suspend fun simpleInference(modelPath: String) {
    // 1. Initialize Compiler with DSL-like 'use' block for auto-cleanup
    LiteRTCompiler(modelPath, LiteRTAccelerator.CPU).use { compiler ->
        compiler.init()

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

        // 3. Write input data using extensions
        floatArrayOf(1.0f, 2.0f, 3.0f).writeTo(inputs[0])

        // 4. Run inference
        compiler.run(inputs, outputs)

        // 5. Read result directly
        val result = outputs[0].readFloat()
        println("Inference result: ${result.joinToString()}")
    }
}

val processedImage = LiteRtImage.fromBytes(bytes)
    .resize(320, 320)
    .rotate(90f) // Degrees as Float
    .flip(horizontal = true, vertical = false)
    .toRgb()

// Efficiently write to buffer
processedImage.writeFloatBuffer(buffer, mean = 0f, std = 255f)

import io.github.kmplitert.tool.audio.*

// Decode WAV file
val audio = WavDecoder.decode(wavBytes)
val pcmData = audio.data // FloatArray

// Basic signal processing
val normalized = SignalProcessing.normalize(pcmData)

val handler = MyClassifier().apply {
    // 1. Result Caching: Skip inference if input fingerprint matches last result
    addCache(onCacheHit = { input, result -> println("Cache hit!") })

    // 2. Logging: Measure and log execution time for each phase
    addLogging(tag = "MyModel", phase = LiteRTPhase.TASK)
}

class MyCustomInterceptor : LiteRTInterceptor<LiteRtImage, LiteRtImage, List<Category>> {
    override suspend fun intercept(
        chain: LiteRTInterceptor.Chain<LiteRtImage, LiteRtImage, List<Category>>
    ): List<Category> {
        // 1. Pre-processing logic (e.g., validate input)
        if (chain.input.width < 100) throw Exception("Image too small")

        // 2. Proceed to the next interceptor or the actual task
        val startTime = currentTimeMillis()
        val results = chain.proceed()
        val duration = currentTimeMillis() - startTime

        // 3. Post-processing logic (e.g., filter results)
        println("Task took ${duration}ms")
        return results.filter { it.score > 0.5f }
    }
}

// Add to your handler
handler.addInterceptor(MyCustomInterceptor(), phase = LiteRTPhase.TASK)