Twidere-App-Android-Twitter-Mastodon/twidere/src/main/kotlin/org/mariotaku/twidere/activity/SignInActivity.kt

/*
 * 				Twidere - Twitter client for Android
 * 
 *  Copyright (C) 2012-2014 Mariotaku Lee <mariotaku.lee@gmail.com>
 * 
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 * 
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 * 
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

package org.mariotaku.twidere.activity

import android.accounts.Account
import android.accounts.AccountAuthenticatorResponse
import android.accounts.AccountManager
import android.app.Activity
import android.app.Dialog
import android.content.ActivityNotFoundException
import android.content.Context
import android.content.DialogInterface
import android.content.Intent
import android.content.res.ColorStateList
import android.net.Uri
import android.os.AsyncTask
import android.os.Bundle
import android.support.customtabs.CustomTabsIntent
import android.support.v4.app.DialogFragment
import android.support.v4.content.ContextCompat
import android.support.v4.util.ArraySet
import android.support.v4.view.ViewCompat
import android.support.v7.app.AlertDialog
import android.text.Editable
import android.text.InputType
import android.text.TextUtils
import android.text.TextWatcher
import android.view.Menu
import android.view.MenuItem
import android.view.View
import android.view.View.OnClickListener
import android.widget.EditText
import android.widget.TextView
import android.widget.Toast
import kotlinx.android.synthetic.main.activity_sign_in.*
import nl.komponents.kovenant.combine.and
import nl.komponents.kovenant.task
import nl.komponents.kovenant.ui.alwaysUi
import nl.komponents.kovenant.ui.successUi
import org.mariotaku.kpreferences.get
import org.mariotaku.ktextension.*
import org.mariotaku.microblog.library.MicroBlog
import org.mariotaku.microblog.library.MicroBlogException
import org.mariotaku.microblog.library.twitter.TwitterOAuth
import org.mariotaku.microblog.library.twitter.auth.BasicAuthorization
import org.mariotaku.microblog.library.twitter.auth.EmptyAuthorization
import org.mariotaku.microblog.library.twitter.model.Paging
import org.mariotaku.microblog.library.twitter.model.User
import org.mariotaku.restfu.http.Endpoint
import org.mariotaku.restfu.oauth.OAuthAuthorization
import org.mariotaku.restfu.oauth.OAuthToken
import org.mariotaku.twidere.R
import org.mariotaku.twidere.TwidereConstants.*
import org.mariotaku.twidere.annotation.AccountType
import org.mariotaku.twidere.constant.IntentConstants.EXTRA_API_CONFIG
import org.mariotaku.twidere.constant.SharedPreferenceConstants.KEY_CREDENTIALS_TYPE
import org.mariotaku.twidere.constant.chromeCustomTabKey
import org.mariotaku.twidere.constant.defaultAPIConfigKey
import org.mariotaku.twidere.constant.randomizeAccountNameKey
import org.mariotaku.twidere.extension.applyTheme
import org.mariotaku.twidere.extension.getNonEmptyString
import org.mariotaku.twidere.extension.model.getColor
import org.mariotaku.twidere.extension.model.newMicroBlogInstance
import org.mariotaku.twidere.extension.model.official
import org.mariotaku.twidere.fragment.APIEditorDialogFragment
import org.mariotaku.twidere.fragment.BaseDialogFragment
import org.mariotaku.twidere.fragment.ProgressDialogFragment
import org.mariotaku.twidere.model.CustomAPIConfig
import org.mariotaku.twidere.model.ParcelableUser
import org.mariotaku.twidere.model.SingleResponse
import org.mariotaku.twidere.model.UserKey
import org.mariotaku.twidere.model.account.AccountExtras
import org.mariotaku.twidere.model.account.StatusNetAccountExtras
import org.mariotaku.twidere.model.account.TwitterAccountExtras
import org.mariotaku.twidere.model.account.cred.BasicCredentials
import org.mariotaku.twidere.model.account.cred.Credentials
import org.mariotaku.twidere.model.account.cred.EmptyCredentials
import org.mariotaku.twidere.model.account.cred.OAuthCredentials
import org.mariotaku.twidere.model.analyzer.SignIn
import org.mariotaku.twidere.model.util.AccountUtils
import org.mariotaku.twidere.model.util.ParcelableUserUtils
import org.mariotaku.twidere.model.util.UserKeyUtils
import org.mariotaku.twidere.util.*
import org.mariotaku.twidere.util.OAuthPasswordAuthenticator.*
import java.io.IOException
import java.lang.ref.WeakReference
import java.util.*


class SignInActivity : BaseActivity(), OnClickListener, TextWatcher,
        APIEditorDialogFragment.APIEditorCallback {
    private lateinit var apiConfig: CustomAPIConfig
    private var apiChangeTimestamp: Long = 0
    private var signInTask: AbstractSignInTask? = null

    private var accountAuthenticatorResponse: AccountAuthenticatorResponse? = null
    private var accountAuthenticatorResult: Bundle? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        accountAuthenticatorResponse = intent.getParcelableExtra(AccountManager.KEY_ACCOUNT_AUTHENTICATOR_RESPONSE)
        accountAuthenticatorResponse?.onRequestContinued()

        setContentView(R.layout.activity_sign_in)

        if (savedInstanceState != null) {
            apiConfig = savedInstanceState.getParcelable(EXTRA_API_CONFIG)
            apiChangeTimestamp = savedInstanceState.getLong(EXTRA_API_LAST_CHANGE)
        } else {
            apiConfig = kPreferences[defaultAPIConfigKey]
        }

        val isTwipOMode = apiConfig.credentialsType == Credentials.Type.EMPTY
        usernamePasswordContainer.visibility = if (isTwipOMode) View.GONE else View.VISIBLE

        editUsername.addTextChangedListener(this)
        editPassword.addTextChangedListener(this)

        signIn.setOnClickListener(this)
        signUp.setOnClickListener(this)
        passwordSignIn.setOnClickListener(this)

        val color = ColorStateList.valueOf(ContextCompat.getColor(this,
                R.color.material_light_green))
        ViewCompat.setBackgroundTintList(signIn, color)

        updateSignInType()
        setSignInButton()

        if (savedInstanceState == null) {
            // Only start at the first time
            updateDefaultFeatures()
        }
    }

    override fun onDestroy() {
        loaderManager.destroyLoader(0)
        super.onDestroy()
    }

    override fun onCreateOptionsMenu(menu: Menu): Boolean {
        super.onCreateOptionsMenu(menu)
        menuInflater.inflate(R.menu.menu_sign_in, menu)
        return true
    }

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        when (requestCode) {
            REQUEST_EDIT_API -> {
                if (resultCode == Activity.RESULT_OK) {
                    apiConfig = data!!.getParcelableExtra(EXTRA_API_CONFIG)
                    updateSignInType()
                }
                setSignInButton()
                invalidateOptionsMenu()
            }
            REQUEST_BROWSER_SIGN_IN -> {
                if (resultCode == Activity.RESULT_OK && data != null) {
                    handleBrowserLoginResult(data)
                }
            }
        }
        super.onActivityResult(requestCode, resultCode, data)
    }

    override fun finish() {
        accountAuthenticatorResponse?.let { response ->
            // send the result bundle back if set, otherwise send an error.
            if (accountAuthenticatorResult != null) {
                response.onResult(accountAuthenticatorResult)
            } else {
                response.onError(AccountManager.ERROR_CODE_CANCELED, "canceled")
            }
            accountAuthenticatorResponse = null
        }
        super.finish()
    }

    override fun afterTextChanged(s: Editable) {

    }

    override fun beforeTextChanged(s: CharSequence, start: Int, count: Int, after: Int) {

    }

    override fun onClick(v: View) {
        when (v) {
            signUp -> {
                val signUpUrl = apiConfig.signUpUrl ?: return
                val uri = Uri.parse(signUpUrl)
                if (preferences[chromeCustomTabKey]) {
                    val builder = CustomTabsIntent.Builder()
                    builder.setToolbarColor(overrideTheme.colorToolbar)
                    val intent = builder.build()
                    try {
                        intent.launchUrl(this, uri)
                    } catch (e: ActivityNotFoundException) {
                        // Ignore
                    }
                } else {
                    val intent = Intent(Intent.ACTION_VIEW, uri)
                    try {
                        startActivity(intent)
                    } catch (e: ActivityNotFoundException) {
                        // Ignore
                    }
                }
            }
            signIn -> {
                if (usernamePasswordContainer.visibility != View.VISIBLE) {
                    editUsername.text = null
                    editPassword.text = null
                }
                if (apiConfig.credentialsType == Credentials.Type.OAUTH) {
                    doBrowserLogin()
                } else {
                    doLogin()
                }
            }
            passwordSignIn -> {
                executeAfterFragmentResumed { fragment ->
                    val df = PasswordSignInDialogFragment()
                    df.show(fragment.supportFragmentManager, "password_sign_in")
                }
            }
        }
    }

    override fun onOptionsItemSelected(item: MenuItem): Boolean {
        when (item.itemId) {
            android.R.id.home -> {
                val accountKeys = DataStoreUtils.getActivatedAccountKeys(this)
                if (accountKeys.isNotEmpty()) {
                    onBackPressed()
                }
            }
            R.id.settings -> {
                if (signInTask != null && signInTask!!.status == AsyncTask.Status.RUNNING)
                    return false
                startActivity(IntentUtils.settings())
            }
            R.id.edit_api -> {
                if (signInTask != null && signInTask!!.status == AsyncTask.Status.RUNNING)
                    return false
                setDefaultAPI()
                val df = APIEditorDialogFragment()
                df.arguments = Bundle {
                    this[EXTRA_API_CONFIG] = apiConfig
                    this[APIEditorDialogFragment.EXTRA_SHOW_LOAD_DEFAULTS] = true
                }
                df.show(supportFragmentManager, "edit_api_config")
            }
        }
        return super.onOptionsItemSelected(item)
    }

    override fun onPrepareOptionsMenu(menu: Menu): Boolean {
        super.onPrepareOptionsMenu(menu)
        val itemBrowser = menu.findItem(R.id.open_in_browser)
        if (itemBrowser != null) {
            val is_oauth = apiConfig.credentialsType == Credentials.Type.OAUTH
            itemBrowser.isVisible = is_oauth
            itemBrowser.isEnabled = is_oauth
        }
        return true
    }

    override fun onSaveInstanceState(outState: Bundle) {
        outState.putParcelable(EXTRA_API_CONFIG, apiConfig)
        outState.putLong(EXTRA_API_LAST_CHANGE, apiChangeTimestamp)
        super.onSaveInstanceState(outState)
    }

    override fun onTextChanged(s: CharSequence, start: Int, before: Int, count: Int) {
        setSignInButton()
    }

    override fun onSaveAPIConfig(config: CustomAPIConfig) {
        apiConfig = config

        updateSignInType()
        setSignInButton()
        invalidateOptionsMenu()
    }

    internal fun updateSignInType() {
        when (apiConfig.credentialsType) {
            Credentials.Type.XAUTH, Credentials.Type.BASIC -> {
                usernamePasswordContainer.visibility = View.VISIBLE
            }
            Credentials.Type.EMPTY -> {
                usernamePasswordContainer.visibility = View.GONE
            }
            else -> {
                usernamePasswordContainer.visibility = View.GONE
            }
        }
    }

    internal fun doBrowserLogin(): Boolean {
        if (apiConfig.credentialsType != Credentials.Type.OAUTH || signInTask != null && signInTask!!.status == AsyncTask.Status.RUNNING)
            return true
        val intent = Intent(this, BrowserSignInActivity::class.java)
        intent.putExtra(EXTRA_API_CONFIG, apiConfig)
        startActivityForResult(intent, REQUEST_BROWSER_SIGN_IN)
        return false
    }

    internal fun doLogin() {
        if (signInTask != null && signInTask!!.status == AsyncTask.Status.RUNNING) {
            signInTask!!.cancel(true)
        }

        val username = editUsername.text.toString()
        val password = editPassword.text.toString()
        signInTask = SignInTask(this, username, password, apiConfig)
        AsyncTaskUtils.executeTask<AbstractSignInTask, Any>(signInTask)
    }

    internal fun onSignInResult(result: SignInResponse) {
        val am = AccountManager.get(this)
        setSignInButton()
        if (result.alreadyLoggedIn) {
            result.updateAccount(am)
            contentResolver.deleteAccountData(result.user.key)
            Toast.makeText(this, R.string.message_toast_already_logged_in, Toast.LENGTH_SHORT).show()
        } else {
            result.addAccount(am, preferences[randomizeAccountNameKey])
            Analyzer.log(SignIn(true, accountType = result.typeExtras.first, credentialsType = apiConfig.credentialsType,
                    officialKey = result.typeExtras.second?.official ?: false))
            finishSignIn()
        }
    }

    internal fun dismissDialogFragment(tag: String) {
        executeAfterFragmentResumed {
            val fm = supportFragmentManager
            val f = fm.findFragmentByTag(tag)
            if (f is DialogFragment) {
                f.dismiss()
            }
            Unit
        }
    }


    internal fun onSignInError(exception: Exception) {
        DebugLog.w(LOGTAG, "Sign in error", exception)
        var errorReason: String? = null
        if (exception is AuthenticityTokenException) {
            Toast.makeText(this, R.string.message_toast_wrong_api_key, Toast.LENGTH_SHORT).show()
            errorReason = "wrong_api_key"
        } else if (exception is WrongUserPassException) {
            Toast.makeText(this, R.string.message_toast_wrong_username_password, Toast.LENGTH_SHORT).show()
            errorReason = "wrong_username_password"
        } else if (exception is SignInTask.WrongBasicCredentialException) {
            Toast.makeText(this, R.string.message_toast_wrong_username_password, Toast.LENGTH_SHORT).show()
            errorReason = "wrong_username_password"
        } else if (exception is SignInTask.WrongAPIURLFormatException) {
            Toast.makeText(this, R.string.message_toast_wrong_api_key, Toast.LENGTH_SHORT).show()
            errorReason = "wrong_api_key"
        } else if (exception is LoginVerificationException) {
            Toast.makeText(this, R.string.message_toast_login_verification_failed, Toast.LENGTH_SHORT).show()
            errorReason = "login_verification_failed"
        } else if (exception is AuthenticationException) {
            Utils.showErrorMessage(this, getString(R.string.action_signing_in), exception.cause, true)
        } else {
            Utils.showErrorMessage(this, getString(R.string.action_signing_in), exception, true)
        }
        Analyzer.log(SignIn(false, credentialsType = apiConfig.credentialsType,
                errorReason = errorReason, accountType = apiConfig.type))
    }

    internal fun onSignInStart() {
        showSignInProgressDialog()
    }

    internal fun showSignInProgressDialog() {
        executeAfterFragmentResumed {
            if (isFinishing) return@executeAfterFragmentResumed
            val fm = supportFragmentManager
            val ft = fm.beginTransaction()
            val fragment = ProgressDialogFragment()
            fragment.isCancelable = false
            fragment.show(ft, FRAGMENT_TAG_SIGN_IN_PROGRESS)
        }
    }

    internal fun setUsernamePassword(username: String, password: String) {
        editUsername.setText(username)
        editPassword.setText(password)
    }

    private fun updateDefaultFeatures() {
        val weakThis = WeakReference(this)
        executeAfterFragmentResumed {
            ProgressDialogFragment.show(it.supportFragmentManager, FRAGMENT_TAG_LOADING_DEFAULT_FEATURES)
        } and task {
            val activity = weakThis.get() ?: return@task
            if (activity.isFinishing) return@task
            activity.defaultFeatures.loadRemoteSettings(activity.restHttpClient)
        }.successUi {
            val activity = weakThis.get() ?: return@successUi
            if (activity.isFinishing) return@successUi
            val apiConfig = activity.apiConfig
            val defaultFeatures = activity.defaultFeatures
            val preferences = activity.preferences
            if (apiConfig.consumerKey == TWITTER_CONSUMER_KEY && apiConfig.consumerSecret == TWITTER_CONSUMER_SECRET) {
                apiConfig.consumerKey = defaultFeatures.defaultTwitterConsumerKey ?: TWITTER_CONSUMER_KEY
                apiConfig.consumerSecret = defaultFeatures.defaultTwitterConsumerSecret ?: TWITTER_CONSUMER_SECRET
            }
            defaultFeatures.save(preferences)
        }.fail {
            DebugLog.w(LOGTAG, "Unable to update default features", it)
        }.alwaysUi {
            val activity = weakThis.get() ?: return@alwaysUi
            if (activity.isFinishing) return@alwaysUi
            activity.executeAfterFragmentResumed { activity ->
                val fm = activity.supportFragmentManager
                val df = fm.findFragmentByTag(FRAGMENT_TAG_LOADING_DEFAULT_FEATURES) as? DialogFragment
                df?.dismiss()
            }
        }
    }

    private fun handleBrowserLoginResult(intent: Intent?) {
        if (intent == null) return
        if (signInTask?.status == AsyncTask.Status.RUNNING) {
            signInTask?.cancel(true)
        }
        val verifier = intent.getStringExtra(EXTRA_OAUTH_VERIFIER)
        val requestToken = OAuthToken(intent.getStringExtra(EXTRA_REQUEST_TOKEN),
                intent.getStringExtra(EXTRA_REQUEST_TOKEN_SECRET))
        signInTask = BrowserSignInTask(this, apiConfig, requestToken, verifier)
        AsyncTaskUtils.executeTask<AbstractSignInTask, Any>(signInTask)
    }

    private fun setDefaultAPI() {
        val apiLastChange = preferences.getLong(KEY_API_LAST_CHANGE, apiChangeTimestamp)
        val defaultApiChanged = apiLastChange != apiChangeTimestamp
        val apiUrlFormat = preferences.getNonEmptyString(KEY_API_URL_FORMAT, DEFAULT_TWITTER_API_URL_FORMAT)
        val authType = preferences.getString(KEY_CREDENTIALS_TYPE, Credentials.Type.OAUTH)
        val sameOAuthSigningUrl = preferences.getBoolean(KEY_SAME_OAUTH_SIGNING_URL, false)
        val noVersionSuffix = preferences.getBoolean(KEY_NO_VERSION_SUFFIX, false)
        val consumerKey = preferences.getNonEmptyString(KEY_CONSUMER_KEY, TWITTER_CONSUMER_KEY)
        val consumerSecret = preferences.getNonEmptyString(KEY_CONSUMER_SECRET, TWITTER_CONSUMER_SECRET)
        if (TextUtils.isEmpty(apiConfig.apiUrlFormat) || defaultApiChanged) {
            apiConfig.apiUrlFormat = apiUrlFormat
        }
        if (defaultApiChanged) {
            apiConfig.credentialsType = authType
        }
        if (defaultApiChanged) {
            apiConfig.isSameOAuthUrl = sameOAuthSigningUrl
        }
        if (defaultApiChanged) {
            apiConfig.isNoVersionSuffix = noVersionSuffix
        }
        if (TextUtils.isEmpty(apiConfig.consumerKey) || defaultApiChanged) {
            apiConfig.consumerKey = consumerKey
        }
        if (TextUtils.isEmpty(apiConfig.consumerSecret) || defaultApiChanged) {
            apiConfig.consumerSecret = consumerSecret
        }
        if (defaultApiChanged) {
            apiChangeTimestamp = apiLastChange
        }
    }

    private fun setSignInButton() {
        when (apiConfig.credentialsType) {
            Credentials.Type.XAUTH, Credentials.Type.BASIC -> {
                passwordSignIn.visibility = View.GONE
                signIn.isEnabled = editPassword.text.isNotEmpty() && editUsername.text.isNotEmpty()
            }
            Credentials.Type.OAUTH -> {
                passwordSignIn.visibility = View.VISIBLE
                signIn.isEnabled = true
            }
            else -> {
                passwordSignIn.visibility = View.GONE
                signIn.isEnabled = true
            }
        }
        signUp.visibility = if (apiConfig.signUpUrlOrDefault != null) {
            View.VISIBLE
        } else {
            View.GONE
        }
        passwordSignIn.visibility = if (apiConfig.type == null || apiConfig.type == AccountType.TWITTER) {
            View.VISIBLE
        } else {
            View.GONE
        }
    }


    private fun finishSignIn() {
        if (accountAuthenticatorResponse != null) {
            accountAuthenticatorResult = Bundle {
                this[AccountManager.KEY_BOOLEAN_RESULT] = true
            }
        } else {
            val intent = Intent(this, HomeActivity::class.java)
            //TODO refresh timelines
            intent.addFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT)
            startActivity(intent)
        }
        finish()
    }

    internal abstract class AbstractSignInTask(activity: SignInActivity) : AsyncTask<Any, Runnable, SingleResponse<SignInResponse>>() {

        protected val activityRef = WeakReference(activity)
        protected val profileImageSize = activity.getString(R.string.profile_image_size)

        override final fun doInBackground(vararg args: Any?): SingleResponse<SignInResponse> {
            try {
                return SingleResponse.getInstance(performLogin())
            } catch (e: Exception) {
                return SingleResponse.getInstance(e)
            }
        }

        abstract fun performLogin(): SignInResponse

        override fun onPostExecute(result: SingleResponse<SignInResponse>) {
            val activity = activityRef.get()
            activity?.dismissDialogFragment(FRAGMENT_TAG_SIGN_IN_PROGRESS)
            if (result.hasData()) {
                activity?.onSignInResult(result.data!!)
            } else {
                activity?.onSignInError(result.exception!!)
            }
        }

        override fun onPreExecute() {
            val activity = activityRef.get()
            activity?.onSignInStart()
        }

        override fun onProgressUpdate(vararg values: Runnable) {
            for (value in values) {
                value.run()
            }
        }

        @Throws(MicroBlogException::class)
        internal fun analyseUserProfileColor(user: User?): Int {
            if (user == null) throw MicroBlogException("Unable to get user info")
            return ParcelableUserUtils.parseColor(user.profileLinkColor)
        }

    }

    /**
     * Created by mariotaku on 16/7/7.
     */
    internal class BrowserSignInTask(
            context: SignInActivity,
            private val apiConfig: CustomAPIConfig,
            private val requestToken: OAuthToken,
            private val oauthVerifier: String?
    ) : AbstractSignInTask(context) {

        private val context: Context

        init {
            this.context = context
        }

        @Throws(Exception::class)
        override fun performLogin(): SignInResponse {
            val versionSuffix = if (apiConfig.isNoVersionSuffix) null else "1.1"
            var endpoint = MicroBlogAPIFactory.getOAuthSignInEndpoint(apiConfig.apiUrlFormat,
                    apiConfig.isSameOAuthUrl)
            val oauth = newMicroBlogInstance(context, endpoint = endpoint,
                    auth = OAuthAuthorization(apiConfig.consumerKey, apiConfig.consumerSecret),
                    accountType = apiConfig.type,
                    cls = TwitterOAuth::class.java)
            val accessToken: OAuthToken
            if (oauthVerifier != null) {
                accessToken = oauth.getAccessToken(requestToken, oauthVerifier)
            } else {
                accessToken = oauth.getAccessToken(requestToken)
            }
            val auth = OAuthAuthorization(apiConfig.consumerKey,
                    apiConfig.consumerSecret, accessToken)
            endpoint = MicroBlogAPIFactory.getOAuthEndpoint(apiConfig.apiUrlFormat, "api", versionSuffix,
                    apiConfig.isSameOAuthUrl)

            val twitter = newMicroBlogInstance(context, endpoint = endpoint, auth = auth,
                    accountType = apiConfig.type, cls = MicroBlog::class.java)
            val apiUser = twitter.verifyCredentials()
            var color = analyseUserProfileColor(apiUser)
            val typeExtras = SignInActivity.detectAccountType(twitter, apiUser, apiConfig.type)
            val userId = apiUser.id
            val accountKey = UserKey(userId, UserKeyUtils.getUserHost(apiUser))
            val user = ParcelableUserUtils.fromUser(apiUser, accountKey, typeExtras.first,
                    profileImageSize = profileImageSize)
            val am = AccountManager.get(context)
            val account = AccountUtils.findByAccountKey(am, accountKey)
            if (account != null) {
                color = account.getColor(am)
            }
            val credentials = OAuthCredentials()
            credentials.api_url_format = apiConfig.apiUrlFormat
            credentials.no_version_suffix = apiConfig.isNoVersionSuffix

            credentials.same_oauth_signing_url = apiConfig.isSameOAuthUrl

            credentials.consumer_key = apiConfig.consumerKey
            credentials.consumer_secret = apiConfig.consumerSecret
            credentials.access_token = accessToken.oauthToken
            credentials.access_token_secret = accessToken.oauthTokenSecret

            return SignInResponse(account != null, Credentials.Type.OAUTH, credentials, user, color,
                    typeExtras)
        }
    }

    /**
     * Created by mariotaku on 16/7/7.
     */
    class InputLoginVerificationDialogFragment : BaseDialogFragment(), DialogInterface.OnClickListener, DialogInterface.OnShowListener {

        private var callback: SignInTask.InputLoginVerificationCallback? = null
        var challengeType: String? = null

        internal fun setCallback(callback: SignInTask.InputLoginVerificationCallback) {
            this.callback = callback
        }


        override fun onCancel(dialog: DialogInterface?) {
            callback!!.challengeResponse = null
        }

        override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
            val builder = AlertDialog.Builder(context)
            builder.setTitle(R.string.login_verification)
            builder.setView(R.layout.dialog_login_verification_code)
            builder.setPositiveButton(android.R.string.ok, this)
            builder.setNegativeButton(android.R.string.cancel, this)
            val dialog = builder.create()
            dialog.setOnShowListener(this)
            return dialog
        }

        override fun onClick(dialog: DialogInterface, which: Int) {
            when (which) {
                DialogInterface.BUTTON_POSITIVE -> {
                    val alertDialog = dialog as AlertDialog
                    val editVerification = (alertDialog.findViewById(R.id.edit_verification_code) as EditText?)!!
                    callback!!.challengeResponse = ParseUtils.parseString(editVerification.text)
                }
                DialogInterface.BUTTON_NEGATIVE -> {
                    callback!!.challengeResponse = null
                }
            }
        }

        override fun onShow(dialog: DialogInterface) {
            (dialog as AlertDialog).applyTheme()
            val verificationHint = dialog.findViewById(R.id.verification_hint) as TextView?
            val editVerification = dialog.findViewById(R.id.edit_verification_code) as EditText?
            if (verificationHint == null || editVerification == null) return
            when {
                "Push".equals(challengeType, ignoreCase = true) -> {
                    verificationHint.setText(R.string.login_verification_push_hint)
                    editVerification.visibility = View.GONE
                }
                "RetypePhoneNumber".equals(challengeType, ignoreCase = true) -> {
                    verificationHint.setText(R.string.login_challenge_retype_phone_hint)
                    editVerification.inputType = InputType.TYPE_CLASS_PHONE
                    editVerification.visibility = View.VISIBLE
                }
                "RetypeEmail".equals(challengeType, ignoreCase = true) -> {
                    verificationHint.setText(R.string.login_challenge_retype_email_hint)
                    editVerification.inputType = InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_VARIATION_EMAIL_ADDRESS
                    editVerification.visibility = View.VISIBLE
                }
                "Sms".equals(challengeType, ignoreCase = true) -> {
                    verificationHint.setText(R.string.login_verification_pin_hint)
                    editVerification.inputType = InputType.TYPE_CLASS_NUMBER or InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD
                    editVerification.visibility = View.VISIBLE
                }
                else -> {
                    verificationHint.text = getString(R.string.unsupported_login_verification_type_name,
                            challengeType)
                    editVerification.visibility = View.VISIBLE
                }
            }
        }
    }

    class PasswordSignInDialogFragment : BaseDialogFragment() {
        override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
            val builder = AlertDialog.Builder(context)
            builder.setView(R.layout.dialog_password_sign_in)
            builder.setPositiveButton(R.string.sign_in) { dialog, _ ->
                val alertDialog = dialog as AlertDialog
                val editUsername = alertDialog.findViewById(R.id.username) as EditText?
                val editPassword = alertDialog.findViewById(R.id.password) as EditText?
                assert(editUsername != null && editPassword != null)
                val activity = activity as SignInActivity
                activity.setUsernamePassword(editUsername!!.text.toString(),
                        editPassword!!.text.toString())
                activity.doLogin()
            }
            builder.setNegativeButton(android.R.string.cancel, null)

            val alertDialog = builder.create()
            alertDialog.setOnShowListener {
                (it as AlertDialog)
                it.applyTheme()
                val editUsername = it.findViewById(R.id.username) as EditText?
                val editPassword = it.findViewById(R.id.password) as EditText?
                assert(editUsername != null && editPassword != null)
                val textWatcher = object : TextWatcher {
                    override fun beforeTextChanged(s: CharSequence, start: Int, count: Int, after: Int) {

                    }

                    override fun onTextChanged(s: CharSequence, start: Int, before: Int, count: Int) {
                        val button = it.getButton(DialogInterface.BUTTON_POSITIVE) ?: return
                        button.isEnabled = editUsername!!.length() > 0 && editPassword!!.length() > 0
                    }

                    override fun afterTextChanged(s: Editable) {

                    }
                }

                editUsername!!.addTextChangedListener(textWatcher)
                editPassword!!.addTextChangedListener(textWatcher)
            }
            return alertDialog
        }
    }

    internal data class SignInResponse(
            val alreadyLoggedIn: Boolean,
            @Credentials.Type val credsType: String = Credentials.Type.EMPTY,
            val credentials: Credentials,
            val user: ParcelableUser,
            val color: Int = 0,
            val typeExtras: Pair<String, AccountExtras?>
    ) {

        private fun writeAccountInfo(action: (k: String, v: String?) -> Unit) {
            action(ACCOUNT_USER_DATA_KEY, user.key.toString())
            action(ACCOUNT_USER_DATA_TYPE, typeExtras.first)
            action(ACCOUNT_USER_DATA_CREDS_TYPE, credsType)

            action(ACCOUNT_USER_DATA_ACTIVATED, true.toString())
            action(ACCOUNT_USER_DATA_COLOR, toHexColor(color, format = HexColorFormat.RGB))

            action(ACCOUNT_USER_DATA_USER, JsonSerializer.serialize(user))
            action(ACCOUNT_USER_DATA_EXTRAS, typeExtras.second?.let { JsonSerializer.serialize(it) })
        }

        private fun writeAuthToken(am: AccountManager, account: Account) {
            val authToken = JsonSerializer.serialize(credentials)
            am.setAuthToken(account, ACCOUNT_AUTH_TOKEN_TYPE, authToken)
        }

        fun updateAccount(am: AccountManager) {
            val account = AccountUtils.findByAccountKey(am, user.key) ?: return
            writeAccountInfo { k, v ->
                am.setUserData(account, k, v)
            }
            writeAuthToken(am, account)
        }

        fun addAccount(am: AccountManager, randomizeAccountName: Boolean): Account {
            var accountName: String
            if (randomizeAccountName) {
                val usedNames = ArraySet<String>()
                AccountUtils.getAccounts(am).mapTo(usedNames, Account::name)
                do {
                    accountName = UUID.randomUUID().toString()
                } while (accountName in usedNames)
            } else {
                accountName = generateAccountName(user.screen_name, user.key.host)
            }
            val account = Account(accountName, ACCOUNT_TYPE)
            val accountPosition = AccountUtils.getAccounts(am).size
            // Don't add UserData in this method, see http://stackoverflow.com/a/29776224/859190
            am.addAccountExplicitly(account, null, null)
            writeAccountInfo { k, v ->
                am.setUserData(account, k, v)
            }
            am.setUserData(account, ACCOUNT_USER_DATA_POSITION, accountPosition.toString())
            writeAuthToken(am, account)
            return account
        }

    }

    internal class SignInTask(
            activity: SignInActivity,
            private val username: String,
            private val password: String,
            private val apiConfig: CustomAPIConfig
    ) : AbstractSignInTask(activity) {
        private val verificationCallback = InputLoginVerificationCallback()
        private val userAgent = UserAgentUtils.getDefaultUserAgentString(activity)
        private val apiUrlFormat = apiConfig.apiUrlFormat ?: DEFAULT_TWITTER_API_URL_FORMAT

        @Throws(Exception::class)
        override fun performLogin(): SignInResponse {
            when (apiConfig.credentialsType) {
                Credentials.Type.OAUTH -> return authOAuth()
                Credentials.Type.XAUTH -> return authxAuth()
                Credentials.Type.BASIC -> return authBasic()
                Credentials.Type.EMPTY -> return authTwipOMode()
            }
            return authOAuth()
        }

        @Throws(OAuthPasswordAuthenticator.AuthenticationException::class, MicroBlogException::class)
        private fun authOAuth(): SignInResponse {
            val activity = activityRef.get() ?: throw InterruptedException()
            val endpoint = MicroBlogAPIFactory.getOAuthSignInEndpoint(apiUrlFormat,
                    apiConfig.isSameOAuthUrl)
            val auth = OAuthAuthorization(apiConfig.consumerKey,
                    apiConfig.consumerSecret)
            val oauth = newMicroBlogInstance(activity, endpoint = endpoint, auth = auth,
                    accountType = apiConfig.type, cls = TwitterOAuth::class.java)
            val authenticator = OAuthPasswordAuthenticator(oauth,
                    verificationCallback, userAgent)
            val accessToken = authenticator.getOAuthAccessToken(username, password)
            val userId = accessToken.userId
            return getOAuthSignInResponse(activity, accessToken, userId, Credentials.Type.OAUTH)
        }

        @Throws(MicroBlogException::class)
        private fun authxAuth(): SignInResponse {
            val activity = activityRef.get() ?: throw InterruptedException()
            var endpoint = MicroBlogAPIFactory.getOAuthSignInEndpoint(apiUrlFormat,
                    apiConfig.isSameOAuthUrl)
            var auth = OAuthAuthorization(apiConfig.consumerKey,
                    apiConfig.consumerSecret)
            val oauth = newMicroBlogInstance(activity, endpoint = endpoint, auth = auth,
                    accountType = apiConfig.type, cls = TwitterOAuth::class.java)
            val accessToken = oauth.getAccessToken(username, password)
            val userId = accessToken.userId ?: run {
                // Trying to fix up userId if accessToken doesn't contain one.
                auth = OAuthAuthorization(apiConfig.consumerKey,
                        apiConfig.consumerSecret, accessToken)
                endpoint = MicroBlogAPIFactory.getOAuthRestEndpoint(apiUrlFormat, apiConfig.isSameOAuthUrl,
                        apiConfig.isNoVersionSuffix)
                val microBlog = newMicroBlogInstance(activity, endpoint = endpoint, auth = auth,
                        accountType = apiConfig.type, cls = MicroBlog::class.java)
                return@run microBlog.verifyCredentials().id
            }
            return getOAuthSignInResponse(activity, accessToken, userId, Credentials.Type.XAUTH)
        }

        @Throws(MicroBlogException::class, OAuthPasswordAuthenticator.AuthenticationException::class)
        private fun authBasic(): SignInResponse {
            val activity = activityRef.get() ?: throw InterruptedException()
            val versionSuffix = if (apiConfig.isNoVersionSuffix) null else "1.1"
            val endpoint = Endpoint(MicroBlogAPIFactory.getApiUrl(apiUrlFormat, "api",
                    versionSuffix))
            val auth = BasicAuthorization(username, password)
            val twitter = newMicroBlogInstance(activity, endpoint = endpoint, auth = auth,
                    accountType = apiConfig.type, cls = MicroBlog::class.java)
            val apiUser: User
            try {
                apiUser = twitter.verifyCredentials()
            } catch (e: MicroBlogException) {
                if (e.statusCode == 401) {
                    throw WrongBasicCredentialException()
                } else if (e.statusCode == 404) {
                    throw WrongAPIURLFormatException()
                }
                throw e
            }

            val userId = apiUser.id!!
            var color = analyseUserProfileColor(apiUser)
            val typeExtras = SignInActivity.detectAccountType(twitter, apiUser, apiConfig.type)
            val accountKey = UserKey(userId, UserKeyUtils.getUserHost(apiUser))
            val user = ParcelableUserUtils.fromUser(apiUser, accountKey, typeExtras.first,
                    profileImageSize = profileImageSize)
            val am = AccountManager.get(activity)
            val account = AccountUtils.findByAccountKey(am, accountKey)
            if (account != null) {
                color = account.getColor(am)
            }
            val credentials = BasicCredentials()
            credentials.api_url_format = apiUrlFormat
            credentials.no_version_suffix = apiConfig.isNoVersionSuffix
            credentials.username = username
            credentials.password = password
            return SignInResponse(account != null, Credentials.Type.BASIC, credentials, user,
                    color, typeExtras)
        }


        @Throws(MicroBlogException::class)
        private fun authTwipOMode(): SignInResponse {
            val activity = activityRef.get() ?: throw InterruptedException()
            val versionSuffix = if (apiConfig.isNoVersionSuffix) null else "1.1"
            val endpoint = Endpoint(MicroBlogAPIFactory.getApiUrl(apiUrlFormat, "api",
                    versionSuffix))
            val auth = EmptyAuthorization()
            val twitter = newMicroBlogInstance(activity, endpoint = endpoint, auth = auth,
                    accountType = apiConfig.type, cls = MicroBlog::class.java)
            val apiUser = twitter.verifyCredentials()
            val userId = apiUser.id!!
            var color = analyseUserProfileColor(apiUser)
            val typeExtras = SignInActivity.detectAccountType(twitter, apiUser, apiConfig.type)
            val accountKey = UserKey(userId, UserKeyUtils.getUserHost(apiUser))
            val user = ParcelableUserUtils.fromUser(apiUser, accountKey, typeExtras.first,
                    profileImageSize = profileImageSize)
            val am = AccountManager.get(activity)
            val account = AccountUtils.findByAccountKey(am, accountKey)
            if (account != null) {
                color = account.getColor(am)
            }
            val credentials = EmptyCredentials()
            credentials.api_url_format = apiUrlFormat
            credentials.no_version_suffix = apiConfig.isNoVersionSuffix

            return SignInResponse(account != null, Credentials.Type.EMPTY, credentials, user, color,
                    typeExtras)
        }

        @Throws(MicroBlogException::class)
        private fun getOAuthSignInResponse(activity: SignInActivity,
                accessToken: OAuthToken,
                userId: String, @Credentials.Type authType: String): SignInResponse {
            val auth = OAuthAuthorization(apiConfig.consumerKey,
                    apiConfig.consumerSecret, accessToken)
            val endpoint = MicroBlogAPIFactory.getOAuthRestEndpoint(apiUrlFormat,
                    apiConfig.isSameOAuthUrl, apiConfig.isNoVersionSuffix)
            val twitter = newMicroBlogInstance(activity, endpoint = endpoint, auth = auth,
                    accountType = apiConfig.type, cls = MicroBlog::class.java)
            val apiUser = twitter.verifyCredentials()
            var color = analyseUserProfileColor(apiUser)
            val typeExtras = SignInActivity.detectAccountType(twitter, apiUser, apiConfig.type)
            val accountKey = UserKey(userId, UserKeyUtils.getUserHost(apiUser))
            val user = ParcelableUserUtils.fromUser(apiUser, accountKey, typeExtras.first,
                    profileImageSize = profileImageSize)
            val am = AccountManager.get(activity)
            val account = AccountUtils.findByAccountKey(am, accountKey)
            if (account != null) {
                color = account.getColor(am)
            }
            val credentials = OAuthCredentials()
            credentials.api_url_format = apiUrlFormat
            credentials.no_version_suffix = apiConfig.isNoVersionSuffix

            credentials.same_oauth_signing_url = apiConfig.isSameOAuthUrl

            credentials.consumer_key = apiConfig.consumerKey
            credentials.consumer_secret = apiConfig.consumerSecret
            credentials.access_token = accessToken.oauthToken
            credentials.access_token_secret = accessToken.oauthTokenSecret

            return SignInResponse(account != null, authType, credentials, user, color, typeExtras)
        }

        internal class WrongBasicCredentialException : OAuthPasswordAuthenticator.AuthenticationException()

        internal class WrongAPIURLFormatException : OAuthPasswordAuthenticator.AuthenticationException()

        internal inner class InputLoginVerificationCallback : OAuthPasswordAuthenticator.LoginVerificationCallback {

            var isChallengeFinished: Boolean = false

            var challengeResponse: String? = null
                set(value) {
                    isChallengeFinished = true
                    field = value
                }

            override fun getLoginVerification(challengeType: String): String? {
                // Dismiss current progress dialog
                publishProgress(Runnable {
                    activityRef.get()?.dismissDialogFragment(SignInActivity.FRAGMENT_TAG_SIGN_IN_PROGRESS)
                })
                // Show verification input dialog and wait for user input
                publishProgress(Runnable {
                    val activity = activityRef.get() ?: return@Runnable
                    activity.executeAfterFragmentResumed { activity ->
                        val sia = activity as SignInActivity
                        val df = InputLoginVerificationDialogFragment()
                        df.isCancelable = false
                        df.setCallback(this@InputLoginVerificationCallback)
                        df.challengeType = challengeType
                        df.show(sia.supportFragmentManager, "login_challenge_$challengeType")
                    }
                })
                while (!isChallengeFinished) {
                    // Wait for 50ms
                    try {
                        Thread.sleep(50)
                    } catch (e: InterruptedException) {
                        // Ignore
                    }

                }
                // Show progress dialog
                publishProgress(Runnable {
                    val activity = activityRef.get() ?: return@Runnable
                    activity.showSignInProgressDialog()
                })
                return challengeResponse
            }

        }

    }


    companion object {

        private val FRAGMENT_TAG_SIGN_IN_PROGRESS = "sign_in_progress"
        private val FRAGMENT_TAG_LOADING_DEFAULT_FEATURES = "loading_default_features"
        private val EXTRA_API_LAST_CHANGE = "api_last_change"
        private val DEFAULT_TWITTER_API_URL_FORMAT = "https://[DOMAIN.]twitter.com/"

        @Throws(IOException::class)
        internal fun detectAccountType(twitter: MicroBlog, user: User, type: String?): Pair<String, AccountExtras?> {
            when (type) {
                AccountType.STATUSNET -> {
                    return getStatusNetAccountType(twitter)
                }
                AccountType.TWITTER -> {
                    return getTwitterAccountType(twitter)
                }
                AccountType.FANFOU -> {
                    return Pair(AccountType.FANFOU, null)
                }
                else -> {
                    if (UserKeyUtils.isFanfouUser(user)) {
                        return Pair(AccountType.FANFOU, null)
                    }
                }
            }
            return Pair(AccountType.TWITTER, null)
        }

        private fun getStatusNetAccountType(twitter: MicroBlog): Pair<String, StatusNetAccountExtras> {
            // Get StatusNet specific resource
            val config = twitter.statusNetConfig
            val extras = StatusNetAccountExtras()
            val site = config.site
            if (site != null) {
                extras.textLimit = site.textLimit
            }
            return Pair(AccountType.STATUSNET, extras)
        }

        private fun getTwitterAccountType(twitter: MicroBlog): Pair<String, TwitterAccountExtras> {
            val extras = TwitterAccountExtras()
            try {
                // Get Twitter official only resource
                val paging = Paging()
                paging.count(1)
                twitter.getActivitiesAboutMe(paging)
                extras.setIsOfficialCredentials(true)
            } catch (e: MicroBlogException) {
                // Ignore
            }
            return Pair(AccountType.TWITTER, extras)
        }
    }

    private val CustomAPIConfig.signUpUrlOrDefault: String?
        get() = signUpUrl ?: when (type) {
            AccountType.TWITTER -> "https://twitter.com/signup"
            AccountType.FANFOU -> "http://fanfou.com/register"
            else -> null
        }

}