path: root/app/src/main/java/net/lacolaco/smileessence/World.kt

package net.lacolaco.smileessence

import android.content.ContentValues
import android.content.Intent
import android.graphics.Bitmap
import android.graphics.drawable.Drawable
import androidx.annotation.StringRes
import com.google.android.material.snackbar.Snackbar
import android.view.View
import com.beust.klaxon.JsonArray
import com.beust.klaxon.JsonObject
import com.beust.klaxon.Parser
import com.beust.klaxon.json
import com.bumptech.glide.Glide
import com.bumptech.glide.request.Request
import com.bumptech.glide.request.RequestOptions
import com.bumptech.glide.request.target.SizeReadyCallback
import com.bumptech.glide.request.target.Target
import com.bumptech.glide.request.transition.Transition
import net.lacolaco.smileessence.activity.MainActivity
import net.lacolaco.smileessence.data.PageInfo
import net.lacolaco.smileessence.entity.Event
import net.lacolaco.smileessence.entity.SavedSearch
import net.lacolaco.smileessence.entity.Tweet
import net.lacolaco.smileessence.entity.User
import net.lacolaco.smileessence.twitter.*
import net.lacolaco.smileessence.util.launchBg
import net.lacolaco.smileessence.util.launchUi
import twitter4j.Twitter
import twitter4j.TwitterFactory
import twitter4j.auth.AccessToken
import twitter4j.conf.ConfigurationBuilder
import java.lang.ref.WeakReference
import java.util.*
import kotlin.coroutines.*

/**
 * World contains data that are specific to a profile.
 */
class World private constructor(private val persistentData: PersistentData) {
    val id = persistentData.id
    val user: User = User.makeSkeletonForInternalUseOnly(id, persistentData.screenName,
            persistentData.profileImageUrl)
    // XXX: Workaround for a bug in Android
    var mainActivityIntent: Intent? = null
    // Timelines
    private val tweets = HashMap<Long, Tweet>()
    private val tweetNotifiers = WeakHashMap<Any, (Tweet) -> Unit>()
    // Events
    private val events = ArrayList<Event>()
    private val eventNotifiers = WeakHashMap<Any, (Event) -> Unit>()
    // Streaming
    private lateinit var stream: PoePoeStreaming
    // Lists
    val listSubscriptions = HashSet<String>()
    // Mute
    private val muteUserIds = HashSet<Long>()
    // Saved searches
    val savedSearches = HashMap<Long, SavedSearch>()
    // Notification
    private var mainActivity: WeakReference<MainActivity>? = null
    private var isMainActivityActive: Boolean = false
    // Pages
    val pages = persistentData.pageInfos

    // Startup

    private var initialized = false
    fun setup() {
        if (initialized)
            return
        initialized = true

        launchBg {
            try {
                listSubscriptions += getUserListsAsync().await()
            } catch (e: TwitterTaskException) {
            }
        }
        launchBg {
            try {
                val blockIds = getBlocksIdsAsync()
                val muteIds = getMutesIdsAsync()
                muteUserIds += blockIds.await()
                muteUserIds += muteIds.await()
            } catch (e: TwitterTaskException) {
            }
        }
        launchBg {
            try {
                val ssl = getSavedSearchesAsync().await()
                savedSearches.clear()
                for (ss in ssl)
                    savedSearches[ss.id] = ss
            } catch (e: TwitterTaskException) {
            }
        }
        launchBg {
            try {
                val jobs = listOf(getHomeTimelineAsync(), getMentionsTimelineAsync())
                jobs.forEach { addTweetAll(it.await()) }
            } catch (e: TwitterTaskException) {
                notifyError(R.string.notice_error_get_home)
            }
        }

        stream = PoePoeStreaming(this)
        stream.start()
    }

    fun refreshStream() {
        stream.stop()
        stream.start()
    }

    private var refreshUserCallback: (() -> Unit)? = null
    fun refreshUser(callback: () -> Unit) {
        synchronized(this) {
            if (refreshUserCallback == null) {
                refreshUserCallback = callback
            } else {
                val orig = refreshUserCallback!!
                refreshUserCallback = { orig(); callback() }
            }
        }

        launchBg {
            try {
                getUserAsync(id).await()
            } catch (e: TwitterTaskException) {
            }
            synchronized(this@World) {
                refreshUserCallback.also { refreshUserCallback = null }
            }!!()
        }
    }

    suspend fun getProfileImageBitmap(size: Int) = suspendCoroutine<Bitmap> { cont ->
        Glide.with(Application.instance)
                .asBitmap()
                .load(user.profileImageUrl)
                .apply(RequestOptions().fitCenter().override(size, size))
                .into(object : Target<Bitmap> {
                    private var req: Request? = null

                    override fun onLoadStarted(placeholder: Drawable?) {
                    }

                    override fun getSize(cb: SizeReadyCallback) {
                    }

                    override fun getRequest(): Request? {
                        return req
                    }

                    override fun onStop() {
                    }

                    override fun setRequest(request: Request?) {
                        req = request
                    }

                    override fun removeCallback(cb: SizeReadyCallback) {
                        cb.onSizeReady(Target.SIZE_ORIGINAL, Target.SIZE_ORIGINAL)
                    }

                    override fun onLoadCleared(placeholder: Drawable?) {
                    }

                    override fun onStart() {
                    }

                    override fun onDestroy() {
                    }

                    override fun onResourceReady(resource: Bitmap, tran: Transition<in Bitmap>?) {
                        cont.resume(resource)
                    }

                    override fun onLoadFailed(errorDrawable: Drawable?) {
                        cont.resumeWithException(
                                RuntimeException("Profile image could not be loaded"))
                    }
                })
    }


    fun checkpoint() = launchBg {
        persistentData.screenName = user.screenName
        persistentData.profileImageUrl = user.profileImageUrl
        persistentData.save()
    }

    var twitterEventStreamEndpoint
        get() = persistentData.twitterEventStreamEndpoint
        set(value) {
            persistentData.twitterEventStreamEndpoint = value
        }

    var useDarkTheme
        get() = persistentData.themeIndex == 0
        set(value) {
            persistentData.themeIndex = if (value) 0 else 1
        }

    var themeColor
        get() = persistentData.themeColor
        set(value) {
            persistentData.themeColor = value
        }

    val twitter: Twitter
        get() {
            val cb = ConfigurationBuilder()
            cb.setTweetModeExtended(true)
            val twitter = TwitterFactory(cb.build()).instance
            twitter.oAuthAccessToken = AccessToken(
                    persistentData.oauthToken, persistentData.oauthTokenSecret)
            return twitter
        }

    // MainActivity holder

    fun setMainActivity(activity: MainActivity) {
        mainActivity = WeakReference(activity)
    }

    fun getMainActivity(): MainActivity? = mainActivity?.get()

    fun setMainActivityActive(yes: Boolean) {
        isMainActivityActive = yes
    }

    // Timelines

    @Synchronized
    fun addTimeline(key: Any, callback: (Tweet) -> Unit) {
        for ((_, item) in tweets)
            callback(item)
        tweetNotifiers[key] = callback
    }

    @Synchronized
    fun addTweet(item: Tweet) {
        tweets[item.id] = item
        for ((_, callback) in tweetNotifiers)
            callback(item)
    }

    @Synchronized
    fun addTweetAll(collection: Collection<Tweet>) {
        for (item in collection) {
            tweets[item.id] = item
            for ((_, callback) in tweetNotifiers)
                callback(item)
        }
    }

    // Events

    @Synchronized
    fun addEventNotifier(key: Any, notify: (Event) -> Unit) {
        for (item in events)
            notify(item)
        eventNotifiers[key] = notify
    }

    private fun addEvent(item: Event) {
        events.add(item)
        for ((_, callback) in eventNotifiers)
            callback(item)
    }

    // Streaming APIs

    val isStreaming: Boolean
        get() = stream.connected

    // Notifications

    fun notify(text: String) {
        notify(Event.SimpleEvent("INFO", text))
    }

    fun notify(@StringRes resId: Int, vararg formatArgs: Any) {
        notify(Application.instance.getString(resId, *formatArgs))
    }

    fun notifyError(text: String) {
        notify(Event.SimpleEvent("ALERT", text))
    }

    fun notifyError(@StringRes resId: Int, vararg formatArgs: Any) {
        notifyError(Application.instance.getString(resId, *formatArgs))
    }

    fun notify(event: Event) {
        launchUi {
            if (isMainActivityActive) {
                val view: View = mainActivity!!.get()!!.findViewById(android.R.id.content)
                Logger.debug("notify(snackbar): ${event.summary}")
                Snackbar.make(view, event.summary, Snackbar.LENGTH_SHORT).show()
            } else {
                Logger.debug(String.format("notify(toast): %s", event.summary))
                Application.toast(event.summary)
            }
            addEvent(event)
        }
    }

    companion object {
        private val cache = LinkedHashMap<Long, World>()

        operator fun get(i: Long) =
                cache[i] ?: throw IllegalStateException("[BUG] World with id == $i not found")

        fun all() = ArrayList(cache.values)

        fun load() {
            if (cache.isNotEmpty())
                throw IllegalStateException("World.load called twice")
            PersistentData.fetchAll().forEach { cache[it.id] = World(it) }
            Logger.info("Loaded ${cache.size} profiles")
        }

        fun register(token: String, tokenSecret: String, userId: Long, screenName: String): World {
            val world = cache[userId]
                    ?: World(PersistentData(userId, token, tokenSecret, screenName))
            world.persistentData.oauthToken = token
            world.persistentData.oauthTokenSecret = tokenSecret
            world.persistentData.screenName = screenName
            world.persistentData.save()
            cache[userId] = world
            return world
        }
    }

    private class PersistentData(
            val id: Long,
            var oauthToken: String,
            var oauthTokenSecret: String,
            var screenName: String,
            var profileImageUrl: String = User.DEFAULT_PROFILE_IMAGE_URL,
            var pageInfos: MutableList<PageInfo> = makeDefaultPageInfos(screenName),
            var themeIndex: Int = 0,
            var themeColor: Int = 0,
            var twitterEventStreamEndpoint: String = "https://userstream.herokuapp.com/stream"
    ) {
        fun save() {
            val values = ContentValues()
            values.put("id", id)
            values.put("oauth_token", oauthToken)
            values.put("oauth_token_secret", oauthTokenSecret)
            values.put("screen_name", screenName)
            values.put("profile_image_url", profileImageUrl)
            values.put("page_infos", stringifyPageInfos())
            values.put("theme", themeIndex)
            values.put("theme_color", themeColor)
            values.put("twitter_event_stream_endpoint", twitterEventStreamEndpoint)
            if (Application.instance.db.replaceOrThrow("profiles", null, values) == -1L)
                throw RuntimeException("SQLiteDatabase#replaceOrThrow failed")
        }

        private fun stringifyPageInfos(): String {
            return json {
                array(pageInfos.filterNot { it.ephemeral }.map { PageInfo.toJsonObject(it) })
            }.toJsonString()
        }

        companion object {
            private fun makeDefaultPageInfos(screenName: String): MutableList<PageInfo> {
                val ret = arrayListOf<PageInfo>()
                ret.add(PageInfo.EventsPageInfo())
                ret.add(PageInfo.ComposePageInfo())
                ret.add(PageInfo.TweetsPageInfo("Home", arrayListOf("")))
                ret.add(PageInfo.TweetsPageInfo("Mentions", arrayListOf("@$screenName")))
                ret.add(PageInfo.SearchPageInfo(""))
                ret.add(PageInfo.ListPageInfo(null))
                return ret
            }

            private fun parsePageInfos(input: String): MutableList<PageInfo> {
                val json = Parser.default().parse(StringBuilder(input)) as JsonArray<*>
                return json.map { PageInfo.fromJsonObject(it as JsonObject) }.toMutableList()
            }

            fun fetchAll(): List<PersistentData> {
                val ret = arrayListOf<PersistentData>()
                Application.instance.db.query("profiles", null, null, null, null, null, null).use { cursor ->
                    while (cursor != null && cursor.moveToNext()) {
                        ret.add(PersistentData(
                                id = cursor.getLong(
                                        cursor.getColumnIndexOrThrow("id")),
                                oauthToken = cursor.getString(
                                        cursor.getColumnIndexOrThrow("oauth_token")),
                                oauthTokenSecret = cursor.getString(
                                        cursor.getColumnIndexOrThrow("oauth_token_secret")),
                                screenName = cursor.getString(
                                        cursor.getColumnIndexOrThrow("screen_name")),
                                profileImageUrl = cursor.getString(
                                        cursor.getColumnIndexOrThrow("profile_image_url")),
                                pageInfos = parsePageInfos(cursor.getString(
                                        cursor.getColumnIndexOrThrow("page_infos"))),
                                themeIndex = cursor.getInt(
                                        cursor.getColumnIndexOrThrow("theme")),
                                themeColor = cursor.getInt(
                                        cursor.getColumnIndexOrThrow("theme_color")),
                                twitterEventStreamEndpoint = cursor.getString(
                                        cursor.getColumnIndexOrThrow("twitter_event_stream_endpoint"))
                        ))
                    }
                }
                return ret
            }
        }
    }
}