core/postssystem.core.exposed/src/main/kotlin/com/insanusmokrassar/postssystem/core/exposed/ExposedPostsRepo.kt

package com.insanusmokrassar.postssystem.core.exposed

import com.insanusmokrassar.postssystem.core.content.ContentId
import com.insanusmokrassar.postssystem.core.generatePostId
import com.insanusmokrassar.postssystem.core.post.*
import com.insanusmokrassar.postssystem.core.post.repo.PostsRepo
import com.insanusmokrassar.postssystem.utils.repos.pagination.*
import com.insanusmokrassar.postssystem.exposed.commons.paginate
import com.soywiz.klock.*
import kotlinx.coroutines.channels.BroadcastChannel
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.asFlow
import org.jetbrains.exposed.sql.*
import org.jetbrains.exposed.sql.transactions.experimental.newSuspendedTransaction
import org.jetbrains.exposed.sql.transactions.transaction

private class PostsRepoContentRelations(
    private val database: Database
) : Table() {
    private val postIdColumn = text("postId")
    private val contentIdColumn = text("contentId")

    init {
        transaction (
            db = database
        ) {
            SchemaUtils.createMissingTablesAndColumns(this@PostsRepoContentRelations)
        }
    }

    suspend fun getPostContents(postId: PostId): List<ContentId> {
        return newSuspendedTransaction(
            db = database
        ) {
            select { postIdColumn.eq(postId) }.map { it[contentIdColumn] }
        }
    }

    suspend fun getContentPosts(contentId: ContentId): List<PostId> {
        return newSuspendedTransaction(
            db = database
        ) {
            select { contentIdColumn.eq(contentId) }.map { it[postIdColumn] }
        }
    }

    suspend fun linkPostAndContents(postId: PostId, vararg contentIds: ContentId) {
        newSuspendedTransaction(
            db = database
        ) {
            val leftToPut = contentIds.toSet() - getPostContents(postId)
            leftToPut.forEach { contentId ->
                insert {
                    it[postIdColumn] = postId
                    it[contentIdColumn] = contentId
                }
            }
        }
    }
    suspend fun unlinkPostAndContents(postId: PostId, vararg contentIds: ContentId): Boolean {
        return newSuspendedTransaction(
            db = database
        ) {
            deleteWhere {
                postIdColumn.eq(postId).and(contentIdColumn.inList(contentIds.toList()))
            } > 0
        }
    }
}

private val dateTimeFormat = DateFormat("EEE, dd MMM yyyy HH:mm:ss z")

private class PostsRepoDatabaseTable(
    private val database: Database
) : PostsRepo, Table() {
    private val contentsTable = PostsRepoContentRelations(database)

    private val idColumn = text("postId")
    private val creationDateColumn = text("creationDate").default(
        DateTime.now().toString(dateTimeFormat)
    )


    private val postCreatedBroadcastChannel = BroadcastChannel<RegisteredPost>(Channel.BUFFERED)
    override val postCreatedFlow: Flow<RegisteredPost> = postCreatedBroadcastChannel.asFlow()

    private val postDeletedBroadcastChannel = BroadcastChannel<RegisteredPost>(Channel.BUFFERED)
    override val postDeletedFlow: Flow<RegisteredPost> = postDeletedBroadcastChannel.asFlow()

    private val postUpdatedBroadcastChannel = BroadcastChannel<RegisteredPost>(Channel.BUFFERED)
    override val postUpdatedFlow: Flow<RegisteredPost> = postUpdatedBroadcastChannel.asFlow()

    init {
        transaction (
            db = database
        ) {
            SchemaUtils.createMissingTablesAndColumns(this@PostsRepoDatabaseTable)
        }
    }

    private suspend fun ResultRow.toRegisteredPost(): RegisteredPost = get(idColumn).let { id ->
        SimpleRegisteredPost(
            id,
            contentsTable.getPostContents(id),
            dateTimeFormat.parse(get(creationDateColumn)).local
        )
    }

    override suspend fun createPost(post: Post): RegisteredPost? {
        val id = generatePostId()
        return newSuspendedTransaction(
            db = database
        ) {
            insert {
                it[idColumn] = id
            }
            contentsTable.linkPostAndContents(id, *post.content.toTypedArray())
            select { idColumn.eq(id) }.firstOrNull() ?.toRegisteredPost()
        } ?.also {
            postCreatedBroadcastChannel.send(it)
        }
    }

    override suspend fun deletePost(id: PostId): Boolean {
        val post = getPostById(id) ?: return false
        return (newSuspendedTransaction(
            db = database
        ) {
            deleteWhere { idColumn.eq(id) }
        } > 0).also {
            if (it) {
                postDeletedBroadcastChannel.send(post)
                contentsTable.unlinkPostAndContents(id, *post.content.toTypedArray())
            }
        }
    }

    override suspend fun updatePostContent(postId: PostId, post: Post): Boolean {
        return newSuspendedTransaction(
            db = database
        ) {
            val alreadyLinked = contentsTable.getPostContents(postId)
            val toRemove = alreadyLinked - post.content
            val toInsert = post.content - alreadyLinked
            val updated = (toRemove.isNotEmpty() && contentsTable.unlinkPostAndContents(postId, *toRemove.toTypedArray())) || toInsert.isNotEmpty()
            if (toInsert.isNotEmpty()) {
                contentsTable.linkPostAndContents(postId, *toInsert.toTypedArray())
            }
            updated
        }.also {
            if (it) {
                getPostById(postId) ?.also { updatedPost -> postUpdatedBroadcastChannel.send(updatedPost) }
            }
        }
    }
    override suspend fun getPostsIds(): Set<PostId> {
        return newSuspendedTransaction(
            db = database
        ) {
            selectAll().map { it[idColumn] }.toSet()
        }
    }

    override suspend fun getPostById(id: PostId): RegisteredPost? {
        return newSuspendedTransaction(
            db = database
        ) {
            select { idColumn.eq(id) }.firstOrNull() ?.toRegisteredPost()
        }
    }

    override suspend fun getPostsByContent(id: ContentId): List<RegisteredPost> {
        return newSuspendedTransaction(
            db = database
        ) {
            val postsIds = contentsTable.getContentPosts(id)
            select { idColumn.inList(postsIds) }.map { it.toRegisteredPost() }
        }
    }

    override suspend fun getPostsByCreatingDates(from: DateTime, to: DateTime): List<RegisteredPost> {
        return newSuspendedTransaction(
            db = database
        ) {
            select { creationDateColumn.between(from, to) }.map { it.toRegisteredPost() }
        }
    }

    override suspend fun getPostsByPagination(pagination: Pagination): PaginationResult<RegisteredPost> {
        return newSuspendedTransaction(
            db = database
        ) {
            val posts = selectAll().paginate(pagination).orderBy(creationDateColumn).map {
                it.toRegisteredPost()
            }
            val postsNumber = selectAll().count()
            posts.createPaginationResult(pagination, postsNumber)
        }
    }

}

class ExposedPostsRepo (
    database: Database
) : PostsRepo by PostsRepoDatabaseTable(database)