package at.mocode.masterdata.service.config

import at.mocode.core.utils.database.DatabaseConfig
import at.mocode.core.utils.database.DatabaseFactory
import at.mocode.masterdata.infrastructure.persistence.LandTable
import at.mocode.masterdata.infrastructure.persistence.BundeslandTable
import at.mocode.masterdata.infrastructure.persistence.AltersklasseTable
import at.mocode.masterdata.infrastructure.persistence.PlatzTable
import org.springframework.context.annotation.Configuration
import org.springframework.context.annotation.Profile
import jakarta.annotation.PostConstruct
import jakarta.annotation.PreDestroy
import org.slf4j.LoggerFactory
import org.jetbrains.exposed.sql.SchemaUtils
import org.jetbrains.exposed.sql.transactions.transaction

/**
 * Database configuration for the Masterdata Service.
 *
 * This configuration ensures that Database.connect() is called properly
 * before any Exposed operations are performed.
 */
@Configuration
@Profile("!test")
class MasterdataDatabaseConfiguration {

    private val log = LoggerFactory.getLogger(MasterdataDatabaseConfiguration::class.java)

    @PostConstruct
    fun initializeDatabase() {
        log.info("Initializing database schema for Masterdata Service...")

        try {
            // Database connection is already initialized by the gateway
            // Only initialize the schema for this service
            transaction {
                SchemaUtils.createMissingTablesAndColumns(
                    LandTable,
                    BundeslandTable,
                    AltersklasseTable,
                    PlatzTable
                )
                log.info("Masterdata database schema initialized successfully")
            }
        } catch (e: Exception) {
            log.error("Failed to initialize database schema", e)
            throw e
        }
    }

    @PreDestroy
    fun closeDatabase() {
        log.info("Closing database connection for Masterdata Service...")
        try {
            DatabaseFactory.close()
            log.info("Database connection closed successfully")
        } catch (e: Exception) {
            log.error("Error closing database connection", e)
        }
    }
}

/**
 * Test-specific database configuration.
 */
@Configuration
@Profile("test")
class MasterdataTestDatabaseConfiguration {

    private val log = LoggerFactory.getLogger(MasterdataTestDatabaseConfiguration::class.java)

    @PostConstruct
    fun initializeTestDatabase() {
        log.info("Initializing test database connection for Masterdata Service...")

        try {
            // Use H2 in-memory database for tests
            val testConfig = DatabaseConfig(
                jdbcUrl = "jdbc:h2:mem:masterdata_test;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE",
                username = "sa",
                password = "",
                driverClassName = "org.h2.Driver",
                maxPoolSize = 5,
                minPoolSize = 1,
                autoMigrate = true
            )

            DatabaseFactory.init(testConfig)
            log.info("Test database connection initialized successfully")

            // Initialize database schema for tests
            transaction {
                SchemaUtils.createMissingTablesAndColumns(
                    LandTable,
                    BundeslandTable,
                    AltersklasseTable,
                    PlatzTable
                )
                log.info("Test masterdata database schema initialized successfully")
            }
        } catch (e: Exception) {
            log.error("Failed to initialize test database connection", e)
            throw e
        }
    }

    @PreDestroy
    fun closeTestDatabase() {
        log.info("Closing test database connection for Masterdata Service...")
        try {
            DatabaseFactory.close()
            log.info("Test database connection closed successfully")
        } catch (e: Exception) {
            log.error("Error closing test database connection", e)
        }
    }
}
