package com.keylesspalace.tusky.components.timeline

import android.text.SpannedString
import androidx.core.text.parseAsHtml
import androidx.core.text.toHtml
import com.google.gson.Gson
import com.google.gson.reflect.TypeToken
import com.keylesspalace.tusky.components.timeline.TimelineRequestMode.DISK
import com.keylesspalace.tusky.components.timeline.TimelineRequestMode.NETWORK
import com.keylesspalace.tusky.db.AccountManager
import com.keylesspalace.tusky.db.TimelineAccountEntity
import com.keylesspalace.tusky.db.TimelineDao
import com.keylesspalace.tusky.db.TimelineStatusEntity
import com.keylesspalace.tusky.db.TimelineStatusWithAccount
import com.keylesspalace.tusky.entity.Account
import com.keylesspalace.tusky.entity.Attachment
import com.keylesspalace.tusky.entity.Emoji
import com.keylesspalace.tusky.entity.Poll
import com.keylesspalace.tusky.entity.Status
import com.keylesspalace.tusky.network.MastodonApi
import com.keylesspalace.tusky.util.Either
import com.keylesspalace.tusky.util.dec
import com.keylesspalace.tusky.util.inc
import com.keylesspalace.tusky.util.trimTrailingWhitespace
import io.reactivex.rxjava3.core.Single
import io.reactivex.rxjava3.schedulers.Schedulers
import java.io.IOException
import java.util.Date
import java.util.concurrent.TimeUnit

data class Placeholder(val id: String)

typealias TimelineStatus = Either<Placeholder, Status>

enum class TimelineRequestMode {
    DISK, NETWORK, ANY
}

interface TimelineRepository {
    fun getStatuses(
        maxId: String?,
        sinceId: String?,
        sincedIdMinusOne: String?,
        limit: Int,
        requestMode: TimelineRequestMode
    ): Single<out List<TimelineStatus>>

    companion object {
        val CLEANUP_INTERVAL = TimeUnit.DAYS.toMillis(14)
    }
}

class TimelineRepositoryImpl(
    private val timelineDao: TimelineDao,
    private val mastodonApi: MastodonApi,
    private val accountManager: AccountManager,
    private val gson: Gson
) : TimelineRepository {

    init {
        this.cleanup()
    }

    override fun getStatuses(
        maxId: String?,
        sinceId: String?,
        sincedIdMinusOne: String?,
        limit: Int,
        requestMode: TimelineRequestMode
    ): Single<out List<TimelineStatus>> {
        val acc = accountManager.activeAccount ?: throw IllegalStateException()
        val accountId = acc.id

        return if (requestMode == DISK) {
            this.getStatusesFromDb(accountId, maxId, sinceId, limit)
        } else {
            getStatusesFromNetwork(maxId, sinceId, sincedIdMinusOne, limit, accountId, requestMode)
        }
    }

    private fun getStatusesFromNetwork(
        maxId: String?,
        sinceId: String?,
        sinceIdMinusOne: String?,
        limit: Int,
        accountId: Long,
        requestMode: TimelineRequestMode
    ): Single<out List<TimelineStatus>> {
        return mastodonApi.homeTimeline(maxId, sinceIdMinusOne, limit + 1)
            .map { response ->
                this.saveStatusesToDb(accountId, response.body().orEmpty(), maxId, sinceId)
            }
            .flatMap { statuses ->
                this.addFromDbIfNeeded(accountId, statuses, maxId, sinceId, limit, requestMode)
            }
            .onErrorResumeNext { error ->
                if (error is IOException && requestMode != NETWORK) {
                    this.getStatusesFromDb(accountId, maxId, sinceId, limit)
                } else {
                    Single.error(error)
                }
            }
    }

    private fun addFromDbIfNeeded(
        accountId: Long,
        statuses: List<Either<Placeholder, Status>>,
        maxId: String?,
        sinceId: String?,
        limit: Int,
        requestMode: TimelineRequestMode
    ): Single<List<TimelineStatus>> {
        return if (requestMode != NETWORK && statuses.size < 2) {
            val newMaxID = if (statuses.isEmpty()) {
                maxId
            } else {
                statuses.last { it.isRight() }.asRight().id
            }
            this.getStatusesFromDb(accountId, newMaxID, sinceId, limit)
                .map { fromDb ->
                    // If it's just placeholders and less than limit (so we exhausted both
                    // db and server at this point)
                    if (fromDb.size < limit && fromDb.all { !it.isRight() }) {
                        statuses
                    } else {
                        statuses + fromDb
                    }
                }
        } else {
            Single.just(statuses)
        }
    }

    private fun getStatusesFromDb(
        accountId: Long,
        maxId: String?,
        sinceId: String?,
        limit: Int
    ): Single<out List<TimelineStatus>> {
        return timelineDao.getStatusesForAccount(accountId, maxId, sinceId, limit)
            .subscribeOn(Schedulers.io())
            .map { statuses ->
                statuses.map { it.toStatus() }
            }
    }

    private fun saveStatusesToDb(
        accountId: Long,
        statuses: List<Status>,
        maxId: String?,
        sinceId: String?
    ): List<Either<Placeholder, Status>> {
        var placeholderToInsert: Placeholder? = null

        // Look for overlap
        val resultStatuses = if (statuses.isNotEmpty() && sinceId != null) {
            val indexOfSince = statuses.indexOfLast { it.id == sinceId }
            if (indexOfSince == -1) {
                // We didn't find the status which must be there. Add a placeholder
                placeholderToInsert = Placeholder(sinceId.inc())
                statuses.mapTo(mutableListOf(), Status::lift)
                    .apply {
                        add(Either.Left(placeholderToInsert))
                    }
            } else {
                // There was an overlap. Remove all overlapped statuses. No need for a placeholder.
                statuses.mapTo(mutableListOf(), Status::lift)
                    .apply {
                        subList(indexOfSince, size).clear()
                    }
            }
        } else {
            // Just a normal case.
            statuses.map(Status::lift)
        }

        Single.fromCallable {

            if (statuses.isNotEmpty()) {
                timelineDao.deleteRange(accountId, statuses.last().id, statuses.first().id)
            }

            for (status in statuses) {
                timelineDao.insertInTransaction(
                    status.toEntity(accountId, gson),
                    status.account.toEntity(accountId, gson),
                    status.reblog?.account?.toEntity(accountId, gson)
                )
            }

            placeholderToInsert?.let {
                timelineDao.insertStatusIfNotThere(placeholderToInsert.toEntity(accountId))
            }

            // If we're loading in the bottom insert placeholder after every load
            // (for requests on next launches) but not return it.
            if (sinceId == null && statuses.isNotEmpty()) {
                timelineDao.insertStatusIfNotThere(
                    Placeholder(statuses.last().id.dec()).toEntity(accountId)
                )
            }

            // There may be placeholders which we thought could be from our TL but they are not
            if (statuses.size > 2) {
                timelineDao.removeAllPlaceholdersBetween(
                    accountId, statuses.first().id,
                    statuses.last().id
                )
            } else if (placeholderToInsert == null && maxId != null && sinceId != null) {
                timelineDao.removeAllPlaceholdersBetween(accountId, maxId, sinceId)
            }
        }
            .subscribeOn(Schedulers.io())
            .subscribe()

        return resultStatuses
    }

    private fun cleanup() {
        Schedulers.io().scheduleDirect {
            val olderThan = System.currentTimeMillis() - TimelineRepository.CLEANUP_INTERVAL
            timelineDao.cleanup(olderThan)
        }
    }

    private fun TimelineStatusWithAccount.toStatus(): TimelineStatus {
        if (this.status.authorServerId == null) {
            return Either.Left(Placeholder(this.status.serverId))
        }

        val attachments: ArrayList<Attachment> = gson.fromJson(
            status.attachments,
            object : TypeToken<List<Attachment>>() {}.type
        ) ?: ArrayList()
        val mentions: List<Status.Mention> = gson.fromJson(
            status.mentions,
            object : TypeToken<List<Status.Mention>>() {}.type
        ) ?: listOf()
        val application = gson.fromJson(status.application, Status.Application::class.java)
        val emojis: List<Emoji> = gson.fromJson(
            status.emojis,
            object : TypeToken<List<Emoji>>() {}.type
        ) ?: listOf()
        val poll: Poll? = gson.fromJson(status.poll, Poll::class.java)

        val reblog = status.reblogServerId?.let { id ->
            Status(
                id = id,
                url = status.url,
                account = account.toAccount(gson),
                inReplyToId = status.inReplyToId,
                inReplyToAccountId = status.inReplyToAccountId,
                reblog = null,
                content = status.content?.parseAsHtml()?.trimTrailingWhitespace()
                    ?: SpannedString(""),
                createdAt = Date(status.createdAt),
                emojis = emojis,
                reblogsCount = status.reblogsCount,
                favouritesCount = status.favouritesCount,
                reblogged = status.reblogged,
                favourited = status.favourited,
                bookmarked = status.bookmarked,
                sensitive = status.sensitive,
                spoilerText = status.spoilerText!!,
                visibility = status.visibility!!,
                attachments = attachments,
                mentions = mentions,
                application = application,
                pinned = false,
                muted = status.muted,
                poll = poll,
                card = null
            )
        }
        val status = if (reblog != null) {
            Status(
                id = status.serverId,
                url = null, // no url for reblogs
                account = this.reblogAccount!!.toAccount(gson),
                inReplyToId = null,
                inReplyToAccountId = null,
                reblog = reblog,
                content = SpannedString(""),
                createdAt = Date(status.createdAt), // lie but whatever?
                emojis = listOf(),
                reblogsCount = 0,
                favouritesCount = 0,
                reblogged = false,
                favourited = false,
                bookmarked = false,
                sensitive = false,
                spoilerText = "",
                visibility = status.visibility!!,
                attachments = ArrayList(),
                mentions = listOf(),
                application = null,
                pinned = false,
                muted = status.muted,
                poll = null,
                card = null
            )
        } else {
            Status(
                id = status.serverId,
                url = status.url,
                account = account.toAccount(gson),
                inReplyToId = status.inReplyToId,
                inReplyToAccountId = status.inReplyToAccountId,
                reblog = null,
                content = status.content?.parseAsHtml()?.trimTrailingWhitespace()
                    ?: SpannedString(""),
                createdAt = Date(status.createdAt),
                emojis = emojis,
                reblogsCount = status.reblogsCount,
                favouritesCount = status.favouritesCount,
                reblogged = status.reblogged,
                favourited = status.favourited,
                bookmarked = status.bookmarked,
                sensitive = status.sensitive,
                spoilerText = status.spoilerText!!,
                visibility = status.visibility!!,
                attachments = attachments,
                mentions = mentions,
                application = application,
                pinned = false,
                muted = status.muted,
                poll = poll,
                card = null
            )
        }
        return Either.Right(status)
    }
}

private val emojisListTypeToken = object : TypeToken<List<Emoji>>() {}

fun Account.toEntity(accountId: Long, gson: Gson): TimelineAccountEntity {
    return TimelineAccountEntity(
        serverId = id,
        timelineUserId = accountId,
        localUsername = localUsername,
        username = username,
        displayName = name,
        url = url,
        avatar = avatar,
        emojis = gson.toJson(emojis),
        bot = bot
    )
}

fun TimelineAccountEntity.toAccount(gson: Gson): Account {
    return Account(
        id = serverId,
        localUsername = localUsername,
        username = username,
        displayName = displayName,
        note = SpannedString(""),
        url = url,
        avatar = avatar,
        header = "",
        locked = false,
        followingCount = 0,
        followersCount = 0,
        statusesCount = 0,
        source = null,
        bot = bot,
        emojis = gson.fromJson(this.emojis, emojisListTypeToken.type),
        fields = null,
        moved = null
    )
}

fun Placeholder.toEntity(timelineUserId: Long): TimelineStatusEntity {
    return TimelineStatusEntity(
        serverId = this.id,
        url = null,
        timelineUserId = timelineUserId,
        authorServerId = null,
        inReplyToId = null,
        inReplyToAccountId = null,
        content = null,
        createdAt = 0L,
        emojis = null,
        reblogsCount = 0,
        favouritesCount = 0,
        reblogged = false,
        favourited = false,
        bookmarked = false,
        sensitive = false,
        spoilerText = null,
        visibility = null,
        attachments = null,
        mentions = null,
        application = null,
        reblogServerId = null,
        reblogAccountId = null,
        poll = null,
        muted = false
    )
}

fun Status.toEntity(
    timelineUserId: Long,
    gson: Gson
): TimelineStatusEntity {
    val actionable = actionableStatus
    return TimelineStatusEntity(
        serverId = this.id,
        url = actionable.url!!,
        timelineUserId = timelineUserId,
        authorServerId = actionable.account.id,
        inReplyToId = actionable.inReplyToId,
        inReplyToAccountId = actionable.inReplyToAccountId,
        content = actionable.content.toHtml(),
        createdAt = actionable.createdAt.time,
        emojis = actionable.emojis.let(gson::toJson),
        reblogsCount = actionable.reblogsCount,
        favouritesCount = actionable.favouritesCount,
        reblogged = actionable.reblogged,
        favourited = actionable.favourited,
        bookmarked = actionable.bookmarked,
        sensitive = actionable.sensitive,
        spoilerText = actionable.spoilerText,
        visibility = actionable.visibility,
        attachments = actionable.attachments.let(gson::toJson),
        mentions = actionable.mentions.let(gson::toJson),
        application = actionable.application.let(gson::toJson),
        reblogServerId = reblog?.id,
        reblogAccountId = reblog?.let { this.account.id },
        poll = actionable.poll.let(gson::toJson),
        muted = actionable.muted
    )
}

fun Status.lift(): Either<Placeholder, Status> = Either.Right(this)