// For Kotlin Multiplatform:
plugins {
    kotlin("multiplatform")
}

kotlin {
    sourceSets {
        commonMain {
            dependencies {
                implementation("io.github.irgaly.kottage:kottage:1.11.0")
                // ...
            }
        }
    }
    // ...
}

// For Kotlin/JVM or Kotlin/Android without Kotlin Multiplatform:
plugins {
    id("com.android.application")
    kotlin("android")
    // kotlin("jvm") // for JVM Application
}

dependencies {
    // You can use as JVM library directly
    implementation("io.github.irgaly.kottage:kottage:1.11.0")
    // ...
}

import io.github.irgaly.kottage.platform.contextOf

// directory path string for SQLite file
// For example:
// * Android File Directory: context.getFilesDir().path
// * Android Cache Directory: context.getCacheDir().path
val databaseDirectory: String = ...
val kottageEnvironment: KottageEnvironment = KottageEnvironment(
    context = contextOf(context) // for Android, set a KottageContext with Android Context object
    //context = KottageContext() // for other platforms, set an empty KottageContext
)
// Initialize with Kottage database information.
val kottage: Kottage = Kottage(
    name = "kottage-store-name", // This will be database file name
    directoryPath = databaseDirectory,
    environment = kottageEnvironment,
    scope = scope, // This kottage instance will be automatically close on this CoroutineScope completion
    json = Json.Default // kotlinx.serialization's json object
)

import kotlin.time.Duration.Companion.days

// Open Kottage database as cache mode
val cache: KottageStorage = kottage.cache("timeline_item_cache") {
    // There are some options
    strategy = KottageFifoStrategy(maxEntryCount = 1000) // default strategy in cache mode
    //strategy = KottageFifoStrategy(maxCacheSize = 512 * 1024 * 1024) // FIFO strategy with cache sized based eviction (bytes)
    //strategy = KottageFifoStrategy(maxEntryCount = 1000, maxCacheSize = 512 * 1024 * 1024) // FIFO strategy with item count and cache sized based eviction (bytes)
    //strategy = KottageLruStrategy(maxEntryCount = 1000) // LRU cache strategy
    //strategy = KottageLruStrategy(maxCacheSize = 512 * 1024 * 1024) // LRU strategy with cache sized based eviction (bytes)
    //strategy = KottageLruStrategy(maxEntryCount = 1000, maxCacheSize = 512 * 1024 * 1024) // LRU strategy with item count and cache sized based eviction (bytes)
    defaultExpireTime = 30.days // cache item expiration time in kotlin.time.Duration
}

// Kottage's data accessing methods (get, put...) are suspending function
// These items will be expired and automatically deleted after 30 days (defaultExpireTime) elapsed
cache.put("item1", "item1 value")
cache.put("item2", 42)
cache.put("item3", true)

val value1: String = cache.get<String>("item1")
val value2: Int = cache.get<Int>("item2")
val value3: Boolean = cache.get<Boolean>("item3")
cache.exists("item4") // => false
cache.getOrNull<String>("item4") // => null

// 30 days later... these items are expired
cache.get<String>("item1") // throws NoSuchElementException
cache.getOrNull<String>("item1") // => null
cache.exists("item1") // => false

// Open Kottage database as storage mode
val storage: KottageStorage = kottage.storage("app_configs")

// Kottage's data accessing methods (get, put...) are suspending function
// These items has no expiration
storage.put("item1", "item1 value")
storage.put("item2", 42)
storage.put("item3", true)

val value1: String = storage.get<String>("item1")
val value2: Int = storage.get<Int>("item2")
val value3: Boolean = storage.get<Boolean>("item3")
storage.exists("item4") // => false
storage.getOrNull<String>("item4") // => null

val storage: KottageStorage = kottage.storage("app_configs")

val myConfig: String by storage.property { "default value" }
val myConfigNullable: String? by storage.nullableProperty()

myConfig.write("value")
val config: String = myConfig.read()

class AppConfiguration(kottage: Kottage) {
    private val storage: KottageStorage = kottage.storage("app_configs")
    val myConfig: String by storage.property { "default value" }
    val myConfigNullable: String? by storage.nullableProperty()
}

val configuration: AppConfiguration = AppConfiguration(kottage)
configuration.myConfig.write("value")
val config: String = configuration.myConfig.read()

import io.github.irgaly.kottage.kottageListValue

val cache: KottageStorage = kottage.cache("timeline_item_cache")
val list: KottageList = cache.list("timeline_list")

// KottageList is an interface of KottageStorage that supports List operations.

// Add List Items
list.add("item_id_1", TimelineItem("item_id_1", ...))
list.addAll(
    listOf(
        kottageListValue("item_id_2", TimelineItem("item_id_2", ...)),
        kottageListValue("item_id_3", TimelineItem("item_id_3", ...)),
        kottageListValue("item_id_4", TimelineItem("item_id_4", ...)),
        kottageListValue("item_id_5", TimelineItem("item_id_5", ...))
    )
)

// The items are stored in "timeline_item_cache" KottageStorage
cache.exists("item_id_1") // => true

// You can update items directly
cache.put("item_id_1", TimelineItem("item_id_1", otherValue = ...))

// Get as Page
val page0: KottageListPage = list.getPageFrom(positionId = null, pageSize = 2)
val page1: KottageListPage = list.getPageFrom(positionId = (page0.nextPositionId), pageSize = 2)
val page2: KottageListPage = list.getPageFrom(positionId = (page1.nextPositionId), pageSize = 2)

page0.items // => List<KottageListEntry>
page0.items.map { it.value<TimelineItem>() }
  // => [TimelineItem("item_id_1", otherValue = ...), TimelineItem("item_id_2", ...)]
page1.items.map { it.value<TimelineItem>() }
  // => [TimelineItem("item_id_3", ...), TimelineItem("item_id_4", ...)]
page2.items.map { it.value<TimelineItem>() }
  // => [TimelineItem("item_id_5", ...)]
page2.hasNext // => false

// KottageList is a Linked List.
val entry1: KottageListEntry? = list.getFirst()
val entry2: KottageListEntry? = list.get(checkNotNull(entry1.nextPositionId))
val entry3: KottageListEntry? = list.get(checkNotNull(entry2.nextPositionId))
// convenience method to get an entry by index
val entry4: KottageListEntry? = list.getByIndex(3)

entry1?.value<TimelineItem>() // => TimelineItem("item_id_1", otherValue = ...)

@Serializable
data class MyData(val myValue: Int)

val data: MyData = MyData(42)
val list: List<String> = listOf("item1", "item2") // List<String> is Serializable
val cache: KottageStorage = kottage.cache("my_data_cache")
cache.put("item1", data)
cache.put("item2", list)
val storedData: MyData = cache.get<MyData>("item1")
val storedList: List<String> = cache.get<List<String>>("item2")

val cache: KottageStorage = kottage.cache("type_items")
cache.put("item1", 0) // Store as Number (= SQLite Number = Long, Int, Short, Byte or Boolean)
cache.put("item2", "strings") // Store as String
cache.get<String>("item1") // throws ClassCastException
cache.get<Int>("item2") // throws ClassCastException

@Serializable
data class Data(val data: Int)

@Serializable
data class Data2(val data2: Int)

val cache: KottageStorage = kottage.cache("type_items")
cache.put("data", Data(42))
cache.get<String>("data") // => "{\"data\":42}"
cache.get<Data2>("data") // throws SerializationException

val cache: KottageStorage = kottage.cache("my_item_cache")
val now: Long = ... // Unix Time (UTC) in millis
launch {
    cache.eventFlow(now).collect { event ->
        // receive events from flow
        val eventType: KottageEventType = event.eventType // eventType => KottageEventType.Create
        val updatedValue: String = cache.get<String>(event.itemKey) // updatedValue => "value"
    }
}
cache.put("key", "value")
// get events after time
val events: List<KottageEvent> = cache.getEvents(now)
val updatedValue: String = cache.get<String>(event.first().itemKey) // updatedValue => "value"

val cache = kottage.cache("my_item_cache")
val now = ... // Unix Time (UTC) in millis
val eventFlow = cache.eventFlow(now)

...

override fun onCreate(...) { // for example: onCreate
    ...
    lifecycleScope.launch {
        repeatOnLifecycle(Lifecycle.State.STARTED) {
            eventFlow.collect { event ->
                // eventFlow starts dispatching events from last emitted event on previous subscription.
            }
        }
    }
}

val storage: KottageStorage = kottage.storage("encrypted_storage") {
    encoder = object : KottageEncoder {
        override fun encode(value: ByteArray): ByteArray {
            // Your encoding logic (plain ByteArray to encrypted ByteArray) here
            return ...
        }

        override fun decode(encoded: ByteArray): ByteArray {
            // Your decoding logic (encrypted ByteArray to plain ByteArray) here
            return ...
        }
    }
}
// storage's values are encrypted
storage.put("long_value", 100L)
storage.put("string_value", "value")
val longValue: Long = storage.get("long_value") // => 100L
val stringValue: String = storage.get("long_value") // => "value"

import org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsEnvSpec
import org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsRootPlugin
import org.jetbrains.kotlin.gradle.targets.js.npm.tasks.KotlinNpmInstallTask

...
plugins.withType<NodeJsRootPlugin> {
    extensions.configure<NodeJsEnvSpec> {
        // Choose any version you want to use from https://nodejs.org/en/download/releases/
        version = "22.0.0"
        val installBetterSqlite3 by tasks.registering(Exec::class) {
            val envSpec = this@configure
            val node = envSpec.executable.get().replace(File.separator, "/")
            val nodeDir = if (OperatingSystem.current().isWindows) {
                File(node).parent.replace(File.separator, "/")
            } else {
                File(node).parentFile.parent
            }
            val nodeBinDir = File(node).parent.replace(File.separator, "/")
            val npmCli = if (OperatingSystem.current().isWindows) {
                "$nodeDir/node_modules/npm/bin/npm-cli.js"
            } else {
                "$nodeDir/lib/node_modules/npm/bin/npm-cli.js"
            }
            val npm = "\"$node\" \"$npmCli\""
            val betterSqlite3 = layout.buildDirectory.dir("js/node_modules/better-sqlite3")
            dependsOn(tasks.withType<KotlinNpmInstallTask>())
            inputs.files(betterSqlite3.get().file("package.json"))
            inputs.property("node-version", envSpec.version)
            outputs.files(betterSqlite3.get().file("build/Release/better_sqlite3.node"))
            outputs.cacheIf { true }
            workingDir = betterSqlite3.get().asFile
            commandLine = if (OperatingSystem.current().isWindows) {
                listOf(
                    "sh",
                    "-c",
                    // use pwd command to convert C:/... -> /c/...
                    "PATH=\$(cd ${nodeBinDir};pwd):\$PATH $npm run install --verbose"
                )
            } else {
                listOf(
                    "sh",
                    "-c",
                    "PATH=\"$nodeBinDir:\$PATH\" $npm run install --verbose"
                )
            }
        }
    }
}
...

plugins {
    kotlin("multiplatform")
}

kotlin {
    js(IR) {
        ...
    }
    ...
}
...
tasks.withType<NodeJsExec>().configureEach {
    dependsOn(rootProject.tasks.named("installBetterSqlite3"))
}
...