sealed class Door {
    // Define the Open state with its data and behavior
    data class Open(val angle: Double) : Door()
    
    // Define the Closed state with its behavior
    object Closed : Door()  // シンボル見たいのはobject
    
    // Define the Locked state with its data and behavior
    data class Locked(val turns: Int) : Door()
}

// Type alias for Door event functions
typealias DoorEvent = (Door) -> Door

// Event functions for each Door state transition
val closeDoor: DoorEvent = { door ->
    when (door) {
        is Door.Open -> Door.Closed
        else -> door // No change if the state is not Open
    }
}

val swingDoor: (Double) -> DoorEvent = { delta ->
    { door ->
        when (door) {
            is Door.Open -> Door.Open(door.angle + delta)
            else -> door // No change if the state is not Open
        }
    }
}

val openDoor: (Double) -> DoorEvent = { degrees ->
    { door ->
        when (door) {
            is Door.Closed -> Door.Open(degrees)
            else -> door // No change if the state is not Closed
        }
    }
}

val lockDoor: DoorEvent = { door ->
    when (door) {
        is Door.Closed -> Door.Locked(1)
        else -> door // No change if the state is not Closed
    }
}

val unlockDoor: DoorEvent = { door ->
    when (door) {
        is Door.Locked -> Door.Closed
        else -> door // No change if the state is not Locked
    }
}

val turnKey: (Int) -> DoorEvent = { delta ->
    { door ->
        when (door) {
            is Door.Locked -> Door.Locked(door.turns + delta)
            else -> door // No change if the state is not Locked
        }
    }
}

// Example usage
fun main() {
    var door: Door = Door.Open(45.0)
    println("Initial state: $door") // Initial state: Open(angle=45.0)

    // Applying events
    door = closeDoor(door)
    println("After closing: $door") // After closing: Closed

    door = openDoor(90.0)(door)
    println("After opening: $door") // After opening: Open(angle=90.0)

    door = swingDoor(15.0)(door)
    println("After swinging: $door") // After swinging: Open(angle=105.0)

    door = closeDoor(door)
    door = lockDoor(door)
    println("After locking: $door") // After locking: Locked(turns=1)

    door = turnKey(2)(door)
    println("After turning key: $door") // After turning key: Locked(turns=3)

    door = unlockDoor(door)
    println("After unlocking: $door") // After unlocking: Closed
}

interface Printable {
    fun prettyPrint(): String
}

interface Comparable<T> {
    fun compareTo(other: T): Int
}

class User(val name: String, val age: Int) : Printable, Comparable<User> {
    override fun prettyPrint(): String {
        return "User(name=$name, age=$age)"
    }

    override fun compareTo(other: User): Int {
        return this.age - other.age
    }
}

fun <T : Printable> printPretty(value: T) {
    println(value.prettyPrint())
}

fun main() {
    val user1 = User("Alice", 30)
    val user2 = User("Bob", 25)

    printPretty(user1) // User(name=Alice, age=30)

    // 比較
    if (user1.compareTo(user2) > 0) {
        println("${user1.name} is older than ${user2.name}")
    } else {
        println("${user1.name} is younger than or the same age as ${user2.name}")
    }
}

// 関数定義
fun addItemFunction(item: ToDoItem): ToDoListProjectionRow {
    return ToDoListProjectionRow(User("SampleUser"), true, ToDoList(listOf(item)))
}

// 関数型の変数
val addItemLambda: (ToDoItem) -> ToDoListProjectionRow = { item -> 
    ToDoListProjectionRow(User("SampleUser"), true, ToDoList(listOf(item)))
}

val newListName = requestForm("newlistname")
    .flatMap(ListName.Companion::fromUntrusted) // 成功時に ListName に変換し、Result をネストしない
    .getOrElse { error ->
        // 失敗時はエラーメッセージを使って BAD_REQUEST レスポンスを返す
        return Response(Response.BAD_REQUEST).body("Form error: $error") //ここでreturnできるのいい
    }

transform2(outcome1, outcome2, { a, b -> a + b })  // 通常の関数呼び出し
transform2(outcome1, outcome2) { a, b -> a + b }   // ラムダ式の外部配置

// 3つのリストをアプリカティブに組み合わせる例
fun main() {
    val list1 = listOf(1, 2)
    val list2 = listOf("A", "B")
    val list3 = listOf(true, false)

    // リストの要素を組み合わせる関数
    val combine: (Int) -> (String) -> (Boolean) -> String = { a -> { b -> { c -> "$a-$b-$c" } } }

    // アプリカティブの `ap` 操作を使ってリストを組み合わせる
    val result = listOf(combine)
        .ap(list1)
        .ap(list2)
        .ap(list3)

    println(result)  // 出力: [1-A-true, 1-A-false, 1-B-true, 1-B-false, 2-A-true, 2-A-false, 2-B-true, 2-B-false]
}

// OptionとListの組み合わせを扱うモナドトランスフォーマーの例（Kotlinには直接のサポートはないが、イメージとして）
fun <A> listOfOptionsTraverse(options: List<Option<A>>): Option<List<A>> {
    return options.foldRight(Option.Some(emptyList())) { opt, acc ->
        opt.flatMap { value -> acc.map { list -> list + value } }
    }
}

// ListとOptionを同時に扱うためにタプルを使う例
fun main() {
    val options = listOf(
        Pair(Option.Some(1), Option.Some("A")),
        Pair(Option.Some(2), Option.None),
        Pair(Option.None, Option.Some("B"))
    )

    val result = options.mapNotNull { (optInt, optStr) ->
        optInt.flatMap { int ->
            optStr.map { str ->
                "$int-$str"
            }
        }.orElse(null)
    }

    println(result)  // 出力: [1-A]
}

data class ListName internal constructor(val name: String) {
    companion object {
        fun fromTrusted(name: String): ListName = ListName(name)
        fun fromUntrustedOrThrow(name: String): ListName =
            fromUntrusted(name).onFailure { error(it.msg) }

        fun fromUntrusted(name: String): ListNameOutcome =
            name.validateListName(::nameTooShort, ::nameTooLong, ::nameWithInvalidChars)
    }
    override fun toString(): String = name
}

sealed class Tentative<Reason, A> {
    data class Valid<A>(val value: A) : Tentative<Nothing, A>() // 有効な値を表す
    data class Invalid<Reason, A>(val value: A, val reason: Reason) : Tentative<Reason, A>() // 無効な値とその理由を表す
}

// 使用例
typealias MyReason = String // 理由の型
typealias MyValue = Int // 値の型

val validValue: Tentative<MyReason, MyValue> = Tentative.Valid(42)
val invalidValue: Tentative<MyReason, MyValue> = Tentative.Invalid(42, "Out of range")

// 状態を判定する関数
fun handleTentative(tentative: Tentative<MyReason, MyValue>) {
    when (tentative) {
        is Tentative.Valid -> println("Valid value: ${tentative.value}")
        is Tentative.Invalid -> println("Invalid value: ${tentative.value}, Reason: ${tentative.reason}")
    }
}

handleTentative(validValue) // 出力: Valid value: 42
handleTentative(invalidValue) // 出力: Invalid value: 42, Reason: Out of range

// Kotlin のファントム型の実装例

// 通貨を表すタグクラスを定義
sealed class Currency

object USD : Currency()
object EUR : Currency()

// ファントム型を使った Money 型の定義
data class Money<T : Currency>(val amount: Double)

// ファントム型を使った Money を生成する関数
fun createMoneyUSD(amount: Double): Money<USD> = Money(amount)
fun createMoneyEUR(amount: Double): Money<EUR> = Money(amount)

// 同じ通貨の Money を加算する関数
fun <T : Currency> addMoney(m1: Money<T>, m2: Money<T>): Money<T> {
    return Money(m1.amount + m2.amount)
}

// ファントム型を使った例
fun main() {
    val usdAmount: Money<USD> = createMoneyUSD(100.0)
    val usdAmount2: Money<USD> = createMoneyUSD(50.0)
    val eurAmount: Money<EUR> = createMoneyEUR(80.0)

    val totalUSD: Money<USD> = addMoney(usdAmount, usdAmount2) // 正しい
    println("Total USD: $totalUSD")

    // 型安全性により、異なる通貨同士の加算はコンパイル時にエラーが発生します
    // val errorExample = addMoney(usdAmount, eurAmount) // コンパイルエラー
}

// 継続モナドの基本クラス
class Cont<R, A>(val run: (A -> R) -> R) {

    // map 関数 (Functor の実装)
    fun <B> map(f: (A) -> B): Cont<R, B> =
        Cont { k -> run { a -> k(f(a)) } }

    // flatMap 関数 (Monad の実装)
    fun <B> flatMap(f: (A) -> Cont<R, B>): Cont<R, B> =
        Cont { k -> run { a -> f(a).run(k) } }
}

// 加算操作の例
fun add(a: Int, b: Int): Cont<Int, Int> = Cont { k ->
    println("Adding $a and $b")
    k(a + b)
}

// 乗算操作の例
fun multiply(a: Int, b: Int): Cont<Int, Int> = Cont { k ->
    println("Multiplying $a and $b")
    k(a * b)
}

// メイン関数
fun main() {
    // 継続モナドを使って遅延計算を構築
    val delayedCalculation: Cont<Int, Int> = add(1, 2).flatMap { sum ->
        multiply(sum, 3)
    }

    // 計算の実行
    delayedCalculation.run { result ->
        println("Result: $result")
    }
}

// 正の値をチェックする例
fun checkPositive(value: Int): Cont<String, Int> = Cont { k ->
    if (value > 0) {
        println("Value $value is positive")
        k(value)
    } else {
        println("Value $value is not positive")
        "Value is not positive"
    }
}

fun main() {
    // 継続モナドを使ってフロー制御を構築
    val controlledFlow: Cont<String, Int> = checkPositive(5).flatMap { value ->
        checkPositive(value - 10)
    }

    // フローの実行
    controlledFlow.run { result ->
        when (result) {
            is Int -> println("Flow succeeded with result: $result")
            is String -> println("Flow failed with error: $result")
        }
    }
}

sealed interface Animal

sealed interface CanFly : Animal
sealed interface CanSwim : Animal

data class Duck(val name: String) : CanFly, CanSwim
data class Eagle(val name: String) : CanFly
data class Dolphin(val name: String) : CanSwim

fun describeAnimal(animal: Animal): String = when (animal) {
    is CanFly -> when (animal) {
        is CanSwim -> describeFlyingSwimmingAnimal(animal)
        else -> describeFlyingAnimal(animal)
    }
    is CanSwim -> describeSwimmingAnimal(animal)
}

fun describeFlyingSwimmingAnimal(animal: CanFly & CanSwim): String = when (animal) {
    is Duck -> "A duck named ${animal.name} that can fly and swim"
    else -> "Unknown animal that can fly and swim"
}

fun describeFlyingAnimal(animal: CanFly): String = when (animal) {
    is Eagle -> "An eagle named ${animal.name} that can fly"
    else -> "Unknown animal that can fly"
}

fun describeSwimmingAnimal(animal: CanSwim): String = when (animal) {
    is Dolphin -> "A dolphin named ${animal.name} that can swim"
    else -> "Unknown animal that can swim"
}

fun main() {
    val animals: List<Animal> = listOf(
        Duck("Donald"),
        Eagle("Majestic"),
        Dolphin("Flipper")
    )

    animals.forEach { animal ->
        println(describeAnimal(animal))
    }
}

A duck named Donald that can fly and swim
An eagle named Majestic that can fly
A dolphin named Flipper that can swim

data class Person(val name: String, val age: Int)

fun main() {
    val person = Person("John", 30)
    val (name, age) = person
    println(name) // John
    println(age)  // 30
}

sealed class Hand {
    object Rock : Hand()
    object Paper : Hand()
    object Scissors : Hand()
}

// アドレスを表すデータクラス
data class Address(val country: String, val state: String)

// 配送先の種類を表すシールドクラス
sealed class ShippingDestination {
    object UsLocalState : ShippingDestination()
    object UsRemoteState : ShippingDestination()
    object International : ShippingDestination()
}

// 注文を表すデータクラス
data class ValidatedOrder(val shippingAddress: Address)

// 配送先を決定する関数
fun determineDestination(address: Address): ShippingDestination = when {
    address.country == "US" -> when (address.state) {
        "CA", "OR", "AZ", "NV" -> ShippingDestination.UsLocalState
        else -> ShippingDestination.UsRemoteState
    }
    else -> ShippingDestination.International
}

// 配送コストを計算する関数
fun calculateShippingCost(order: ValidatedOrder): Double {
    val destination = determineDestination(order.shippingAddress)
    return when (destination) {
        is ShippingDestination.UsLocalState -> 5.0
        is ShippingDestination.UsRemoteState -> 10.0
        is ShippingDestination.International -> 20.0
    }
}

// 使用例
fun main() {
    val localOrder = ValidatedOrder(Address("US", "CA"))
    val remoteOrder = ValidatedOrder(Address("US", "NY"))
    val internationalOrder = ValidatedOrder(Address("JP", "Tokyo"))

    fun processOrder(order: ValidatedOrder) {
        val cost = calculateShippingCost(order)
        println("Shipping cost for ${order.shippingAddress}: $cost")
    }

    processOrder(localOrder)
    processOrder(remoteOrder)
    processOrder(internationalOrder)
}

// 各タスクを定義する純粋関数
fun curriedTask1(): (Int) -> (Int) -> Int = { x ->
    { y ->
        x * y
    }
}

fun task2(x: Int): Int = x * 3
fun task3(x: Int): Int = x + 10

// ワークフローを動的に構成する関数
fun createWorkflow(input: Int): (Int) -> Int {
    val curriedTask1PartiallyApplied = curriedTask1()(input) // curriedTask1をinputで部分適用する

    val tasks: List<(Int) -> Int> = when {
        input < 5 -> listOf(curriedTask1PartiallyApplied, ::task3)  // task1は入力がbakeされた状態
        else -> listOf(curriedTask1PartiallyApplied, ::task2, ::task3)  // 同様にtask1は入力がbakeされた状態
    }

    // ワークフローを構成する関数リストを合成して関数を返す
    return tasks.reduce { acc, task -> { x -> task(acc(x)) } }
}

// テスト
fun main() {
    val input1 = 3
    val input2 = 6

    val workflow1 = createWorkflow(input1)
    val result1 = workflow1(4)  // curriedTask1(3)(4) = 12, then task3(12) = 22
    println("Result for input1: $result1")  // タスク1とタスク3のみ実行

    val workflow2 = createWorkflow(input2)
    val result2 = workflow2(5)  // curriedTask1(6)(5) = 30, task2(30) = 90, task3(90) = 100
    println("Result for input2: $result2")  // 全てのタスクを実行
}

import java.time.LocalDate

// 保険契約者の情報
data class Customer(
    val age: Int,
    val smoker: Boolean,
    val healthConditions: List<String>
)

// 保険の種類
enum class InsuranceType { LIFE, HEALTH, AUTO }

// 保険料計算のための環境
data class PricingEnv(
    var baseRate: Double,
    val currentDate: LocalDate
)

// Writer モナドの簡易実装
data class Writer<T>(val value: T, val log: List<String>)

// PricingM モナド（ReaderT + Writer の簡易実装）
typealias PricingM<T> = (PricingEnv) -> Writer<T>

// モナド操作のヘルパー関数
fun <T> PricingM<T>.flatMap(f: (T) -> PricingM<T>): PricingM<T> = { env ->
    val (value, log1) = this(env)
    val (newValue, log2) = f(value)(env)
    Writer(newValue, log1 + log2)
}

fun <T> PricingM<T>.map(f: (T) -> T): PricingM<T> = { env ->
    val (value, log) = this(env)
    Writer(f(value), log)
}

// DSL 関数
fun setBaseRate(rate: Double): PricingM<Unit> = { env ->
    env.baseRate = rate
    Writer(Unit, listOf("基本料金を設定: $rate"))
}

fun adjustForAge(customer: Customer): PricingM<Double> = { env ->
    val factor = if (customer.age > 50) 1.5 else 1.0
    Writer(env.baseRate * factor, listOf("年齢による調整係数: $factor"))
}

fun adjustForSmoking(customer: Customer): PricingM<Double> = { env ->
    val factor = if (customer.smoker) 1.5 else 1.0
    Writer(env.baseRate * factor, listOf("喫煙状態による調整係数: $factor"))
}

fun adjustForHealth(customer: Customer): PricingM<Double> = { env ->
    val factor = 1.0 + (0.1 * customer.healthConditions.size)
    Writer(env.baseRate * factor, listOf("健康状態による調整係数: $factor"))
}

fun finalAdjustment(insuranceType: InsuranceType): PricingM<Double> = { env ->
    val factor = when (insuranceType) {
        InsuranceType.LIFE -> 1.2
        InsuranceType.HEALTH -> 1.1
        InsuranceType.AUTO -> 1.0
    }


    Writer(env.baseRate * factor, listOf("保険種類による最終調整係数: $factor"))
}

// 保険料計算のメイン関数
fun calculatePremium(customer: Customer, insType: InsuranceType): PricingM<Double> = { env ->
    val result = setBaseRate(1000.0)
        .flatMap { adjustForAge(customer) }
        .flatMap { adjustForSmoking(customer) }
        .flatMap { adjustForHealth(customer) }
        .flatMap { finalAdjustment(insType) }
    result(env)
}

// DSLの使用例
fun main() {
    val env = PricingEnv(0.0, LocalDate.now())
    val customer = Customer(age = 55, smoker = true, healthConditions = listOf("高血圧"))
    
    val (premium, logs) = calculatePremium(customer, InsuranceType.LIFE)(env)
    
    println("保険料計算ログ:")
    logs.forEach(::println)
    println("最終保険料: $premium")
}

import kotlin.math.max

data class InventoryItem(val id: String, val name: String, var quantity: Int)
typealias InventoryState = Map<String, InventoryItem>

class State<S, A>(val run: (S) -> Pair<A, S>) {
    companion object {
        fun <S, A> pure(a: A): State<S, A> = State { s -> Pair(a, s) }
    }

    fun <B> flatMap(f: (A) -> State<S, B>): State<S, B> = State { s ->
        val (a, s1) = this.run(s)
        f(a).run(s1)
    }

    fun <B> map(f: (A) -> B): State<S, B> = flatMap { a -> pure(f(a)) }
}

object InventoryDSL {
    // 共通の環境を定義
    var logger: (String) -> Unit = { println(it) }
    var maxCapacity: Int = 1000
    var lowStockThreshold: Int = 10

    private fun log(message: String) = State<InventoryState, Unit> { state ->
        logger(message)
        Pair(Unit, state)
    }

    fun addItem(item: InventoryItem): State<InventoryState, Unit> = State { state ->
        val newState = state + (item.id to item)
        if (newState.values.sumOf { it.quantity } > maxCapacity) {
            throw IllegalStateException("Exceeding max capacity")
        }
        Pair(Unit, newState)
    }.flatMap { log("Added item: ${item.id}") }

    fun removeItem(id: String): State<InventoryState, Unit> = State { state ->
        val newState = state - id
        Pair(Unit, newState)
    }.flatMap { log("Removed item: $id") }

    fun updateQuantity(id: String, delta: Int): State<InventoryState, Unit> = State { state ->
        val item = state[id] ?: throw IllegalArgumentException("Item not found: $id")
        val updatedItem = item.copy(quantity = max(0, item.quantity + delta))
        val newState = state + (id to updatedItem)
        Pair(Unit, newState)
    }.flatMap { 
        log("Updated quantity for item $id: delta=$delta")
    }.flatMap {
        checkLowStock(id)
    }

    fun getItemQuantity(id: String): State<InventoryState, Int> = State { state ->
        val quantity = state[id]?.quantity ?: throw IllegalArgumentException("Item not found: $id")
        Pair(quantity, state)
    }

    fun listItems(): State<InventoryState, List<InventoryItem>> = State { state ->
        Pair(state.values.toList(), state)
    }

    private fun checkLowStock(id: String): State<InventoryState, Unit> = getItemQuantity(id).flatMap { quantity ->
        if (quantity <= lowStockThreshold) {
            log("Low stock alert for item $id: quantity=$quantity")
        } else {
            State.pure(Unit)
        }
    }
}

fun manageInventory(): State<InventoryState, Unit> {
    return InventoryDSL.run {
        addItem(InventoryItem("A001", "Widget", 100))
            .flatMap { addItem(InventoryItem("B002", "Gadget", 50)) }
            .flatMap { updateQuantity("A001", -95) }
            .flatMap { getItemQuantity("A001").map { quantity -> println("Current quantity of Widget: $quantity") } }
            .flatMap { updateQuantity("B002", 30) }
            .flatMap { removeItem("A001") }
            .flatMap { listItems().map { items -> println("Remaining items: ${items.joinToString { it.name }}") } }
    }
}

fun runInventoryManagement(initialState: InventoryState): InventoryState {
    // カスタム環境の設定
    InventoryDSL.logger = { message -> println("LOG: $message") }
    InventoryDSL.maxCapacity = 500
    InventoryDSL.lowStockThreshold = 20

    return manageInventory().run(initialState).second
}

fun main() {
    val initialState = emptyMap<String, InventoryItem>()
    val finalState = runInventoryManagement(initialState)
    println("Final inventory state: $finalState")
}

inline fun <reified T> List<Any>.mapIfType(transform: (T) -> T): List<Any> {
    return this.map { 
        if (it is T) {
            transform(it)
        } else {
            it
        }
    }
}

// 使用例
val mixedList = listOf(1, "Hello", 2, "World")

val result = mixedList.mapIfType<String> { it.toUpperCase() }
println(result)  // 出力: [1, "HELLO", 2, "WORLD"]

inline fun <reified T> executeIfType(value: Any, ifTrue: (T) -> Unit, ifFalse: () -> Unit) {
    if (value is T) {
        ifTrue(value)
    } else {
        ifFalse()
    }
}

// 使用例
val data: Any = "Kotlin"

executeIfType<String>(data,
    ifTrue = { println("String detected: $it") },
    ifFalse = { println("Not a string") }
)  // 出力: "String detected: Kotlin"

executeIfType<Int>(data,
    ifTrue = { println("Int detected: $it") },
    ifFalse = { println("Not an Int") }
)  // 出力: "Not an Int"

inline fun <reified T, R> transformIfType(list: List<Any>, transform: (T) -> R): List<Any> {
    return list.map {
        if (it is T) {
            transform(it)
        } else {
            it
        }
    }
}

// 使用例
val mixedList2 = listOf(1, "Hello", 2, "World")

val transformedList = transformIfType<String, String>(mixedList2) { it.reversed() }
println(transformedList)  // 出力: [1, "olleH", 2, "dlroW"]

val intTransformedList = transformIfType<Int, Int>(mixedList2) { it * 2 }
println(intTransformedList)  // 出力: [2, "Hello", 4, "World"]

inline fun <reified T, R> filterAndTransform(list: List<Any>, transform: (T) -> R): List<R> {
    return list.filterIsInstance<T>().map(transform)
}

// 使用例
val mixedList3 = listOf(1, "Hello", 2, "World", 3)

val resultStrings = filterAndTransform<String, String>(mixedList3) { it.toUpperCase() }
println(resultStrings)  // 出力: ["HELLO", "WORLD"]

val resultInts = filterAndTransform<Int, Int>(mixedList3) { it * 10 }
println(resultInts)  // 出力: [10, 20, 30]