/*
 * 				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.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.Build
import android.os.Bundle
import androidx.loader.app.LoaderManager
import androidx.core.content.ContextCompat
import androidx.loader.content.Loader
import androidx.collection.ArraySet
import androidx.core.view.ViewCompat
import androidx.appcompat.app.AlertDialog
import android.text.Editable
import android.text.InputType
import android.text.TextWatcher
import android.view.*
import android.view.View.OnClickListener
import android.webkit.CookieManager
import android.webkit.CookieSyncManager
import android.widget.BaseExpandableListAdapter
import android.widget.ExpandableListView
import android.widget.TextView
import android.widget.Toast
import kotlinx.android.synthetic.main.activity_sign_in.*
import kotlinx.android.synthetic.main.dialog_expandable_list.*
import kotlinx.android.synthetic.main.dialog_login_verification_code.*
import nl.komponents.kovenant.CancelException
import nl.komponents.kovenant.Deferred
import nl.komponents.kovenant.combine.and
import nl.komponents.kovenant.deferred
import nl.komponents.kovenant.task
import nl.komponents.kovenant.ui.alwaysUi
import nl.komponents.kovenant.ui.failUi
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.mastodon.Mastodon
import org.mariotaku.microblog.library.mastodon.MastodonOAuth2
import org.mariotaku.microblog.library.mastodon.annotation.AuthScope
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.OAuthToken
import org.mariotaku.restfu.oauth2.OAuth2Authorization
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.apiLastChangeKey
import org.mariotaku.twidere.constant.defaultAPIConfigKey
import org.mariotaku.twidere.constant.randomizeAccountNameKey
import org.mariotaku.twidere.extension.*
import org.mariotaku.twidere.extension.model.*
import org.mariotaku.twidere.extension.model.api.isFanfouUser
import org.mariotaku.twidere.extension.model.api.key
import org.mariotaku.twidere.extension.model.api.mastodon.toParcelable
import org.mariotaku.twidere.extension.model.api.toParcelable
import org.mariotaku.twidere.fragment.APIEditorDialogFragment
import org.mariotaku.twidere.fragment.BaseDialogFragment
import org.mariotaku.twidere.fragment.ProgressDialogFragment
import org.mariotaku.twidere.loader.DefaultAPIConfigLoader
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.MastodonAccountExtras
import org.mariotaku.twidere.model.account.StatusNetAccountExtras
import org.mariotaku.twidere.model.account.TwitterAccountExtras
import org.mariotaku.twidere.model.account.cred.*
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.util.*
import org.mariotaku.twidere.util.OAuthPasswordAuthenticator.*
import java.io.IOException
import java.lang.ref.WeakReference
import java.util.*
import kotlin.collections.ArrayList


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)


        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)


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

        updateSignInType()
        setSignInButton()

        if (savedInstanceState == null) {
            // Only start at the first time
            showLoginTypeChooser()
            // Must call this before cookie manager under lollipop
            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
                @Suppress("DEPRECATION")
                CookieSyncManager.createInstance(this)
            }
            CookieManager.getInstance().removeAllCookiesSupport()
        }
    }

    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 && data != null) {
                    apiConfig = data.getParcelableExtra(EXTRA_API_CONFIG)
                    updateSignInType()
                }
                setSignInButton()
                invalidateOptionsMenu()
            }
            REQUEST_BROWSER_TWITTER_SIGN_IN -> {
                if (resultCode == Activity.RESULT_OK && data != null) {
                    handleBrowserLoginResult(data)
                }
            }
            REQUEST_BROWSER_MASTODON_SIGN_IN -> {
                if (resultCode == Activity.RESULT_OK && data != null) {
                    val code = data.getStringExtra(EXTRA_CODE)
                    val extras = data.getBundleExtra(EXTRA_EXTRAS)!!
                    val host = extras.getString(EXTRA_HOST)!!
                    val clientId = extras.getString(EXTRA_CLIENT_ID)!!
                    val clientSecret = extras.getString(EXTRA_CLIENT_SECRET)!!

                    finishMastodonBrowserLogin(host, clientId, clientSecret, code)
                }
            }
        }
        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 uri = apiConfig.signUpUrl?.let(Uri::parse) ?: return
                OnLinkClickHandler.openLink(this, preferences, uri)
            }
            signIn -> {
                if (usernamePasswordContainer.visibility != View.VISIBLE) {
                    editUsername.text = null
                    editPassword.text = null
                }
                setDefaultAPI()
                if (apiConfig.type == AccountType.MASTODON) {
                    performMastodonLogin()
                } else when (apiConfig.credentialsType) {
                    Credentials.Type.OAUTH -> {
                        performBrowserLogin()
                    }
                    else -> {
                        val username = editUsername.text.toString()
                        val password = editPassword.text.toString()
                        performUserPassLogin(username, password)
                    }
                }
            }
            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()
    }


    private fun performBrowserLogin() {
        val weakThis = WeakReference(this)
        executeAfterFragmentResumed { activity ->
            ProgressDialogFragment.show(activity.supportFragmentManager, "get_request_token")
        } and task {
            val activity = weakThis.get() ?: throw InterruptedException()
            val apiConfig = activity.apiConfig
            val apiUrlFormat = apiConfig.apiUrlFormat ?:
                    throw MicroBlogException("Invalid API URL format")
            val endpoint = MicroBlogAPIFactory.getOAuthSignInEndpoint(apiUrlFormat,
                    apiConfig.isSameOAuthUrl)
            val auth = apiConfig.getOAuthAuthorization() ?:
                    throw MicroBlogException("Invalid OAuth credentials")
            val oauth = newMicroBlogInstance(activity, endpoint, auth, apiConfig.type,
                    TwitterOAuth::class.java)
            return@task oauth.getRequestToken(OAUTH_CALLBACK_OOB)
        }.successUi { requestToken ->
            val activity = weakThis.get() ?: return@successUi
            val intent = Intent(activity, BrowserSignInActivity::class.java)
            val apiConfig = activity.apiConfig
            val endpoint = MicroBlogAPIFactory.getOAuthSignInEndpoint(apiConfig.apiUrlFormat!!, true)
            intent.data = Uri.parse(endpoint.construct("/oauth/authorize", arrayOf("oauth_token",
                    requestToken.oauthToken)))
            intent.putExtra(EXTRA_EXTRAS, Bundle {
                this[EXTRA_REQUEST_TOKEN] = requestToken.oauthToken
                this[EXTRA_REQUEST_TOKEN_SECRET] = requestToken.oauthTokenSecret
            })
            activity.startActivityForResult(intent, REQUEST_BROWSER_TWITTER_SIGN_IN)
        }.failUi {
            val activity = weakThis.get() ?: return@failUi
            // TODO show error message
            if (it is MicroBlogException) {
                Toast.makeText(activity, it.message, Toast.LENGTH_SHORT).show()
            }
        }.alwaysUi {
            executeAfterFragmentResumed {
                it.supportFragmentManager.dismissDialogFragment("get_request_token")
            }
        }
    }

    private fun performMastodonLogin() {
        val weakThis = WeakReference(this)
        val host = editUsername.string?.takeIf(String::isNotEmpty) ?: run {
            Toast.makeText(this, R.string.message_toast_invalid_mastodon_host,
                    Toast.LENGTH_SHORT).show()
            return
        }
        val scopes = arrayOf(AuthScope.READ, AuthScope.WRITE, AuthScope.FOLLOW)
        executeAfterFragmentResumed { activity ->
            ProgressDialogFragment.show(activity.supportFragmentManager, "open_browser_auth")
        } and task {
            val activity = weakThis.get() ?: throw InterruptedException()
            val registry = activity.mastodonApplicationRegistry
            return@task Pair(host, registry[host] ?: registry.fetch(host, scopes))
        }.successUi { (host, app) ->
            val activity = weakThis.get() ?: return@successUi
            val endpoint = Endpoint("https://$host/")
            val intent = Intent(activity, BrowserSignInActivity::class.java)
            intent.data = Uri.parse(endpoint.construct("/oauth/authorize",
                    arrayOf("response_type", "code"),
                    arrayOf("client_id", app.clientId),
                    arrayOf("redirect_uri", MASTODON_CALLBACK_URL),
                    arrayOf("scope", scopes.joinToString(" "))))
            intent.putExtra(EXTRA_EXTRAS, Bundle {
                this[EXTRA_HOST] = host
                this[EXTRA_CLIENT_ID] = app.clientId
                this[EXTRA_CLIENT_SECRET] = app.clientSecret
            })
            activity.startActivityForResult(intent, REQUEST_BROWSER_MASTODON_SIGN_IN)
        }.failUi {
            val activity = weakThis.get() ?: return@failUi
            // TODO show error message
            activity.onSignInError(it)
        }.alwaysUi {
            val activity = weakThis.get() ?: return@alwaysUi
            activity.executeAfterFragmentResumed {
                it.supportFragmentManager.dismissDialogFragment("open_browser_auth")
            }
        }
    }

    private fun performUserPassLogin(username: String, password: String) {
        if (signInTask != null && signInTask!!.status == AsyncTask.Status.RUNNING) {
            signInTask!!.cancel(true)
        }

        signInTask = SignInTask(this, username, password, apiConfig).apply { execute() }
    }

    private 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.type,
                    credentialsType = apiConfig.credentialsType,
                    officialKey = result.extras?.official == true))
            finishSignIn()
        }
    }

    private fun dismissDialogFragment(tag: String) {
        executeAfterFragmentResumed {
            it.supportFragmentManager.dismissDialogFragment(tag)
        }
    }

    internal fun onSignInError(exception: Exception) {
        DebugLog.w(LOGTAG, "Sign in error", exception)
        var errorReason: String? = null
        when (exception) {
            is AuthenticityTokenException -> {
                Toast.makeText(this, R.string.message_toast_wrong_api_key, Toast.LENGTH_SHORT).show()
                errorReason = "wrong_api_key"
            }
            is WrongUserPassException -> {
                Toast.makeText(this, R.string.message_toast_wrong_username_password, Toast.LENGTH_SHORT).show()
                errorReason = "wrong_username_password"
            }
            is SignInTask.WrongBasicCredentialException -> {
                Toast.makeText(this, R.string.message_toast_wrong_username_password, Toast.LENGTH_SHORT).show()
                errorReason = "wrong_username_password"
            }
            is SignInTask.WrongAPIURLFormatException -> {
                Toast.makeText(this, R.string.message_toast_wrong_api_key, Toast.LENGTH_SHORT).show()
                errorReason = "wrong_api_key"
            }
            is LoginVerificationException -> {
                Toast.makeText(this, R.string.message_toast_login_verification_failed, Toast.LENGTH_SHORT).show()
                errorReason = "login_verification_failed"
            }
            else -> {
                Toast.makeText(this, exception.getErrorMessage(this), Toast.LENGTH_SHORT).show()
            }
        }
        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 dismissSignInProgressDialog() {
        dismissDialogFragment(FRAGMENT_TAG_SIGN_IN_PROGRESS)
    }

    private fun showLoginTypeChooser() {
        executeAfterFragmentResumed {
            val fm = it.supportFragmentManager
            val df = SignInTypeChooserDialogFragment()
            df.show(fm, "login_type_chooser")
        }
    }


    private fun finishMastodonBrowserLogin(host: String, clientId: String, clientSecret: String, code: String) {
        signInTask = MastodonLoginTask(this, host, clientId, clientSecret, code).apply { execute() }
    }

    private fun handleBrowserLoginResult(intent: Intent?) {
        if (intent == null) return
        val extras = intent.getBundleExtra(EXTRA_EXTRAS) ?: return
        val requestToken = OAuthToken(extras.getString(EXTRA_REQUEST_TOKEN),
                extras.getString(EXTRA_REQUEST_TOKEN_SECRET))
        val verifier = intent.getStringExtra(EXTRA_OAUTH_VERIFIER)
        signInTask = BrowserSignInTask(this, apiConfig, requestToken, verifier).apply { execute() }
    }

    private fun setDefaultAPI() {
        if (!apiConfig.isDefault) return
        val apiLastChange = preferences[apiLastChangeKey]
        if (apiLastChange != apiChangeTimestamp) {
            apiConfig = preferences[defaultAPIConfigKey]
            apiChangeTimestamp = apiLastChange
        }
        updateSignInType()
        setSignInButton()
    }

    private fun updateSignInType() {
        // Mastodon have different case
        if (apiConfig.type == AccountType.MASTODON) {
            usernamePasswordContainer.visibility = View.VISIBLE
            editPassword.visibility = View.GONE
            editUsername.hint = getString(R.string.label_mastodon_host)
        } else when (apiConfig.credentialsType) {
            Credentials.Type.XAUTH, Credentials.Type.BASIC -> {
                usernamePasswordContainer.visibility = View.VISIBLE
                editPassword.visibility = View.VISIBLE
                editUsername.hint = getString(R.string.label_username)
            }
            Credentials.Type.EMPTY -> {
                usernamePasswordContainer.visibility = View.GONE
            }
            else -> {
                usernamePasswordContainer.visibility = View.GONE
            }
        }
    }

    private fun setSignInButton() {
        // Mastodon have different case
        if (apiConfig.type == AccountType.MASTODON) {
            passwordSignIn.visibility = View.GONE
            signIn.isEnabled = true
        } else when (apiConfig.credentialsType) {
            Credentials.Type.XAUTH, Credentials.Type.BASIC -> {
                passwordSignIn.visibility = View.GONE
                signIn.isEnabled = !(editPassword.text.isNullOrEmpty() || editUsername.text.isNullOrEmpty())
            }
            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()
    }

    class SignInTypeChooserDialogFragment : BaseDialogFragment(),
            LoaderManager.LoaderCallbacks<List<CustomAPIConfig>> {
        override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
            val builder = AlertDialog.Builder(requireContext())
            builder.setView(R.layout.dialog_expandable_list)
            val dialog = builder.create()
            dialog.onShow {
                it.applyTheme()
                val listView = it.expandableList
                val adapter = LoginTypeAdapter(requireContext())
                listView.setAdapter(adapter)
                listView.setOnGroupClickListener { _, _, groupPosition, _ ->
                    val type = adapter.getGroup(groupPosition)
                    if (type.hasChildren) return@setOnGroupClickListener false
                    val activity = activity as? SignInActivity
                    val config = type.configs.single()
                    activity?.let {
                        it.apiConfig = config
                        it.updateSignInType()
                        it.setSignInButton()
                    }
                    dismiss()
                    return@setOnGroupClickListener true
                }
                listView.setOnChildClickListener { _, _, groupPosition, childPosition, _ ->
                    val config = adapter.getChild(groupPosition, childPosition)
                    val activity = activity as? SignInActivity
                    activity?.let {
                        it.apiConfig = config
                        it.updateSignInType()
                        it.setSignInButton()
                    }
                    dismiss()
                    return@setOnChildClickListener true
                }

                loaderManager.initLoader(0, null, this)
            }
            return dialog
        }

        override fun onLoadFinished(loader: Loader<List<CustomAPIConfig>>, data: List<CustomAPIConfig>) {
            val dialog = dialog ?: return
            val listView: ExpandableListView = dialog.findViewById(R.id.expandableList)
            val defaultConfig = preferences[defaultAPIConfigKey]
            defaultConfig.name = getString(R.string.login_type_user_settings)
            val allConfig = ArraySet(data)
            allConfig.add(defaultConfig)
            val configGroup = allConfig.groupBy { it.safeType }
            val supportedAccountTypes = arrayOf(AccountType.TWITTER, AccountType.FANFOU,
                    AccountType.MASTODON, AccountType.STATUSNET)
            val result = supportedAccountTypes.mapNotNullTo(ArrayList()) { type ->
                if (type == AccountType.MASTODON) return@mapNotNullTo LoginType(type,
                        listOf(CustomAPIConfig.mastodon(requireContext())))
                return@mapNotNullTo configGroup[type]?.let { list ->
                    LoginType(type, list.sortedBy { !it.isDefault })
                }
            }
            (listView.expandableListAdapter as LoginTypeAdapter).data = result
        }

        override fun onCreateLoader(id: Int, args: Bundle?): Loader<List<CustomAPIConfig>> {
            return DefaultAPIConfigLoader(requireContext())
        }

        override fun onLoaderReset(loader: Loader<List<CustomAPIConfig>>) {

        }

        private data class LoginType(val type: String, val configs: List<CustomAPIConfig>) {
            val hasChildren = configs.size > 1
        }

        private class LoginTypeAdapter(val context: Context) : BaseExpandableListAdapter() {

            private val inflater = LayoutInflater.from(context)

            var data: List<LoginType>? = null

            override fun getGroupCount() = data?.count() ?: 0
            override fun getGroup(groupPosition: Int) = data!![groupPosition]
            override fun getChild(groupPosition: Int, childPosition: Int) =
                    getGroup(groupPosition).configs[childPosition]

            override fun getChildrenCount(groupPosition: Int): Int {
                val size = getGroup(groupPosition).configs.size
                if (size > 1) return size
                return 0
            }

            override fun isChildSelectable(groupPosition: Int, childPosition: Int) = true
            override fun hasStableIds() = false
            override fun getGroupId(groupPosition: Int) = groupPosition.toLong()
            override fun getChildId(groupPosition: Int, childPosition: Int): Long =
                    groupPosition.toLong().shl(32) or childPosition.toLong()


            override fun getGroupView(groupPosition: Int, isExpanded: Boolean, convertView: View?,
                    parent: ViewGroup): View {
                val view = convertView ?: inflater.inflate(android.R.layout.simple_expandable_list_item_1, parent, false)
                val text1 = view.findViewById<TextView>(android.R.id.text1)
                val group = getGroup(groupPosition)
                text1.text = APIEditorDialogFragment.getTypeTitle(context, group.type)
                return view
            }

            override fun getChildView(groupPosition: Int, childPosition: Int, isLastChild: Boolean,
                    convertView: View?, parent: ViewGroup): View {
                val view = convertView ?: inflater.inflate(android.R.layout.simple_list_item_1, parent, false)
                val config = getChild(groupPosition, childPosition)
                val text1 = view.findViewById<TextView>(android.R.id.text1)
                text1.text = config.name
                return view
            }

        }
    }

    internal class InputLoginVerificationDialogFragment : BaseDialogFragment() {

        var deferred: Deferred<String?, Exception>? = null
        var challengeType: String? = null

        override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
            val builder = AlertDialog.Builder(requireContext())
            builder.setTitle(R.string.login_verification)
            builder.setView(R.layout.dialog_login_verification_code)
            builder.positive(android.R.string.ok, this::performVerification)
            builder.negative(android.R.string.cancel, this::cancelVerification)
            val dialog = builder.create()
            dialog.onShow(this::onDialogShow)
            return dialog
        }

        override fun onCancel(dialog: DialogInterface) {
            deferred?.reject(CancelException())
        }

        private fun performVerification(dialog: Dialog) {
            deferred?.resolve(dialog.editVerificationCode.string)
        }

        private fun cancelVerification(dialog: Dialog) {
            deferred?.reject(CancelException())
        }

        private fun onDialogShow(dialog: Dialog) {
            (dialog as? AlertDialog)?.applyTheme()
            val verificationHint = dialog.verificationHint
            val editVerification = dialog.editVerificationCode
            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(requireContext())
            builder.setView(R.layout.dialog_password_sign_in)
            builder.positive(R.string.action_sign_in, this::onPositiveButton)
            builder.setNegativeButton(android.R.string.cancel, null)

            val alertDialog = builder.create()
            alertDialog.onShow { dialog ->
                dialog.applyTheme()
                val editUsername = dialog.editUsername
                val editPassword = dialog.editPassword
                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 = dialog.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
        }

        private fun onPositiveButton(dialog: Dialog) {
            val activity = activity as SignInActivity
            val username = dialog.editUsername.string.orEmpty()
            val password = dialog.editPassword.string.orEmpty()
            activity.setDefaultAPI()
            activity.performUserPassLogin(username, password)
        }
    }

    internal class BrowserSignInTask(activity: SignInActivity, private val apiConfig: CustomAPIConfig,
            private val requestToken: OAuthToken, private val oauthVerifier: String?) :
            AbstractSignInTask(activity) {

        @Throws(Exception::class)
        override fun performLogin(): SignInResponse {
            val context = activityRef.get() ?: throw InterruptedException()
            val versionSuffix = if (apiConfig.isNoVersionSuffix) null else "1.1"
            val apiUrlFormat = apiConfig.apiUrlFormat ?: throw MicroBlogException("No API URL format")
            var auth = apiConfig.getOAuthAuthorization() ?:
                    throw MicroBlogException("Invalid OAuth credential")
            var endpoint = MicroBlogAPIFactory.getOAuthSignInEndpoint(apiUrlFormat,
                    apiConfig.isSameOAuthUrl)
            val oauth = newMicroBlogInstance(context, endpoint = endpoint, auth = auth,
                    accountType = apiConfig.type, cls = TwitterOAuth::class.java)
            val accessToken: OAuthToken
            accessToken = if (oauthVerifier != null) {
                oauth.getAccessToken(requestToken, oauthVerifier)
            } else {
                oauth.getAccessToken(requestToken)
            }
            auth = apiConfig.getOAuthAuthorization(accessToken) ?:
                    throw MicroBlogException("Invalid OAuth credential")
            endpoint = MicroBlogAPIFactory.getOAuthEndpoint(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 (type, extras) = detectAccountType(twitter, apiUser, apiConfig.type)
            val accountKey = apiUser.key
            val user = apiUser.toParcelable(accountKey, type, 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 = apiUrlFormat
            credentials.no_version_suffix = apiConfig.isNoVersionSuffix

            credentials.same_oauth_signing_url = apiConfig.isSameOAuthUrl

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

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

    }

    internal class MastodonLoginTask(context: SignInActivity, val host: String, val clientId: String,
            val clientSecret: String, val code: String) : AbstractSignInTask(context) {
        @Throws(Exception::class)
        override fun performLogin(): SignInResponse {
            val context = activityRef.get() ?: throw InterruptedException()
            val oauth2 = newMicroBlogInstance(context, Endpoint("https://$host/"),
                    EmptyAuthorization(), AccountType.MASTODON, MastodonOAuth2::class.java)
            val token = oauth2.getToken(clientId, clientSecret, code, MASTODON_CALLBACK_URL)

            val endpoint = Endpoint("https://$host/api/")
            val auth = OAuth2Authorization(token.accessToken)
            val mastodon = newMicroBlogInstance(context, endpoint = endpoint, auth = auth,
                    accountType = AccountType.MASTODON, cls = Mastodon::class.java)
            val apiAccount = mastodon.verifyCredentials()
            var color = 0
            val accountKey = UserKey(apiAccount.id, host)
            val user = apiAccount.toParcelable(accountKey)
            val am = AccountManager.get(context)
            val account = AccountUtils.findByAccountKey(am, accountKey)
            if (account != null) {
                color = account.getColor(am)
            }
            val credentials = OAuth2Credentials()
            credentials.api_url_format = endpoint.url
            credentials.no_version_suffix = true

            credentials.access_token = token.accessToken
            return SignInResponse(account != null, Credentials.Type.OAUTH2, credentials, user,
                    color, AccountType.MASTODON, getMastodonAccountExtras(mastodon))
        }
    }

    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(AuthenticationException::class, MicroBlogException::class)
        private fun authOAuth(): SignInResponse {
            val activity = activityRef.get() ?: throw InterruptedException()
            val endpoint = MicroBlogAPIFactory.getOAuthSignInEndpoint(apiUrlFormat,
                    apiConfig.isSameOAuthUrl)
            val auth = apiConfig.getOAuthAuthorization() ?:
                    throw MicroBlogException("Invalid OAuth credential")
            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, 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 = apiConfig.getOAuthAuthorization() ?:
                    throw MicroBlogException("Invalid OAuth credential")
            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 = apiConfig.getOAuthAuthorization(accessToken) ?:
                        throw MicroBlogException("Invalid OAuth credential")
                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, Credentials.Type.XAUTH)
        }

        @Throws(MicroBlogException::class, 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
            }

            var color = analyseUserProfileColor(apiUser)
            val (type, extras) = detectAccountType(twitter, apiUser, apiConfig.type)
            val accountKey = apiUser.key
            val user = apiUser.toParcelable(accountKey, type, 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, type, extras)
        }


        @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()
            var color = analyseUserProfileColor(apiUser)
            val (type, extras) = detectAccountType(twitter, apiUser, apiConfig.type)
            val accountKey = apiUser.key
            val user = apiUser.toParcelable(accountKey, type, 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,
                    type, extras)
        }

        @Throws(MicroBlogException::class)
        private fun getOAuthSignInResponse(activity: SignInActivity, accessToken: OAuthToken,
                @Credentials.Type authType: String): SignInResponse {
            val auth = apiConfig.getOAuthAuthorization(accessToken) ?:
                    throw MicroBlogException("Invalid OAuth credential")
            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 (type, extras) = detectAccountType(twitter, apiUser, apiConfig.type)
            val accountKey = apiUser.key
            val user = apiUser.toParcelable(accountKey, type, 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 = auth.consumerKey
            credentials.consumer_secret = auth.consumerSecret
            credentials.access_token = accessToken.oauthToken
            credentials.access_token_secret = accessToken.oauthTokenSecret

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

        internal class WrongBasicCredentialException : AuthenticationException()

        internal class WrongAPIURLFormatException : AuthenticationException()

        internal inner class InputLoginVerificationCallback : LoginVerificationCallback {

            override fun getLoginVerification(challengeType: String): String? {
                // Dismiss current progress dialog
                publishProgress(Runnable {
                    activityRef.get()?.dismissSignInProgressDialog()
                })
                val deferred = deferred<String?, Exception>()
                // Show verification input dialog and wait for user input
                publishProgress(Runnable {
                    val activity = activityRef.get() ?: return@Runnable
                    activity.executeAfterFragmentResumed {
                        val sia = it as SignInActivity
                        val df = InputLoginVerificationDialogFragment()
                        df.isCancelable = false
                        df.deferred = deferred
                        df.challengeType = challengeType
                        df.show(sia.supportFragmentManager, "login_challenge_$challengeType")
                    }
                })

                return try {
                    deferred.promise.get()
                } catch (e: CancelException) {
                    throw MicroBlogException(e)
                } finally {
                    // Show progress dialog
                    publishProgress(Runnable {
                        activityRef.get()?.showSignInProgressDialog()
                    })
                }
            }

        }

    }

    internal abstract class AbstractSignInTask(activity: SignInActivity) : AsyncTask<Any, Runnable, SingleResponse<SignInResponse>>() {
        protected val activityRef = WeakReference(activity)

        protected val profileImageSize: String = activity.getString(R.string.profile_image_size)

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

    }

    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 type: String,
            val extras: AccountExtras?
    ) {

        private fun writeAccountInfo(action: (k: String, v: String?) -> Unit) {
            action(ACCOUNT_USER_DATA_KEY, user.key.toString())
            action(ACCOUNT_USER_DATA_TYPE, type)
            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, extras?.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
        }

    }

    companion object {
        const val REQUEST_BROWSER_TWITTER_SIGN_IN = 101
        const val REQUEST_BROWSER_MASTODON_SIGN_IN = 102

        private const val FRAGMENT_TAG_SIGN_IN_PROGRESS = "sign_in_progress"
        private const val EXTRA_API_LAST_CHANGE = "api_last_change"

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

        private fun getStatusNetAccountExtras(twitter: MicroBlog): StatusNetAccountExtras {
            // Get StatusNet specific resource
            val config = twitter.statusNetConfig
            return StatusNetAccountExtras().apply {
                textLimit = config.site?.textLimit ?: -1
                uploadLimit = config.attachments?.fileQuota ?: -1L
            }
        }

        private fun getTwitterAccountExtras(twitter: MicroBlog): 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 extras
        }

        private fun getMastodonAccountExtras(mastodon: Mastodon): MastodonAccountExtras {
            return MastodonAccountExtras()
        }

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

    }

}