package net.lacolaco.smileessence.entity

import android.net.Uri
import twitter4j.Status

import java.util.*
import java.util.concurrent.ConcurrentHashMap

class Tweet private constructor(st: twitter4j.Status, myUserId: Long) : EntitySupport(st), IdObject {
    override val id: Long = st.id
    val user: User = User.fromTwitter(st.user)
    val createdAt: Date = st.createdAt
    val source: String = st.source
    val retweetedTweet: Tweet? =
            if (st.isRetweet) Tweet.fromTwitter(st.retweetedStatus, myUserId)
            else null
    val isRetweet = retweetedTweet != null
    val originalTweet = retweetedTweet ?: this
    val text: String = retweetedTweet?.text ?: extractText(st, false)
    val inReplyToStatusId: Long? = when {
        isRetweet -> retweetedTweet!!.inReplyToStatusId
        st.inReplyToStatusId != -1L -> st.inReplyToStatusId
        else -> null
    }
    var favoriteCount: Int = st.favoriteCount
        get() = retweetedTweet?.favoriteCount ?: field
        private set
    var retweetCount: Int = st.retweetCount
        get() = retweetedTweet?.retweetCount ?: field
        private set
    private val favoriters: MutableSet<Long> = Collections.newSetFromMap(ConcurrentHashMap())
    private val retweets: MutableMap<Long, Long> = ConcurrentHashMap()

    // Override EntitySupport
    override val mentions: List<String> = retweetedTweet?.mentions ?: super.mentions
    override val hashtags: List<String> = retweetedTweet?.hashtags ?: super.hashtags
    override val mediaUrls: List<String> = retweetedTweet?.mediaUrls ?: super.mediaUrls
    override val urlsExpanded: List<String> = retweetedTweet?.urlsExpanded ?: super.urlsExpanded
    override val symbols: List<String> = retweetedTweet?.symbols ?: super.symbols

    init {
        update(st, myUserId)
    }

    private fun update(status: twitter4j.Status, myUserId: Long) {
        User.fromTwitter(status.user)
        if (retweetedTweet != null) {
            retweetedTweet.update(status.retweetedStatus, myUserId)
            if (status.isFavorited)
                retweetedTweet.favoriters.add(myUserId)
            if (status.user.id == myUserId)
                retweetedTweet.retweets.put(myUserId, status.id)
        } else {
            favoriteCount = status.favoriteCount
            retweetCount = status.retweetCount
            if (status.isFavorited)
                favoriters.add(myUserId)
            else
                favoriters.remove(myUserId)
            if (status.currentUserRetweetId > 0)
                retweets.put(myUserId, status.currentUserRetweetId)
        }
    }

    val twitterUrl: String
        get() = String.format("https://twitter.com/%s/status/%s", user.screenName, id)

    fun isFavoritedBy(id: Long): Boolean {
        return originalTweet.favoriters.contains(id)
    }

    fun addFavoriter(id: Long): Boolean {
        return originalTweet.favoriters.add(id)
    }

    fun removeFavoriter(id: Long): Boolean {
        return originalTweet.favoriters.remove(id)
    }

    fun isRetweetedBy(id: Long): Boolean {
        return originalTweet.retweets.containsKey(id)
    }

    fun getRetweetIdBy(id: Long): Long {
        return originalTweet.retweets[id]!!
    }

    // helper methods::
    val embeddedStatusIDs: List<Long> by lazy {
        val list = ArrayList<Long>()
        for (url in urlsExpanded) {
            val uri = Uri.parse(url)
            if ("twitter.com" == uri.host) {
                val segments = uri.pathSegments
                if (segments.size >= 3 && segments[1] == "status") {
                    val idish = segments[2].toLongOrNull()
                    if (idish != null)
                        list.add(idish)
                }
            }
        }
        list
    }

    companion object {
        private val storage = HashMap<Long, Tweet>()

        @Synchronized
        fun fetch(statusId: Long): Tweet? {
            return storage[statusId]
        }

        @Synchronized
        fun fromTwitter(st: twitter4j.Status, myUserId: Long): Tweet {
            var t = fetch(st.id)
            if (t == null) {
                t = Tweet(st, myUserId)
                storage.put(st.id, t)
            } else {
                t.update(st, myUserId)
            }
            return t
        }

        @Synchronized
        fun fromTwitter(sts: List<Status>, myUserId: Long): List<Tweet> {
            return sts.map { st -> fromTwitter(st, myUserId) }
        }
    }
}