// MyClass.java
public class MyClass {
    public static void main(final String[] args) throws Exception {
        System.out.println("Hello world!");
    }
}

// MyClass.kt
fun main(args: Array<String>) =
    println("Hello world!")

// MyClass.java
public class MyClass {
    private static final String DASHES = "--";
    public static void main(final String... args) {
        new MyClass()
                .run("Hello", text -> System.out.println(DASHES + " " + text + " "))
                .run("world!", text -> System.out.println(text));
    }
    private MyClass run(final String text, final Consumer<String> task) {
        task.accept(text);
        return this;
    }
}

// MyClass.kt
fun main(vararg args: String) =
    MyClass()
        .run("Hello", { text -> println("$DASHES $text ") })
        .run("world!") { println(it) }

class MyClass {
    companion object {
        const val DASHES = "--"
    }
    fun run(text: String, task: Consumer<String>): MyClass {
        task.accept(text)
        return this
    }
}

// persistency
@Entity
@Table(schema = "CPCM", name = "BasicRate")
internal class DbBasicRate {
    @Id
    lateinit var identifier: String
    lateinit var validFrom: LocalDate
    var validTo: LocalDate? = null
    @Column(columnDefinition = "CHAR(3)")
    lateinit var currencyCode: CurrencyCode
    @Column(precision = RATE_PRECISION, scale = RATE_SCALE)
    var bidRate: BigDecimal? = null
    // ...
}

// persistency
internal object DbBasicRateAdapter {

    fun toDbBasicRate(basicRate: BasicRate) =
        DbBasicRate().apply {
            identifier = basicRate.identifier
            createdBy = basicRate.lifeSpan.createdBy
            createdAt = basicRate.lifeSpan.createdAt
            terminatedAt = basicRate.lifeSpan.terminatedAt
            validFrom = basicRate.validity.validFrom
            validTo = basicRate.validity.validTo
            currencyCode = basicRate.currencyCode
            rateType = basicRate.rateType
            // ...
        }

    fun toBasicRate(dbBasicRate: DbBasicRate) =
        BasicRate().apply {
            identifier = dbBasicRate.identifier
            lifeSpan.createdBy = dbBasicRate.createdBy
            lifeSpan.createdAt = dbBasicRate.createdAt
            lifeSpan.terminatedAt = dbBasicRate.terminatedAt
            validity.validFrom = dbBasicRate.validFrom
            validity.validTo = dbBasicRate.validTo
            currencyCode = dbBasicRate.currencyCode
            // ...
        }
}

internal class DbContainer private constructor() :
    MSSQLServerContainer<DbContainer>("mcr.microsoft.com/mssql/server:latest") {

    companion object {
        val singleton by lazy { DbContainer() }
    }

    override fun start() {
        acceptLicense()
        // Start the Docker container.
        super.start()
        // Create database 'NCP' and then update schema 'CPCM' using Liquibase.
        createDatabase(jdbcUrl, username, password) // DbContainer.username = "sa"
        updateSchema(jdbcUrl, DBO_USER, DBO_PASSWORD, "UNIT_TEST")
    }
}

// This extension must be triggered BEFORE any extension that requires database access.
private class StartTestcontainersBeforeAll : BeforeAllCallback {

    override fun beforeAll(extensionContext: ExtensionContext) {
        // Start the database in a Docker container if it is not already running.
        if (!DatabaseContainer.singleton.isRunning) {
            DatabaseContainer.singleton.start()
        }
    }
}

@SpringBootTest(classes = [CPCMApplication::class])
@TestPropertySource("classpath:application-test.properties")
@ExtendWith(StartTestcontainersBeforeAll::class)
interface AbstractTestcontainersIT {

    companion object {
        @DynamicPropertySource
        @JvmStatic
        fun applyContainerPropertiesToSpring(registry: DynamicPropertyRegistry) {
            registry.add("spring.datasource.url") { DatabaseContainer.singleton.jdbcUrl }
            registry.add("spring.datasource.username") { DB_USER }
            registry.add("spring.datasource.password") { DB_PASSWORD }
        }
    }
}