Abit/app/src/main/java/ch/dissem/apps/abit/MainActivity.kt

/*
 * Copyright 2016 Christian Basler
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package ch.dissem.apps.abit

import android.content.Intent
import android.graphics.Point
import android.os.Bundle
import android.support.v4.app.Fragment
import android.support.v7.app.AppCompatActivity
import android.support.v7.widget.Toolbar
import android.view.View
import android.view.ViewGroup
import android.widget.RelativeLayout
import ch.dissem.apps.abit.drawer.ProfileImageListener
import ch.dissem.apps.abit.drawer.ProfileSelectionListener
import ch.dissem.apps.abit.listener.ListSelectionListener
import ch.dissem.apps.abit.repository.AndroidMessageRepository.Companion.LABEL_ARCHIVE
import ch.dissem.apps.abit.service.Singleton
import ch.dissem.apps.abit.synchronization.SyncAdapter
import ch.dissem.apps.abit.util.Labels
import ch.dissem.apps.abit.util.NetworkUtils
import ch.dissem.apps.abit.util.Preferences
import ch.dissem.bitmessage.BitmessageContext
import ch.dissem.bitmessage.entity.BitmessageAddress
import ch.dissem.bitmessage.entity.Plaintext
import ch.dissem.bitmessage.entity.valueobject.Label
import com.github.amlcurran.showcaseview.ShowcaseView
import com.mikepenz.community_material_typeface_library.CommunityMaterial
import com.mikepenz.google_material_typeface_library.GoogleMaterial
import com.mikepenz.iconics.IconicsDrawable
import com.mikepenz.materialdrawer.AccountHeader
import com.mikepenz.materialdrawer.AccountHeaderBuilder
import com.mikepenz.materialdrawer.Drawer
import com.mikepenz.materialdrawer.DrawerBuilder
import com.mikepenz.materialdrawer.model.*
import com.mikepenz.materialdrawer.model.interfaces.IDrawerItem
import com.mikepenz.materialdrawer.model.interfaces.IProfile
import com.mikepenz.materialdrawer.model.interfaces.Nameable
import io.github.kobakei.materialfabspeeddial.FabSpeedDial
import kotlinx.android.synthetic.main.activity_main.*
import org.jetbrains.anko.doAsync
import org.jetbrains.anko.uiThread
import java.io.Serializable
import java.lang.ref.WeakReference
import java.util.*


/**
 * An activity representing a list of Messages. This activity
 * has different presentations for handset and tablet-size devices. On
 * handsets, the activity presents a list of items, which when touched,
 * lead to a [MessageDetailActivity] representing
 * item details. On tablets, the activity presents the list of items and
 * item details side-by-side using two vertical panes.
 *
 *
 * The activity makes heavy use of fragments. The list of items is a
 * [MessageListFragment] and the item details
 * (if present) is a [MessageDetailFragment].
 *
 *
 * This activity also implements the required
 * [ListSelectionListener] interface
 * to listen for item selections.
 *
 */
class MainActivity : AppCompatActivity(), ListSelectionListener<Serializable> {

    private var active: Boolean = false

    /**
     * Whether or not the activity is in two-pane mode, i.e. running on a tablet
     * device.
     */
    var hasDetailPane: Boolean = false
        private set

    var selectedLabel: Label? = null
        private set

    private lateinit var bmc: BitmessageContext
    private lateinit var accountHeader: AccountHeader

    private lateinit var drawer: Drawer
    private lateinit var nodeSwitch: SwitchDrawerItem

    val floatingActionButton: FabSpeedDial?
        get() = findViewById(R.id.fab)

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        instance = WeakReference(this)
        bmc = Singleton.getBitmessageContext(this)

        setContentView(R.layout.activity_main)
        fab.hide()

        val toolbar = findViewById<Toolbar>(R.id.toolbar)
        setSupportActionBar(toolbar)

        val listFragment = MessageListFragment()
        supportFragmentManager
                .beginTransaction()
                .replace(R.id.item_list, listFragment)
                .commit()

        if (findViewById<View>(R.id.message_detail_container) != null) {
            // The detail container view will be present only in the
            // large-screen layouts (res/values-large and
            // res/values-sw600dp). If this view is present, then the
            // activity should be in two-pane mode.
            hasDetailPane = true

            // In two-pane mode, list items should be given the
            // 'activated' state when touched.
            listFragment.setActivateOnItemClick(true)
        }

        createDrawer(toolbar)

        // handle intents
        val intent = intent
        if (intent.hasExtra(EXTRA_SHOW_MESSAGE)) {
            onItemSelected(intent.getSerializableExtra(EXTRA_SHOW_MESSAGE))
        }
        if (intent.hasExtra(EXTRA_REPLY_TO_MESSAGE)) {
            val item = intent.getSerializableExtra(EXTRA_REPLY_TO_MESSAGE) as Plaintext
            ComposeMessageActivity.launchReplyTo(this, item)
        }

        if (Preferences.useTrustedNode(this)) {
            SyncAdapter.startSync(this)
        } else {
            SyncAdapter.stopSync(this)
        }
        if (drawer.isDrawerOpen) {
            val lps = RelativeLayout.LayoutParams(ViewGroup
                    .LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT)
            lps.addRule(RelativeLayout.ALIGN_PARENT_BOTTOM)
            lps.addRule(RelativeLayout.ALIGN_PARENT_LEFT)
            val margin = ((resources.displayMetrics.density * 12) as Number).toInt()
            lps.setMargins(margin, margin, margin, margin)

            ShowcaseView.Builder(this)
                    .withMaterialShowcase()
                    .setStyle(R.style.CustomShowcaseTheme)
                    .setContentTitle(R.string.full_node)
                    .setContentText(R.string.full_node_description)
                    .setTarget {
                        val view = drawer.stickyFooter
                        val location = IntArray(2)
                        view.getLocationInWindow(location)
                        val x = location[0] + 7 * view.width / 8
                        val y = location[1] + view.height / 2
                        Point(x, y)
                    }
                    .replaceEndButton(R.layout.showcase_button)
                    .hideOnTouchOutside()
                    .build()
                    .setButtonPosition(lps)
        }
    }

    private fun <F> changeList(listFragment: F) where F : Fragment, F : ListHolder<*> {
        if (active) {
            val transaction = supportFragmentManager
                    .beginTransaction()
            transaction.replace(R.id.item_list, listFragment)
            val detailFragment = supportFragmentManager.findFragmentById(R.id.message_detail_container)
            if (detailFragment != null) {
                transaction.remove(detailFragment)
            }
            transaction.addToBackStack(null).commit()

            if (hasDetailPane) {
                // In two-pane mode, list items should be given the
                // 'activated' state when touched.
                listFragment.setActivateOnItemClick(true)
            }
        }
    }

    private fun createDrawer(toolbar: Toolbar) {
        val profiles = ArrayList<IProfile<*>>()
        profiles.add(ProfileSettingDrawerItem()
                .withName(getString(R.string.add_identity))
                .withDescription(getString(R.string.add_identity_summary))
                .withIcon(IconicsDrawable(this, GoogleMaterial.Icon.gmd_add)
                        .actionBar()
                        .paddingDp(5)
                        .colorRes(R.color.icons))
                .withIdentifier(ADD_IDENTITY.toLong())
        )
        profiles.add(ProfileSettingDrawerItem()
                .withName(getString(R.string.manage_identity))
                .withIcon(GoogleMaterial.Icon.gmd_settings)
                .withIdentifier(MANAGE_IDENTITY.toLong())
        )
        // Create the AccountHeader
        accountHeader = AccountHeaderBuilder()
                .withActivity(this)
                .withHeaderBackground(R.drawable.header)
                .withProfiles(profiles)
                .withOnAccountHeaderProfileImageListener(ProfileImageListener(this))
                .withOnAccountHeaderListener(ProfileSelectionListener(this@MainActivity, supportFragmentManager))
                .build()
        if (profiles.size > 2) { // There's always the add and manage identity items
            accountHeader.setActiveProfile(profiles[0], true)
        }

        val drawerItems = ArrayList<IDrawerItem<*, *>>()
        drawerItems.add(PrimaryDrawerItem()
                .withName(R.string.archive)
                .withTag(LABEL_ARCHIVE)
                .withIcon(CommunityMaterial.Icon.cmd_archive)
        )
        drawerItems.add(DividerDrawerItem())
        drawerItems.add(PrimaryDrawerItem()
                .withName(R.string.contacts_and_subscriptions)
                .withIcon(GoogleMaterial.Icon.gmd_contacts))
        drawerItems.add(PrimaryDrawerItem()
                .withName(R.string.settings)
                .withIcon(GoogleMaterial.Icon.gmd_settings))

        nodeSwitch = SwitchDrawerItem()
                .withIdentifier(ID_NODE_SWITCH)
                .withName(R.string.full_node)
                .withIcon(CommunityMaterial.Icon.cmd_cloud_outline)
                .withChecked(Preferences.isFullNodeActive(this))
                .withOnCheckedChangeListener { _, _, isChecked ->
                    if (isChecked) {
                        NetworkUtils.enableNode(this@MainActivity)
                    } else {
                        NetworkUtils.disableNode(this@MainActivity)
                    }
                }

        drawer = DrawerBuilder()
                .withActivity(this)
                .withToolbar(toolbar)
                .withAccountHeader(accountHeader)
                .withDrawerItems(drawerItems)
                .addStickyDrawerItems(nodeSwitch)
                .withOnDrawerItemClickListener(DrawerItemClickListener())
                .withShowDrawerOnFirstLaunch(true)
                .build()

        loadDrawerItemsAsynchronously()
    }

    private fun loadDrawerItemsAsynchronously() {
        doAsync {
            val identities = bmc.addresses.getIdentities()
            if (identities.isEmpty()) {
                // Create an initial identity
                Singleton.getIdentity(this@MainActivity)
            }

            uiThread {
                for (identity in identities) {
                    addIdentityEntry(identity)
                }
            }
        }

        doAsync {
            val labels = bmc.messages.getLabels()

            uiThread {
                if (intent.hasExtra(EXTRA_SHOW_LABEL)) {
                    selectedLabel = intent.getSerializableExtra(EXTRA_SHOW_LABEL) as Label
                } else if (selectedLabel == null) {
                    selectedLabel = labels[0]
                }
                for (label in labels) {
                    addLabelEntry(label)
                }
                val selectedDrawerItem = drawer.getDrawerItem(selectedLabel)
                if (selectedDrawerItem != null) {
                    drawer.setSelection(selectedDrawerItem)
                }
            }
        }
    }

    override fun onBackPressed() {
        val listFragment = supportFragmentManager.findFragmentById(R.id.item_list)
        if (listFragment is ListHolder<*>) {
            val listHolder = listFragment as ListHolder<*>
            if (listHolder.showPreviousList()) {
                val drawerItem = drawer.getDrawerItem(listHolder.currentLabel)
                if (drawerItem != null) {
                    drawer.setSelection(drawerItem)
                }
                return
            }
        }
        super.onBackPressed()
    }

    private inner class DrawerItemClickListener : Drawer.OnDrawerItemClickListener {
        override fun onItemClick(view: View?, position: Int, item: IDrawerItem<*, *>): Boolean {
            val itemList = supportFragmentManager.findFragmentById(R.id.item_list)
            val tag = item.tag
            if (tag is Label) {
                selectedLabel = tag
                if (itemList is MessageListFragment) {
                    itemList.updateList(tag)
                } else {
                    val listFragment = MessageListFragment()
                    changeList(listFragment)
                    listFragment.updateList(tag)
                }
                return false
            } else if (item is Nameable<*>) {
                when (item.name.textRes) {
                    R.string.contacts_and_subscriptions -> {
                        if (itemList is AddressListFragment) {
                            itemList.updateList()
                        } else {
                            changeList(AddressListFragment())
                        }
                        return false
                    }
                    R.string.settings -> {
                        supportFragmentManager
                                .beginTransaction()
                                .replace(R.id.item_list, SettingsFragment())
                                .addToBackStack(null)
                                .commit()
                        return false
                    }
                    R.string.full_node -> return true
                    else -> return false
                }
            }
            return false
        }
    }

    override fun onSaveInstanceState(savedInstanceState: Bundle) {
        super.onSaveInstanceState(savedInstanceState)
        savedInstanceState.putSerializable("selectedLabel", selectedLabel)
    }

    override fun onRestoreInstanceState(savedInstanceState: Bundle) {
        selectedLabel = savedInstanceState.getSerializable("selectedLabel") as? Label

        selectedLabel?.let { selectedLabel ->
            drawer.getDrawerItem(selectedLabel)?.let { selectedItem ->
                drawer.setSelection(selectedItem)
            }
        }
        super.onRestoreInstanceState(savedInstanceState)
    }

    override fun onResume() {
        updateUnread()
        if (Preferences.isFullNodeActive(this) && Preferences.isConnectionAllowed(this@MainActivity)) {
            NetworkUtils.enableNode(this, false)
        }
        Singleton.getMessageListener(this).resetNotification()
        active = true
        super.onResume()
    }

    override fun onPause() {
        super.onPause()
        active = false
    }

    fun addIdentityEntry(identity: BitmessageAddress) {
        val newProfile = ProfileDrawerItem()
                .withIcon(Identicon(identity))
                .withName(identity.toString())
                .withNameShown(true)
                .withEmail(identity.address)
                .withTag(identity)
        if (accountHeader.profiles != null) {
            // we know that there are 2 setting elements.
            // Set the new profile above them ;)
            accountHeader.addProfile(
                    newProfile, accountHeader.profiles.size - 2)
        } else {
            accountHeader.addProfiles(newProfile)
        }
    }

    private fun addLabelEntry(label: Label) {
        val item = PrimaryDrawerItem()
                .withName(label.toString())
                .withTag(label)
                .withIcon(Labels.getIcon(label))
                .withIconColor(Labels.getColor(label))
        drawer.addItemAtPosition(item, drawer.drawerItems.size - 3)
    }

    fun updateIdentityEntry(identity: BitmessageAddress) {
        for (profile in accountHeader.profiles) {
            if (profile is ProfileDrawerItem) {
                if (identity == profile.tag) {
                    profile
                            .withName(identity.toString())
                            .withTag(identity)
                    return
                }
            }
        }
    }

    fun removeIdentityEntry(identity: BitmessageAddress) {
        for (profile in accountHeader.profiles) {
            if (profile is ProfileDrawerItem) {
                if (identity == profile.tag) {
                    accountHeader.removeProfile(profile)
                    return
                }
            }
        }
    }

    fun updateUnread() {
        for (item in drawer.drawerItems) {
            if (item.tag is Label) {
                val label = item.tag as Label
                if (label !== LABEL_ARCHIVE) {
                    val unread = bmc.messages.countUnread(label)
                    if (unread > 0) {
                        (item as PrimaryDrawerItem).withBadge(unread.toString())
                    } else {
                        (item as PrimaryDrawerItem).withBadge(null as String?)
                    }
                    drawer.updateItem(item)
                }
            }
        }
    }

    /**
     * Callback method from [ListSelectionListener]
     * indicating that the item with the given ID was selected.
     */
    override fun onItemSelected(item: Serializable) {
        if (hasDetailPane) {
            // In two-pane mode, show the detail view in this activity by
            // adding or replacing the detail fragment using a
            // fragment transaction.
            val arguments = Bundle()
            arguments.putSerializable(MessageDetailFragment.ARG_ITEM, item)
            val fragment = when (item) {
                is Plaintext -> MessageDetailFragment()
                is BitmessageAddress -> AddressDetailFragment()
                else -> throw IllegalArgumentException("Plaintext or BitmessageAddress expected, but was ${item::class.simpleName}")
            }
            fragment.arguments = arguments
            supportFragmentManager.beginTransaction()
                    .replace(R.id.message_detail_container, fragment)
                    .commit()
        } else {
            // In single-pane mode, simply start the detail activity
            // for the selected item ID.
            val detailIntent = when (item) {
                is Plaintext -> {
                    Intent(this, MessageDetailActivity::class.java).apply {
                        putExtra(EXTRA_SHOW_LABEL, selectedLabel)
                    }
                }
                is BitmessageAddress -> Intent(this, AddressDetailActivity::class.java)
                else -> throw IllegalArgumentException("Plaintext or BitmessageAddress expected, but was ${item::class.simpleName}")
            }
            detailIntent.putExtra(MessageDetailFragment.ARG_ITEM, item)
            startActivity(detailIntent)
        }
    }

    fun setDetailView(fragment: Fragment) {
        if (hasDetailPane) {
            supportFragmentManager.beginTransaction()
                    .replace(R.id.message_detail_container, fragment)
                    .commit()
        }
    }

    fun updateTitle(title: CharSequence) {
        supportActionBar?.title = title
    }

    companion object {
        val EXTRA_SHOW_MESSAGE = "ch.dissem.abit.ShowMessage"
        val EXTRA_SHOW_LABEL = "ch.dissem.abit.ShowLabel"
        val EXTRA_REPLY_TO_MESSAGE = "ch.dissem.abit.ReplyToMessage"
        val ACTION_SHOW_INBOX = "ch.dissem.abit.ShowInbox"

        val ADD_IDENTITY = 1
        val MANAGE_IDENTITY = 2

        private val ID_NODE_SWITCH: Long = 1

        private var instance: WeakReference<MainActivity>? = null

        fun updateNodeSwitch() {
            val i = getInstance()
            i?.apply {
                runOnUiThread {
                    nodeSwitch.withChecked(Preferences.isFullNodeActive(i))
                    drawer.updateStickyFooterItem(nodeSwitch)
                }
            }
        }

        fun getInstance() = instance?.get()
    }
}