// settings.gradle.kts
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        mavenCentral()
        maven { url = uri("https://jitpack.io") }
    }
}

// build.gradle.kts
plugins {
    kotlin("jvm")
    id("com.google.devtools.ksp")
}

dependencies {
    ksp("com.github.vdybysov.kserde:processor:0.0.1")
    implementation("com.github.vdybysov.kserde:core:0.0.1")
    implementation("com.github.vdybysov.kserde:annotations:0.0.1")

    // Optional: Ktor ContentConverter for JSON
    implementation("com.github.vdybysov.kserde:ktor:0.0.1")

    // Optional: MongoDB CodecProvider
    implementation("com.github.vdybysov.kserde:mongo:0.0.1")
}

import serde.annotation.Serde

@Serde
data class User(
    val id: String,
    val name: String,
    val email: String?,
    val createdAt: Instant
)

import your.package.UserSerde

val user = User("1", "Alice", "[email protected]", Instant.now())

// Serialize
val json = UserSerde.toJson(user)
val bson = UserSerde.toBson(user)

// Deserialize
val fromJson = UserSerde.fromJson(json)
val fromBson = UserSerde.fromBson(bson)

import serde.SerdeRegistry

val registry = SerdeRegistry.Default
val serde = registry.getSerde(User::class.java)

val json = serde.toJson(user)
val restored = serde.fromJson(json)

import org.bson.BsonReader
import org.bson.BsonWriter
import serde.annotation.PropertyName
import serde.annotation.Serde

enum class UserRole { GUEST, USER, ADMIN }

@Serde
data class UserProfile(
    val id: String,
    val displayName: String,
    @PropertyName(bson = "tags_bson", json = "tags") val tags: Set<String>,
    val preferences: UserPreferences,
    val role: UserRole
)

@Serde
data class UserPreferences(
    @Serde(with = CustomIdsSerde::class) val favoriteIds: List<Int>
)

// Custom format: store List<Int> as comma-separated string "1,2,3"
object CustomIdsSerde : serde.Serde<List<Int>> {
    override fun read(reader: BsonReader): List<Int> =
        reader.readString()
            .takeIf { it.isNotEmpty() }
            ?.split(",")
            ?.map { it.toInt() }
            ?.toList()
            ?: emptyList()

    override fun write(writer: BsonWriter, value: List<Int>) =
        writer.writeString(value.joinToString(","))
}

// Usage
val profile = UserProfile(
    "1", "Alice", setOf("a", "b"),
    UserPreferences(listOf(10, 20)),
    UserRole.ADMIN
)
val json = UserProfileSerde.toJson(profile)
val restored = UserProfileSerde.fromBson(UserProfileSerde.toBson(profile))

@Serde
data class Simple(val x: Int)

@Serde(with = CustomUserSerde::class)
data class User(val id: String)

@Serde
@Mutable
class ComplexEntity { var id: String = ""; var name: String = "" }

@Serde
@SubTypes(
    propertyName = "kind",
    types = [
        SubTypes.Type(type = Dog::class, name = "dog"),
        SubTypes.Type(type = Cat::class, name = "cat"),
    ]
)
interface Animal {
    val kind: String
}

@Serde
data class Dog(val name: String) : Animal {
    override val kind = "dog"
}

@Serde
data class Cat(val lives: Int) : Animal {
    override val kind = "cat"
}

@Serde
data class ApiResponse(
    @PropertyName(json = "user_id") val userId: String,
    @PropertyName(bson = "_id", json = "id") val id: ObjectId
)

@Serde
data class ApiResponse(
    val requestId: String,
    val payload: String,
    @PropertyIgnore val internalTraceId: String  // excluded from BSON/JSON
)

@Serde
data class Document(
    val id: String,
    @ReadOnly val computedAt: Instant?,  // Read from storage, never write
    @WriteOnly val internalFlag: Boolean  // Write for debugging, never read
)

import io.ktor.client.plugins.contentnegotiation.ContentNegotiation
import io.ktor.http.ContentType
import serde.ktor.converter.SerdeConverter
import serde.SerdeRegistry

// Ktor Client
HttpClient {
    install(ContentNegotiation) {
        register(
            ContentType.Application.Json,
            SerdeConverter(SerdeRegistry.Default)
        )
    }
}

// Ktor Server
install(ContentNegotiation) {
    register(
        ContentType.Application.Json,
        SerdeConverter(SerdeRegistry.Default)
    )
}

import com.mongodb.ConnectionString
import com.mongodb.MongoClientSettings
import com.mongodb.client.MongoClient
import com.mongodb.client.MongoClients
import org.bson.codecs.configuration.CodecRegistries
import serde.SerdeRegistry
import serde.mongo.codecProvider

val settings = MongoClientSettings.builder()
    .applyConnectionString(ConnectionString("mongodb://localhost"))
    .codecRegistry(
        CodecRegistries.fromProviders(
            SerdeRegistry.Default.codecProvider,
            // ... other providers
        )
    )
    .build()

val client = MongoClients.create(settings)
val collection = client
    .getDatabase("mydb")
    .getCollection("users", User::class.java)

interface Serde<T : Any> {
    fun read(reader: BsonReader): T
    fun readList(reader: BsonReader): MutableList<T>
    fun write(writer: BsonWriter, value: T)
    fun writeList(writer: BsonWriter, coll: Iterable<T>)
    fun fromBson(bson: ByteArray): T
    fun fromJson(json: String): T
    fun toBson(obj: T): ByteArray
    fun toBsonDocument(obj: T): BsonDocument
    fun toJson(obj: T): String
    fun copy(obj: T): T
}

@Serde
data class User(val id: String, val name: String)

public object UserSerde : ObjectSerde<User> {
    override fun read(reader: BsonReader): User {
        var id: String? = null
        var name: String? = null
        reader.readDocument {
            when (it) {
                "id" -> id = StringSerde.read(reader)
                "name" -> name = StringSerde.read(reader)
                else -> reader.skipValue()
            }
        }
        require(id != null) { "Parameter 'id' is required." }
        require(name != null) { "Parameter 'name' is required." }
        return User(id!!, name!!)
    }

    override fun writeFields(writer: BsonWriter, value: User) {
        writer.writeName("id")
        StringSerde.write(writer, value.id)
        writer.writeName("name")
        StringSerde.write(writer, value.name)
    }
}