// 基本データ型への執着
val price: Double = 19.99
val currency: String = "USD"  // 通貨型の代わりに文字列を使用

// より良いアプローチ
data class Price(val amount: Double, val currency: Currency)
enum class Currency {
    USD, EUR, JPY
}

// データの群れ
fun processUser(firstName: String, lastName: String, address: String, city: String, zipCode: String) {
    // 処理コード
}

// より良いアプローチ
data class User(val firstName: String, val lastName: String, val address: Address)
data class Address(val streetAddress: String, val city: String, val zipCode: String)

// Switch文
fun calculateTax(productType: String, price: Double): Double {
    return when (productType) {
        "book" -> price * 0.05
        "food" -> price * 0.08
        "electronics" -> price * 0.15
        else -> price * 0.20
    }
}

// ポリモーフィズムを使用したより良いアプローチ
interface Product {
    fun calculateTax(): Double
}

class Book(private val price: Double) : Product {
    override fun calculateTax() = price * 0.05
}

class Food(private val price: Double) : Product {
    override fun calculateTax() = price * 0.08
}

class Electronics(private val price: Double) : Product {
    override fun calculateTax() = price * 0.15
}

// 機能の横恋慕
class Order {
    fun totalPrice() = 20.0
}

class Payment {
    fun processPayment(order: Order) {
        val price = order.totalPrice()
        // 注文データに基づいて支払いを処理
    }
}

// より良いアプローチ：processPaymentメソッドをOrderクラスに移動
class Order {
    fun totalPrice() = 20.0

    fun processPayment() {
        val price = totalPrice()
        // 支払いを処理
    }
}

// コメント付きの悪い例
fun calculate() {
    // ユーザーがログインしていてセッションが有効かチェック
    if (user.isLoggedIn && session.isValid) {
        // 有効な場合、ユーザータイプに基づいて計算を実行
        // ユーザータイプが管理者の場合、10%増加
        if (user.type == "admin") {
            performCalculation() * 1.10
        } else {
            performCalculation()
        }
    }
}

// より良いアプローチ：コメント不要の自己説明的コード
fun calculate() {
    if (isValidSession()) {
        performUserSpecificCalculation()
    }
}

private fun isValidSession() = user.isLoggedIn && session.isValid
private fun performUserSpecificCalculation() = when (user.type) {
    "admin" -> performCalculation() * 1.10
    else -> performCalculation()
}

interface CreditCardProcessor {
    fun chargeCard(cardInfo: String, amount: Double): Boolean
}

interface TransactionLog {
    fun logTransaction(status: String)
}

class PaymentService(
    private val processor: CreditCardProcessor,
    private val transactionLog: TransactionLog
) {
    fun processPayment(cardInfo: String, amount: Double): Boolean {
        val success = processor.chargeCard(cardInfo, amount)
        if (success) {
            transactionLog.logTransaction("Success")
        } else {
            transactionLog.logTransaction("Failure")
        }
        return success
    }
}

import io.mockk.every
import io.mockk.mockk
import io.mockk.verify
import org.junit.Test

class PaymentServiceTest {

    @Test
    fun `Given credit card is valid, When processing payment, Then log success`() {
        // Arrange (Given) - 準備
        val mockProcessor = mockk<CreditCardProcessor>()
        val mockTransactionLog = mockk<TransactionLog>(relaxed = true)

        every { mockProcessor.chargeCard(any(), any()) } returns true

        val paymentService = PaymentService(mockProcessor, mockTransactionLog)

        // Act (When) - 実行
        val paymentResult = paymentService.processPayment("1234567890", 100.0)

        // Assert (Then) - 検証
        assert(paymentResult)
        verify { mockTransactionLog.logTransaction("Success") }
    }
}