package space.luminic.finance.repos

import org.springframework.jdbc.core.RowMapper
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate
import org.springframework.stereotype.Repository
import space.luminic.finance.models.User

@Repository
class UserRepoImpl(
    private val jdbcTemplate: NamedParameterJdbcTemplate
) : UserRepo {

    private fun userRowMapper() = RowMapper { rs, _ ->
        User(
            id = rs.getInt("id"),
            username = rs.getString("username"),
            firstName = rs.getString("first_name"),
            tgId = rs.getLong("tg_id"),
            tgUserName = rs.getString("tg_user_name"),
            photoUrl = rs.getString("photo_url"),
            password = rs.getString("password"),
            isActive = rs.getBoolean("is_active"),
            regDate = rs.getDate("reg_date").toLocalDate(),
            createdAt = rs.getTimestamp("created_at").toInstant(),
            updatedAt = rs.getTimestamp("updated_at").toInstant(),
            roles = (rs.getArray("roles")?.array as? Array<String>)?.toList() ?: emptyList()
        )
    }

    override fun findAll(): List<User> {
        val sql = "select * from finance.users order by created_at desc"
        return jdbcTemplate.query(sql, userRowMapper())
    }

    override fun findById(id: Int): User? {
        val sql = "select * from finance.users where id = :userId"
        return jdbcTemplate.queryForObject(sql, mapOf("userId" to id), userRowMapper())
    }

    override fun findByUsername(username: String): User? {
        val sql = "select * from finance.users where username = :username"
        return jdbcTemplate.query(sql, mapOf("username" to username), userRowMapper()).firstOrNull()
    }

    override fun findParticipantsBySpace(spaceId: Int): Set<User> {
        val sql =
            "select * from finance.users u join finance.spaces_participants sp on sp.participants_id = u.id where sp.space_id = :spaceId"
        return jdbcTemplate.query(sql, mapOf("spaceId" to spaceId), userRowMapper()).toSet()
    }

    override fun findByTgId(tgId: Long): User? {
        val sql = """
            select * from finance.users u where tg_id = :tgId
        """.trimIndent()
        val params = mapOf("tgId" to tgId)
        return jdbcTemplate.query(sql, params, userRowMapper()).firstOrNull()
    }

    override fun create(user: User): User {
        val sql =
            "insert into finance.users(username, first_name, tg_id, tg_user_name, photo_url, password, is_active, reg_date) values (:username, :firstname, :tg_id, :tg_user_name, :photo_url, :password, :isActive, :regDate) returning ID"
        val params = mapOf(
            "username" to user.username,
            "firstname" to user.firstName,
            "tg_id" to user.tgId,
            "tg_user_name" to user.tgUserName,
            "photo_url" to user.photoUrl,
            "password" to user.password,
            "isActive" to user.isActive,
            "regDate" to user.regDate,
        )
        val savedId = jdbcTemplate.queryForObject(sql, params, Int::class.java)
        user.id = savedId
        return user
    }

    override fun update(user: User): User {
        TODO("Not yet implemented")
    }

    override fun deleteById(id: Long) {
        val sql = "update finance.users set is_active = false where id = :id"
        jdbcTemplate.update(sql, mapOf("id" to id))
    }
}