object Resource { val name = "Name" }

object Resource {
    val name = "Name"
}

fun main() {
    println(Resource.name)  // => "Name"
}

// domain/ports
interface BookingRepo {
    suspend fun find(id: String): Booking?
    suspend fun save(b: Booking)
}

// infra/adapters
class BookingRepoPg(private val ds: DataSource): BookingRepo { /* ... */ }

class BookingService(private val repo: BookingRepo) {
    suspend fun get(id: String) = repo.find(id) ?: error("not found")
}

object AppConfig {
    val dbUrl: String by lazy { System.getenv("DB_URL") ?: "jdbc:postgresql://localhost:5432/app" }
}

object Resources {
    val dataSource: DataSource by lazy {
        HikariDataSource(HikariConfig().apply { jdbcUrl = AppConfig.dbUrl })
    }
    val http: HttpClient by lazy { HttpClient(CIO) { expectSuccess = true } }
}

fun Application.module() {
    // 依存の組み立て（コンテナなし）
    val bookingRepo: BookingRepo = BookingRepoPg(Resources.dataSource)
    val bookingService = BookingService(bookingRepo)

    // ライフサイクル管理
    environment.monitor.subscribe(ApplicationStopping) {
        (Resources.dataSource as? HikariDataSource)?.close()
        Resources.http.close()
    }

    // ルーティングに注入（高階関数で渡すとテストも楽）
    routing { bookingRoutes(bookingService) }
}

fun Route.bookingRoutes(svc: BookingService) {
    get("/bookings/{id}") {
        val id = call.parameters["id"]!!
        call.respond(svc.get(id))
    }
}

data class Settings(val dbUrl: String, val jwtIssuer: String)
fun loadSettings(): Settings = Settings(
    dbUrl = System.getenv("DB_URL") ?: error("DB_URL required"),
    jwtIssuer = System.getenv("JWT_ISSUER") ?: "gym-booking"
)

class BookingRepoFake : BookingRepo { /* メモリに保存 */ }
@Test fun `get returns entity`() = runTest {
    val svc = BookingService(BookingRepoFake().apply { /* seed */ })
    assertNotNull(svc.get("id1"))
}

src/main/kotlin/
  app/
    Module.kt           // Composition Root
    Routes.kt
    Settings.kt
  domain/
    model/Booking.kt
    ports/BookingRepo.kt
    services/BookingService.kt
  infra/
    db/BookingRepoPg.kt
    http/ExternalFooClient.kt

@JvmInline value class EmployeeId(private val id: String) 
@JvmInline value class CustomerId(private val id: String)

@JvmInline
value class EmployeeId(private val id: String)

@JvmInline
value class CustomerId(private val id: String)

fun findEmployee(id: String) { ... }
fun findCustomer(id: String) { ... }

val emp = "E-123"
val cus = "C-456"

// 間違えてもコンパイルが通ってしまう
findEmployee(cus) 

fun findEmployee(id: EmployeeId) { ... }
fun findCustomer(id: CustomerId) { ... }

val emp = EmployeeId("E-123")
val cus = CustomerId("C-456")

findEmployee(emp)   // ✅ OK
findEmployee(cus)   // ❌ コンパイルエラー

val name: String? = "Kotlin"
val length = name?.let {
    println("名前は $it")
    it.length
} ?: 0

val message = StringBuilder().run {
    append("Hello, ")
    append("World!")
    toString()
}

val turtle = Turtle()
with(turtle) {
    penDown()
    repeat(4) {
        forward(100.0)
        turn(90.0)
    }
    penUp()
}

val user = User().apply {
    name = "Alice"
    age = 30
}

val list = mutableListOf("a", "b").also {
    println("初期リスト: $it")
}

fun calcTaxes(): BigDecimal = TODO("Waiting for feedback from accounting")

fun calcTaxes(): BigDecimal = TODO("Waiting for feedback from accounting")

@Disabled("まだ未実装: 会計ロジック待ち")
@Test
fun `calcTaxes should return proper amount`() {
    val result = calcTaxes()
    // TODO: 実装後に期待値を入れる
}

class TaxSpec : StringSpec({
    "calcTaxes should compute correct value".config(enabled = false) {
        calcTaxes() shouldBe BigDecimal("100")
    }
})

class TaxSpec : StringSpec({
    "calcTaxes should compute correct value".config(enabled = false) {
        TODO("未実装")
    }
})

/**
 * Sample class laid out per the guideline:
 * 1) Properties & init blocks
 * 2) Secondary constructors
 * 3) Methods (group related ones together; mix regular/extension helpers)
 * 4) Companion object
 * 5) Nested classes intended for external use and NOT referenced inside the class
 */
class TaskQueue(
    private val store: Persistence,
    private val now: () -> Long = { System.currentTimeMillis() }
) {

    // --- 1) Property declarations & initializer blocks -----------------------

    private val inMemoryBuffer = mutableListOf<Task>() // small write-through buffer

    init {
        // basic invariant checks
        require(now() > 0) { "Clock must return a positive epoch millis." }
    }

    // --- 2) Secondary constructors ------------------------------------------

    /**
     * Convenience constructor for an in-memory queue.
     */
    constructor() : this(InMemoryPersistence())

    // --- 3) Methods (public API first, then helpers; related things together) -

    /** Enqueue a task and return its assigned id. */
    fun enqueue(payload: String, priority: Int = DEFAULT_PRIORITY): String {
        val task = Task(
            id = Ids.newId(),
            payload = payload,
            priority = priority.coerceIn(MIN_PRIORITY..MAX_PRIORITY),
            enqueuedAt = now()
        )
        inMemoryBuffer.add(task)
        // write-through to persistence
        store.save(task)
        return task.id
    }

    /** Try to dequeue the highest-priority task (stable by time). */
    fun dequeue(): Task? {
        // merge view: buffer + persisted (demonstration purpose)
        val merged = (store.all() + inMemoryBuffer).distinctBy { it.id }.toMutableList()
        val next = merged.pickHighestPriority()
        if (next != null) {
            store.delete(next.id)
            inMemoryBuffer.removeIf { it.id == next.id }
        }
        return next
    }

    /** Peek current size (not strictly consistent; demo intent). */
    fun size(): Int = (store.all() + inMemoryBuffer).distinctBy { it.id }.size

    /** Clear everything. */
    fun clear() {
        store.clear()
        inMemoryBuffer.clear()
    }

    // ----- Helpers: keep them close to the methods that use them -------------

    /** Member *extension* on a mutable list of Task: pick highest priority, FIFO on ties. */
    private fun MutableList<Task>.pickHighestPriority(): Task? =
        this.maxWithOrNull(compareBy<Task> { it.priority }.thenBy { it.enqueuedAt })

    // --- 4) Companion object -------------------------------------------------

    companion object {
        const val MIN_PRIORITY = 0
        const val MAX_PRIORITY = 10
        const val DEFAULT_PRIORITY = 5

        /** Simple id generator kept with the type that uses it. */
        private object Ids {
            fun newId(): String = buildString(16) {
                append(System.currentTimeMillis().toString(16))
                append('-')
                append((0..Int.MAX_VALUE).random().toString(16))
            }
        }
    }

    // Put nested classes next to the code that uses them:
    // These are referenced inside TaskQueue, so keep them here (not at the end).

    /** Persistence port (interface) used by TaskQueue. */
    interface Persistence {
        fun save(task: Task)
        fun all(): List<Task>
        fun delete(id: String)
        fun clear()
    }

    /** Simple in-memory adapter; used by the secondary ctor and methods above. */
    private class InMemoryPersistence : Persistence {
        private val map = LinkedHashMap<String, Task>()
        override fun save(task: Task) { map[task.id] = task }
        override fun all(): List<Task> = map.values.toList()
        override fun delete(id: String) { map.remove(id) }
        override fun clear() { map.clear() }
    }

    /** Value object used internally and in public API returns. */
    data class Task(
        val id: String,
        val payload: String,
        val priority: Int,
        val enqueuedAt: Long
    )
}

// --- 5) Nested types intended for external use and NOT referenced inside ----
// (If you had such types, place them after the companion object of the class.)
// For demonstration, imagine an externally-consumed DTO unrelated to internals:

/** Example: A lightweight projection that external modules might use. */
data class TaskSummary(val id: String, val priority: Int)

/**
 * Class layout sample that maps clearly to the requested order:
 * 1) Property declarations & initializer blocks
 * 2) Secondary constructors
 * 3) Method declarations (related ones grouped together)
 * 4) Companion object
 */
class TaskQueue(
    private val store: Persistence,
    private val now: () -> Long = { System.currentTimeMillis() }
) {

    // ------------------------------------------------------------
    // [1] Property declarations and initializer blocks
    // ------------------------------------------------------------
    private val inMemoryBuffer = mutableListOf<Task>() // small write-through buffer

    init {
        require(now() > 0) { "Clock must return a positive epoch millis." }
    }

    // ------------------------------------------------------------
    // [2] Secondary constructors
    // ------------------------------------------------------------
    /** Convenience in-memory queue constructor. */
    constructor() : this(InMemoryPersistence())

    // ------------------------------------------------------------
    // [3] Method declarations
    // (public API first; helpers placed near their callers)
    // ------------------------------------------------------------
    /** Enqueue a task and return its id. */
    fun enqueue(payload: String, priority: Int = DEFAULT_PRIORITY): String {
        val task = Task(
            id = Ids.newId(),
            payload = payload,
            priority = priority.coerceIn(MIN_PRIORITY..MAX_PRIORITY),
            enqueuedAt = now()
        )
        inMemoryBuffer.add(task)
        store.save(task) // write-through
        return task.id
    }

    /** Dequeue highest-priority (stable by time) task; null if none. */
    fun dequeue(): Task? {
        val merged = (store.all() + inMemoryBuffer).distinctBy { it.id }.toMutableList()
        val next = merged.pickHighestPriority()
        if (next != null) {
            store.delete(next.id)
            inMemoryBuffer.removeIf { it.id == next.id }
        }
        return next
    }

    /** Approximate queue size. */
    fun size(): Int = (store.all() + inMemoryBuffer).distinctBy { it.id }.size

    /** Clear all tasks. */
    fun clear() {
        store.clear()
        inMemoryBuffer.clear()
    }

    /** Helper: pick highest priority, FIFO on ties. */
    private fun MutableList<Task>.pickHighestPriority(): Task? =
        this.maxWithOrNull(compareBy<Task> { it.priority }.thenBy { it.enqueuedAt })

    // ------------------------------------------------------------
    // [4] Companion object
    // ------------------------------------------------------------
    companion object {
        const val MIN_PRIORITY = 0
        const val MAX_PRIORITY = 10
        const val DEFAULT_PRIORITY = 5

        /** Simple id generator kept with the type that uses it. */
        internal object Ids {
            fun newId(): String = buildString(16) {
                append(System.currentTimeMillis().toString(16))
                append('-')
                append((0..Int.MAX_VALUE).random().toString(16))
            }
        }
    }

    // (Nested classes are placed next to usage sites; these are referenced above)

    interface Persistence {
        fun save(task: Task)
        fun all(): List<Task>
        fun delete(id: String)
        fun clear()
    }

    private class InMemoryPersistence : Persistence {
        private val map = LinkedHashMap<String, Task>()
        override fun save(task: Task) { map[task.id] = task }
        override fun all(): List<Task> = map.values.toList()
        override fun delete(id: String) { map.remove(id) }
        override fun clear() { map.clear() }
    }

    data class Task(
        val id: String,
        val payload: String,
        val priority: Int,
        val enqueuedAt: Long
    )
}

typealias Headers = Map<String, List<String>>
typealias UserJson = String
typealias OnTaxCalculated = (amount: BigDecimal) -> Unit

// 実体は元の型と完全に同じ（オーバーロードの区別も不可）
fun send(h: Headers) { /* Map<String, List<String>> と同じ */ }

@JvmInline
value class UserId(val value: String) {
    fun masked() = value.takeLast(6).padStart(value.length, '*')
}

@JvmInline
value class Yen(val amount: Long)
@JvmInline
value class Usd(val amount: Long)

// 誤用をコンパイルで防げる（Kotlin から呼ぶ場合）
fun pay(id: UserId, price: Yen) { /* ... */ }

// こういう取り違えはエラーになる
// pay(UserId("u1"), Usd(100)) // 型が違うのでコンパイルエラー

@JvmInline
value class BookingId(val value: String)

get("/bookings/{id}") {
    val id = call.parameters["id"]?.let(::BookingId) ?: return@get call.respond(HttpStatusCode.BadRequest)
    // 以降は BookingId として安全に扱える
}

typealias JsonBody = String
suspend fun respondJson(call: ApplicationCall, body: JsonBody) { call.respondText(body, ContentType.Application.Json) }

dependencies {
    implementation("io.ktor:ktor-server-core-jvm:2.3.12")
    implementation("io.ktor:ktor-server-netty-jvm:2.3.12")
    implementation("com.zaxxer:HikariCP:5.1.0")
    implementation("org.jetbrains.exposed:exposed-core:0.54.0")
    implementation("org.jetbrains.exposed:exposed-dao:0.54.0")
    implementation("org.jetbrains.exposed:exposed-jdbc:0.54.0")
    implementation("org.postgresql:postgresql:42.7.4") // DBに合わせて
    // マイグレーション（任意）
    implementation("org.flywaydb:flyway-core:10.18.2")
}

import com.zaxxer.hikari.HikariConfig
import com.zaxxer.hikari.HikariDataSource
import org.jetbrains.exposed.sql.Database

fun connectDatabase() {
    val cfg = HikariConfig().apply {
        jdbcUrl = System.getenv("DATABASE_URL") ?: "jdbc:postgresql://localhost:5432/app"
        username = System.getenv("DB_USER") ?: "app"
        password = System.getenv("DB_PASSWORD") ?: "password"
        maximumPoolSize = 10
    }
    Database.connect(HikariDataSource(cfg))
}

import org.jetbrains.exposed.sql.*
import org.jetbrains.exposed.sql.transactions.transaction

object Users : Table("users") {
    val id = long("id").autoIncrement()
    val name = varchar("name", 50)
    val email = varchar("email", 255).uniqueIndex()
    override val primaryKey = PrimaryKey(id)
}

fun createAndQuery() = transaction {
    // 本番は SchemaUtils ではなく Flyway/Liquibase を推奨
    SchemaUtils.create(Users)

    Users.insert {
        it[name] = "Alice"
        it[email] = "alice@example.com"
    }

    Users.selectAll()
        .limit(10)
        .map { it[Users.id] to it[Users.name] }
}

fun Application.module() {
    connectDatabase()

    routing {
        get("/users") {
            val users = org.jetbrains.exposed.sql.transactions.transaction {
                Users.selectAll().map {
                    mapOf("id" to it[Users.id], "name" to it[Users.name])
                }
            }
            call.respond(users)
        }
    }
}

src/main/resources/db/migration/
  └─ V1__create_users.sql

CREATE TABLE IF NOT EXISTS users (
  id BIGSERIAL PRIMARY KEY,
  name VARCHAR(50) NOT NULL,
  email VARCHAR(255) NOT NULL UNIQUE
);

// 起動時に実行
import org.flywaydb.core.Flyway

fun migrate() {
    val url = System.getenv("DATABASE_URL") ?: "jdbc:postgresql://localhost:5432/app"
    val user = System.getenv("DB_USER") ?: "app"
    val pass = System.getenv("DB_PASSWORD") ?: "password"
    Flyway.configure()
        .dataSource(url, user, pass)
        .locations("classpath:db/migration")
        .load()
        .migrate()
}