package jp.juggler.subwaytooter

import android.Manifest
import android.annotation.SuppressLint
import android.app.Activity
import android.app.Dialog
import android.content.ContentResolver
import android.content.ContentValues
import android.content.Intent
import android.content.SharedPreferences
import android.content.pm.PackageManager
import android.graphics.Bitmap
import android.net.Uri
import android.os.Build
import android.os.Bundle
import android.os.Handler
import android.os.SystemClock
import android.provider.MediaStore
import android.text.Editable
import android.text.InputType
import android.text.TextWatcher
import android.text.method.LinkMovementMethod
import android.view.View
import android.view.ViewGroup
import android.view.ViewTreeObserver
import android.view.inputmethod.EditorInfo
import android.widget.*
import androidx.appcompat.app.AlertDialog
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat
import androidx.core.view.inputmethod.InputConnectionCompat
import androidx.core.view.inputmethod.InputContentInfoCompat
import jp.juggler.subwaytooter.Styler.defaultColorIcon
import jp.juggler.subwaytooter.api.*
import jp.juggler.subwaytooter.api.entity.*
import jp.juggler.subwaytooter.dialog.*
import jp.juggler.subwaytooter.span.MyClickableSpan
import jp.juggler.subwaytooter.table.AcctColor
import jp.juggler.subwaytooter.table.PostDraft
import jp.juggler.subwaytooter.table.SavedAccount
import jp.juggler.subwaytooter.util.*
import jp.juggler.subwaytooter.view.FocusPointView
import jp.juggler.subwaytooter.view.MyEditText
import jp.juggler.subwaytooter.view.MyNetworkImageView
import jp.juggler.util.*
import kotlinx.coroutines.delay
import kotlinx.coroutines.isActive
import okhttp3.MediaType
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.MultipartBody
import okhttp3.Request
import okhttp3.RequestBody
import okio.BufferedSink
import org.jetbrains.anko.textColor
import ru.gildor.coroutines.okhttp.await
import java.io.*
import java.lang.ref.WeakReference
import java.util.*
import java.util.concurrent.ConcurrentHashMap
import java.util.concurrent.ConcurrentLinkedQueue
import java.util.concurrent.atomic.AtomicBoolean

class ActPost : AsyncActivity(),
    View.OnClickListener,
    PostAttachment.Callback {

    companion object {

        internal val log = LogCategory("ActPost")

        internal const val EXTRA_POSTED_ACCT = "posted_acct"
        internal const val EXTRA_POSTED_STATUS_ID = "posted_status_id"
        internal const val EXTRA_POSTED_REPLY_ID = "posted_reply_id"
        internal const val EXTRA_POSTED_REDRAFT_ID = "posted_redraft_id"

        internal const val KEY_ACCOUNT_DB_ID = "account_db_id"
        internal const val KEY_REPLY_STATUS = "reply_status"
        internal const val KEY_REDRAFT_STATUS = "redraft_status"
        internal const val KEY_INITIAL_TEXT = "initial_text"
        internal const val KEY_SENT_INTENT = "sent_intent"
        internal const val KEY_QUOTE = "quote"
        internal const val KEY_SCHEDULED_STATUS = "scheduled_status"

        internal const val KEY_ATTACHMENT_LIST = "attachment_list"
        internal const val KEY_VISIBILITY = "visibility"
        internal const val KEY_IN_REPLY_TO_ID = "in_reply_to_id"
        internal const val KEY_IN_REPLY_TO_TEXT = "in_reply_to_text"
        internal const val KEY_IN_REPLY_TO_IMAGE = "in_reply_to_image"
        internal const val KEY_IN_REPLY_TO_URL = "in_reply_to_url"

        private const val REQUEST_CODE_ATTACHMENT = 1
        private const val REQUEST_CODE_CAMERA = 2
        private const val REQUEST_CODE_MUSHROOM = 3
        private const val REQUEST_CODE_VIDEO = 4
        private const val REQUEST_CODE_ATTACHMENT_OLD = 5
        private const val REQUEST_CODE_SOUND = 6
        private const val REQUEST_CODE_CUSTOM_THUMBNAIL = 7

        private const val PERMISSION_REQUEST_CODE = 1

        internal const val MIME_TYPE_JPEG = "image/jpeg"
        internal const val MIME_TYPE_PNG = "image/png"


        internal val acceptable_mime_types = HashSet<String>().apply {
            //
            add("image/*") // Android標準のギャラリーが image/* を出してくることがあるらしい
            add("video/*") // Android標準のギャラリーが image/* を出してくることがあるらしい
            add("audio/*") // Android標準のギャラリーが image/* を出してくることがあるらしい
            //
            add("image/jpeg")
            add("image/png")
            add("image/gif")
            add("video/webm")
            add("video/mp4")
            add("video/quicktime")
            //
            add("audio/webm")
            add("audio/ogg")
            add("audio/mpeg")
            add("audio/mp3")
            add("audio/wav")
            add("audio/wave")
            add("audio/x-wav")
            add("audio/x-pn-wav")
            add("audio/flac")
            add("audio/x-flac")

            // https://github.com/tootsuite/mastodon/pull/11342
            add("audio/aac")
            add("audio/m4a")
            add("audio/3gpp")
        }
        internal val acceptable_mime_types_pixelfed = HashSet<String>().apply {
            //
            add("image/*") // Android標準のギャラリーが image/* を出してくることがあるらしい
            add("video/*") // Android標準のギャラリーが image/* を出してくることがあるらしい
            //
            add("image/jpeg")
            add("image/png")
            add("image/gif")
            add("video/mp4")
            add("video/m4v")
        }

        private val imageHeaderList = arrayOf(
            Pair(
                "image/jpeg",
                intArrayOf(0xff, 0xd8, 0xff).toByteArray()
            ),
            Pair(
                "image/png",
                intArrayOf(0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A).toByteArray()
            ),
            Pair(
                "image/gif",
                charArrayOf('G', 'I', 'F').toLowerByteArray()
            ),
            Pair(
                "audio/wav",
                charArrayOf('R', 'I', 'F', 'F').toLowerByteArray()
            ),
            Pair(
                "audio/ogg",
                charArrayOf('O', 'g', 'g', 'S').toLowerByteArray()
            ),
            Pair(
                "audio/flac",
                charArrayOf('f', 'L', 'a', 'C').toLowerByteArray()
            )
        )

        private val sig3gp = arrayOf(
            "3ge6",
            "3ge7",
            "3gg6",
            "3gp1",
            "3gp2",
            "3gp3",
            "3gp4",
            "3gp5",
            "3gp6",
            "3gp7",
            "3gr6",
            "3gr7",
            "3gs6",
            "3gs7",
            "kddi"
        ).map { it.toCharArray().toLowerByteArray() }

        private val sigM4a = arrayOf(
            "M4A ",
            "M4B ",
            "M4P "
        ).map { it.toCharArray().toLowerByteArray() }

        private val sigFtyp = "ftyp".toCharArray().toLowerByteArray()

        private fun matchSig(
            data: ByteArray,
            dataOffset: Int,
            sig: ByteArray,
            sigSize: Int = sig.size
        ): Boolean {
            for (i in 0 until sigSize) {
                if (data[dataOffset + i] != sig[i]) return false
            }
            return true
        }

        private fun findMimeTypeByFileHeader(
            contentResolver: ContentResolver,
            uri: Uri
        ): String? {
            try {
                contentResolver.openInputStream(uri)?.use { inStream ->
                    val data = ByteArray(65536)
                    val nRead = inStream.read(data, 0, data.size)
                    for (pair in imageHeaderList) {
                        val type = pair.first
                        val header = pair.second
                        if (nRead >= header.size && data.startWith(header)) return type
                    }

                    // scan frame header
                    for (i in 0 until nRead - 8) {

                        if (!matchSig(data, i, sigFtyp)) continue

                        // 3gpp check
                        for (s in sig3gp) {
                            if (matchSig(data, i + 4, s)) return "audio/3gpp"
                        }

                        // m4a check
                        for (s in sigM4a) {
                            if (matchSig(data, i + 4, s)) return "audio/m4a"
                        }

                    }

                    // scan frame header
                    loop@ for (i in 0 until nRead - 2) {

                        // mpeg frame header
                        val b0 = data[i].toInt() and 255
                        if (b0 != 255) continue
                        val b1 = data[i + 1].toInt() and 255
                        if ((b1 and 0b11100000) != 0b11100000) continue

                        val mpegVersionId = ((b1 shr 3) and 3)
                        // 00 mpeg 2.5
                        // 01 not used
                        // 10 (mp3) mpeg 2 / (AAC) mpeg-4
                        // 11 (mp3) mpeg 1 / (AAC) mpeg-2

                        @Suppress("MoveVariableDeclarationIntoWhen")
                        val mpegLayerId = ((b1 shr 1) and 3)
                        // 00 (mp3)not used / (AAC) always 0
                        // 01 (mp3)layer III
                        // 10 (mp3)layer II
                        // 11 (mp3)layer I

                        when (mpegLayerId) {
                            0 -> when (mpegVersionId) {
                                2, 3 -> return "audio/aac"

                                else -> {
                                }
                            }
                            1 -> when (mpegVersionId) {
                                0, 2, 3 -> return "audio/mp3"

                                else -> {
                                }
                            }
                        }
                    }
                }
            } catch (ex: Throwable) {
                log.e(ex, "findMimeTypeByFileHeader failed.")
            }
            return null
        }

        /////////////////////////////////////////////////

        const val DRAFT_CONTENT = "content"
        const val DRAFT_CONTENT_WARNING = "content_warning"
        internal const val DRAFT_CONTENT_WARNING_CHECK = "content_warning_check"
        internal const val DRAFT_NSFW_CHECK = "nsfw_check"
        internal const val DRAFT_VISIBILITY = "visibility"
        internal const val DRAFT_ACCOUNT_DB_ID = "account_db_id"
        internal const val DRAFT_ATTACHMENT_LIST = "attachment_list"
        internal const val DRAFT_REPLY_ID = "reply_id"
        internal const val DRAFT_REPLY_TEXT = "reply_text"
        internal const val DRAFT_REPLY_IMAGE = "reply_image"
        internal const val DRAFT_REPLY_URL = "reply_url"
        internal const val DRAFT_IS_ENQUETE = "is_enquete"
        internal const val DRAFT_POLL_TYPE = "poll_type"
        internal const val DRAFT_POLL_MULTIPLE = "poll_multiple"
        internal const val DRAFT_POLL_HIDE_TOTALS = "poll_hide_totals"
        internal const val DRAFT_POLL_EXPIRE_DAY = "poll_expire_day"
        internal const val DRAFT_POLL_EXPIRE_HOUR = "poll_expire_hour"
        internal const val DRAFT_POLL_EXPIRE_MINUTE = "poll_expire_minute"
        internal const val DRAFT_ENQUETE_ITEMS = "enquete_items"
        internal const val DRAFT_QUOTE = "quotedRenote" // 歴史的な理由で名前がMisskey用になってる

        private const val STATE_MUSHROOM_INPUT = "mushroom_input"
        private const val STATE_MUSHROOM_START = "mushroom_start"
        private const val STATE_MUSHROOM_END = "mushroom_end"
        private const val STATE_REDRAFT_STATUS_ID = "redraft_status_id"
        private const val STATE_URI_CAMERA_IMAGE = "uri_camera_image"
        private const val STATE_TIME_SCHEDULE = "time_schedule"
        private const val STATE_SCHEDULED_STATUS = "scheduled_status"

        fun open(
            activity: Activity,
            request_code: Int,
            account_db_id: Long,

            // 再編集する投稿。アカウントと同一のタンスであること
            redraft_status: TootStatus? = null,

            // 返信対象の投稿。同一タンス上に同期済みであること
            reply_status: TootStatus? = null,

            //初期テキスト
            initial_text: String? = null,

            // 外部アプリから共有されたインテント
            sent_intent: Intent? = null,

            // 返信ではなく引用トゥートを作成する
            quote: Boolean = false,

            //(Mastodon) 予約投稿の編集
            scheduledStatus: TootScheduled? = null

        ) {
            val intent = Intent(activity, ActPost::class.java)
            intent.putExtra(KEY_ACCOUNT_DB_ID, account_db_id)

            if (redraft_status != null) {
                intent.putExtra(KEY_REDRAFT_STATUS, redraft_status.json.toString())
            }

            if (reply_status != null) {
                intent.putExtra(KEY_REPLY_STATUS, reply_status.json.toString())
                intent.putExtra(KEY_QUOTE, quote)
            }

            if (initial_text != null) {
                intent.putExtra(KEY_INITIAL_TEXT, initial_text)
            }

            if (sent_intent != null) {
                intent.putExtra(KEY_SENT_INTENT, sent_intent)
            }
            if (scheduledStatus != null) {
                intent.putExtra(KEY_SCHEDULED_STATUS, scheduledStatus.src.toString())
            }
            activity.startActivityForResult(intent, request_code)
        }

        internal suspend fun check_exist(url: String?): Boolean {
            if (url?.isEmpty() != false) return false
            try {
                val request = Request.Builder().url(url).build()
                val call = App1.ok_http_client.newCall(request)
                val response = call.await()
                if (response.isSuccessful) return true

                log.e(TootApiClient.formatResponse(response,"check_exist failed."))
            } catch (ex: Throwable) {
                log.trace(ex)
            }
            return false
        }
    }

    private lateinit var btnAccount: Button
    private lateinit var btnVisibility: ImageButton
    private lateinit var btnAttachment: ImageButton
    private lateinit var btnPost: ImageButton
    private lateinit var llAttachment: View
    private lateinit var ivMedia: List<MyNetworkImageView>
    private lateinit var cbNSFW: CheckBox
    private lateinit var cbContentWarning: CheckBox
    private lateinit var etContentWarning: MyEditText
    private lateinit var etContent: MyEditText
    private lateinit var btnFeaturedTag: ImageButton

    private lateinit var cbQuote: CheckBox

    private lateinit var spEnquete: Spinner
    private lateinit var llEnquete: View
    private lateinit var list_etChoice: List<MyEditText>

    private lateinit var cbMultipleChoice: CheckBox
    private lateinit var cbHideTotals: CheckBox
    private lateinit var llExpire: LinearLayout
    private lateinit var etExpireDays: EditText
    private lateinit var etExpireHours: EditText
    private lateinit var etExpireMinutes: EditText

    private lateinit var tvCharCount: TextView
    internal lateinit var handler: Handler
    private lateinit var formRoot: View

    private lateinit var llReply: View
    private lateinit var tvReplyTo: TextView
    private lateinit var btnRemoveReply: ImageButton
    private lateinit var ivReply: MyNetworkImageView
    private lateinit var scrollView: ScrollView

    private lateinit var tvSchedule: TextView
    private lateinit var ibSchedule: ImageButton
    private lateinit var ibScheduleReset: ImageButton

    internal lateinit var pref: SharedPreferences
    internal lateinit var app_state: AppState
    private lateinit var post_helper: PostHelper
    private var attachment_list = ArrayList<PostAttachment>()
    private var isPostComplete: Boolean = false

    internal var density: Float = 0f

    private lateinit var account_list: ArrayList<SavedAccount>

    private var redraft_status_id: EntityId? = null

    private var timeSchedule = 0L

    private var scheduledStatus: TootScheduled? = null

    private val text_watcher: TextWatcher = object : TextWatcher {
        override fun beforeTextChanged(charSequence: CharSequence, i: Int, i1: Int, i2: Int) {

        }

        override fun onTextChanged(charSequence: CharSequence, i: Int, i1: Int, i2: Int) {

        }

        override fun afterTextChanged(editable: Editable) {
            updateTextCount()
        }
    }

    private val scroll_listener: ViewTreeObserver.OnScrollChangedListener =
        ViewTreeObserver.OnScrollChangedListener { post_helper.onScrollChanged() }

    //////////////////////////////////////////////////////////
    // Account

    internal var account: SavedAccount? = null

    private var uriCameraImage: Uri? = null

    //////////////////////////////////////////////////////////////////////
    // visibility

    internal var visibility: TootVisibility? = null

    /////////////////////////////////////////////////

    internal var in_reply_to_id: EntityId? = null
    private var in_reply_to_text: String? = null
    private var in_reply_to_image: String? = null
    private var in_reply_to_url: String? = null
    private var mushroom_input: Int = 0
    private var mushroom_start: Int = 0
    private var mushroom_end: Int = 0

    private val link_click_listener: (View, MyClickableSpan) -> Unit = { _, span ->
        openBrowser(span.linkInfo.url)
    }

    ////////////////////////////////////////////////////////////////

    override fun onClick(v: View) {
        when (v.id) {
            R.id.btnAccount -> performAccountChooser()
            R.id.btnVisibility -> performVisibility()
            R.id.btnAttachment -> openAttachment()
            R.id.ivMedia1 -> performAttachmentClick(0)
            R.id.ivMedia2 -> performAttachmentClick(1)
            R.id.ivMedia3 -> performAttachmentClick(2)
            R.id.ivMedia4 -> performAttachmentClick(3)
            R.id.btnPost -> performPost()
            R.id.btnRemoveReply -> removeReply()
            R.id.btnMore -> performMore()
            R.id.btnPlugin -> openMushroom()
            R.id.btnEmojiPicker -> post_helper.openEmojiPickerFromMore()
            R.id.btnFeaturedTag -> post_helper.openFeaturedTagList(
                featuredTagCache[account?.acct?.ascii ?: ""]?.list
            )
            R.id.ibSchedule -> performSchedule()
            R.id.ibScheduleReset -> resetSchedule()
        }
    }

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        if (resultCode != RESULT_OK) {
            when (requestCode) {
                REQUEST_CODE_CAMERA -> {
                    // 失敗したら DBからデータを削除
                    val uriCameraImage = this.uriCameraImage
                    if (uriCameraImage != null) {
                        contentResolver.delete(uriCameraImage, null, null)
                        this@ActPost.uriCameraImage = null
                    }
                }
            }
        } else {
            when (requestCode) {
                REQUEST_CODE_CUSTOM_THUMBNAIL -> uploadCustomThumbnail(
                    data?.handleGetContentResult(
                        contentResolver
                    )
                )

                REQUEST_CODE_ATTACHMENT_OLD -> checkAttachments(
                    data?.handleGetContentResult(
                        contentResolver
                    )
                )
                REQUEST_CODE_ATTACHMENT -> checkAttachments(
                    data?.handleGetContentResult(
                        contentResolver
                    )
                )

                REQUEST_CODE_CAMERA -> {
                    // 画像のURL
                    val uri = data?.data ?: uriCameraImage
                    if (uri != null) {
                        addAttachment(uri)
                    } else {
                        showToast(false, "missing image uri")
                    }
                }

                REQUEST_CODE_VIDEO, REQUEST_CODE_SOUND -> data?.data?.let { addAttachment(it) }

                REQUEST_CODE_MUSHROOM -> {
                    data?.getStringExtra("replace_key")?.let { applyMushroomResult(it) }
                }
            }
        }

        super.onActivityResult(requestCode, resultCode, data)
    }

    override fun onBackPressed() {
        saveDraft()
        super.onBackPressed()
    }

    override fun onResume() {
        super.onResume()
        MyClickableSpan.link_callback = WeakReference(link_click_listener)
    }

    override fun onPause() {
        super.onPause()

        // 編集中にホーム画面を押したり他アプリに移動する場合は下書きを保存する
        // やや過剰な気がするが、自アプリに戻ってくるときにランチャーからアイコンタップされると
        // メイン画面より上にあるアクティビティはすべて消されてしまうので
        // このタイミングで保存するしかない
        if (!isPostComplete) {
            saveDraft()
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {

        var sv: String?

        super.onCreate(savedInstanceState)
        App1.setActivityTheme(this, noActionBar = true)

        app_state = App1.getAppState(this)
        pref = app_state.pref

        initUI()

        // Android 9 から、明示的にフォーカスを当てる必要がある
        if (savedInstanceState == null) {
            etContent.requestFocus()
        }

        if (account_list.isEmpty()) {
            showToast(true, R.string.please_add_account)
            finish()
            return
        }

        if (savedInstanceState != null) {

            mushroom_input = savedInstanceState.getInt(STATE_MUSHROOM_INPUT, 0)
            mushroom_start = savedInstanceState.getInt(STATE_MUSHROOM_START, 0)
            mushroom_end = savedInstanceState.getInt(STATE_MUSHROOM_END, 0)
            redraft_status_id = EntityId.from(savedInstanceState, STATE_REDRAFT_STATUS_ID)
            timeSchedule = savedInstanceState.getLong(STATE_TIME_SCHEDULE, 0L)


            savedInstanceState.getString(STATE_URI_CAMERA_IMAGE).mayUri()?.let {
                uriCameraImage = it
            }

            val account_db_id =
                savedInstanceState.getLong(KEY_ACCOUNT_DB_ID, SavedAccount.INVALID_DB_ID)
            if (account_db_id != SavedAccount.INVALID_DB_ID) {
                var i = 0
                val ie = account_list.size
                while (i < ie) {
                    val a = account_list[i]
                    if (a.db_id == account_db_id) {
                        selectAccount(a)
                        break
                    }
                    ++i
                }
            }

            this.visibility = TootVisibility.fromId(savedInstanceState.getInt(KEY_VISIBILITY, -1))

            val a = account
            if (a != null) {
                savedInstanceState.getString(STATE_SCHEDULED_STATUS)?.let {
                    scheduledStatus =
                        parseItem(
                            ::TootScheduled,
                            TootParser(this@ActPost, a),
                            it.decodeJsonObject(),
                            log
                        )
                }
            }

            if (app_state.attachment_list != null) {

                val list_in_state = app_state.attachment_list
                if (list_in_state != null) {
                    // static なデータが残ってるならそれを使う
                    this.attachment_list = list_in_state
                }

                // コールバックを新しい画面に差し替える
                for (pa in attachment_list) {
                    pa.callback = this
                }

            } else {
                sv = savedInstanceState.getString(KEY_ATTACHMENT_LIST)
                if (sv?.isNotEmpty() == true) {

                    // state から復元する
                    app_state.attachment_list = this.attachment_list
                    this.attachment_list.clear()

                    try {
                        sv.decodeJsonArray().objectList().forEach {
                            try {
                                attachment_list.add(PostAttachment(TootAttachment.decodeJson(it)))
                            } catch (ex: Throwable) {
                                log.trace(ex)
                            }
                        }

                    } catch (ex: Throwable) {
                        log.trace(ex)
                    }

                }
            }

            this.in_reply_to_id = EntityId.from(savedInstanceState, KEY_IN_REPLY_TO_ID)
            this.in_reply_to_text = savedInstanceState.getString(KEY_IN_REPLY_TO_TEXT)
            this.in_reply_to_image = savedInstanceState.getString(KEY_IN_REPLY_TO_IMAGE)
            this.in_reply_to_url = savedInstanceState.getString(KEY_IN_REPLY_TO_URL)
        } else {
            app_state.attachment_list = this.attachment_list
            this.attachment_list.clear()

            val intent = intent
            val account_db_id = intent.getLongExtra(KEY_ACCOUNT_DB_ID, SavedAccount.INVALID_DB_ID)
            if (account_db_id != SavedAccount.INVALID_DB_ID) {
                var i = 0
                val ie = account_list.size
                while (i < ie) {
                    val a = account_list[i]
                    if (a.db_id == account_db_id) {
                        selectAccount(a)
                        break
                    }
                    ++i
                }
            }

            val sent_intent = intent.getParcelableExtra<Intent>(KEY_SENT_INTENT)
            if (sent_intent != null) {

                val hasUri = when (sent_intent.action) {
                    Intent.ACTION_VIEW -> {
                        val uri = sent_intent.data
                        val type = sent_intent.type
                        if (uri != null) {
                            addAttachment(uri, type)
                            true
                        } else {
                            false
                        }
                    }

                    Intent.ACTION_SEND -> {
                        val uri = sent_intent.getParcelableExtra<Uri>(Intent.EXTRA_STREAM)
                        val type = sent_intent.type
                        if (uri != null) {
                            addAttachment(uri, type)
                            true
                        } else {
                            false
                        }
                    }

                    Intent.ACTION_SEND_MULTIPLE -> {
                        val list_uri =
                            sent_intent.getParcelableArrayListExtra<Uri>(Intent.EXTRA_STREAM)
                                ?.filterNotNull()
                        if (list_uri?.isNotEmpty() == true) {
                            for (uri in list_uri) {
                                addAttachment(uri)
                            }
                            true
                        } else {
                            false
                        }
                    }

                    else -> false
                }

                if (!hasUri || !Pref.bpIgnoreTextInSharedMedia(pref)) {
                    appendContentText(sent_intent)
                }
            }

            appendContentText(intent.getStringExtra(KEY_INITIAL_TEXT))

            val account = this.account

            sv = intent.getStringExtra(KEY_REPLY_STATUS)
            if (sv != null && account != null) {
                try {
                    val reply_status =
                        TootParser(this@ActPost, account).status(sv.decodeJsonObject())

                    val isQuote = intent.getBooleanExtra(KEY_QUOTE, false)

                    if (reply_status != null) {

                        if (isQuote) {
                            cbQuote.isChecked = true

                            // 引用リノートはCWやメンションを引き継がない

                        } else {

                            // CW をリプライ元に合わせる
                            if (reply_status.spoiler_text.isNotEmpty()) {
                                cbContentWarning.isChecked = true
                                etContentWarning.setText(reply_status.spoiler_text)
                            }

                            // 新しいメンションリスト
                            val mention_list = ArrayList<Acct>()

                            // 自己レス以外なら元レスへのメンションを追加
                            // 最初に追加する https://github.com/tateisu/SubwayTooter/issues/94
                            if (!account.isMe(reply_status.account)) {
                                mention_list.add(account.getFullAcct(reply_status.account))
                            }

                            // 元レスに含まれていたメンションを複製
                            reply_status.mentions?.forEach { mention ->

                                val who_acct = mention.acct

                                // 空データなら追加しない
                                if (!who_acct.isValid) return@forEach

                                // 自分なら追加しない
                                if (account.isMe(who_acct)) return@forEach

                                // 既出でないなら追加する
                                val acct = account.getFullAcct(who_acct)
                                if (!mention_list.contains(acct)) mention_list.add(acct)
                            }

                            if (mention_list.isNotEmpty()) {
                                appendContentText(
                                    StringBuilder().apply {
                                        for (acct in mention_list) {
                                            if (isNotEmpty()) append(' ')
                                            append("@${acct.ascii}")
                                        }
                                        append(' ')
                                    }.toString()
                                )
                            }
                        }

                        // リプライ表示をつける
                        in_reply_to_id = reply_status.id
                        in_reply_to_text = reply_status.content
                        in_reply_to_image = reply_status.account.avatar_static
                        in_reply_to_url = reply_status.url

                        // 公開範囲
                        try {
                            // 比較する前にデフォルトの公開範囲を計算する
                            visibility = visibility
                                ?: account.visibility
                            //	?: TootVisibility.Public
                            // VISIBILITY_WEB_SETTING だと 1.5未満のタンスでトラブルになる

                            if (visibility == TootVisibility.Unknown) {
                                visibility = TootVisibility.PrivateFollowers
                            }

                            val sample = when (val base = reply_status.visibility) {
                                TootVisibility.Unknown -> TootVisibility.PrivateFollowers
                                else -> base
                            }

                            if (TootVisibility.WebSetting == visibility) {
                                // 「Web設定に合わせる」だった場合は無条件にリプライ元の公開範囲に変更する
                                this.visibility = sample
                            } else if (TootVisibility.isVisibilitySpoilRequired(
                                    this.visibility, sample)) {
                                // デフォルトの方が公開範囲が大きい場合、リプライ元に合わせて公開範囲を狭める
                                this.visibility = sample
                            }


                        } catch (ex: Throwable) {
                            log.trace(ex)
                        }
                    }
                } catch (ex: Throwable) {
                    log.trace(ex)
                }
            }

            appendContentText(account?.default_text, selectBefore = true)

            cbNSFW.isChecked = account?.default_sensitive ?: false

            // 再編集
            sv = intent.getStringExtra(KEY_REDRAFT_STATUS)
            if (sv != null && account != null) {
                try {
                    val base_status =
                        TootParser(this@ActPost, account).status(sv.decodeJsonObject())
                    if (base_status != null) {

                        redraft_status_id = base_status.id

                        this.visibility = base_status.visibility

                        val src_attachments = base_status.media_attachments
                        if (src_attachments?.isNotEmpty() == true) {
                            app_state.attachment_list = this.attachment_list
                            this.attachment_list.clear()
                            try {
                                for (src in src_attachments) {
                                    if (src is TootAttachment) {
                                        src.redraft = true
                                        val pa = PostAttachment(src)
                                        pa.status = PostAttachment.STATUS_UPLOADED
                                        this.attachment_list.add(pa)
                                    }
                                }

                            } catch (ex: Throwable) {
                                log.trace(ex)
                            }
                        }

                        cbNSFW.isChecked = base_status.sensitive == true

                        // 再編集の場合はdefault_textは反映されない

                        val decodeOptions = DecodeOptions(
                            this,
                            mentionFullAcct = true,
                            mentions = base_status.mentions,
                            mentionDefaultHostDomain = account
                        )

                        var text: CharSequence = if (account.isMisskey) {
                            base_status.content ?: ""
                        } else {
                            decodeOptions.decodeHTML(base_status.content)
                        }
                        etContent.setText(text)
                        etContent.setSelection(text.length)

                        text = decodeOptions.decodeEmoji(base_status.spoiler_text)
                        etContentWarning.setText(text)
                        etContentWarning.setSelection(text.length)
                        cbContentWarning.isChecked = text.isNotEmpty()

                        val src_enquete = base_status.enquete
                        val src_items = src_enquete?.items
                        when {
                            src_items == null -> {

                            }

                            src_enquete.pollType == TootPollsType.FriendsNico && src_enquete.type != TootPolls.TYPE_ENQUETE -> {
                                // フレニコAPIのアンケート結果は再編集の対象外
                            }

                            else -> {
                                spEnquete.setSelection(
                                    if (src_enquete.pollType == TootPollsType.FriendsNico) {
                                        2
                                    } else {
                                        1
                                    }
                                )
                                text = decodeOptions.decodeHTML(src_enquete.question)
                                etContent.text = text
                                etContent.setSelection(text.length)

                                var src_index = 0
                                loop@ for (et in list_etChoice) {
                                    if (src_index < src_items.size) {
                                        val choice = src_items[src_index]
                                        when {
                                            src_index == src_items.size - 1 && choice.text == "\uD83E\uDD14" -> {
                                                // :thinking_face: は再現しない
                                            }

                                            else -> {
                                                et.setText(decodeOptions.decodeEmoji(choice.text))
                                                ++src_index
                                                continue@loop
                                            }
                                        }
                                    }
                                    et.setText("")
                                }
                            }
                        }
                    }

                } catch (ex: Throwable) {
                    log.trace(ex)
                }

            }

            // 予約編集の再編集
            sv = intent.getStringExtra(KEY_SCHEDULED_STATUS)
            if (sv != null && account != null) {
                try {
                    val item = parseItem(
                        ::TootScheduled,
                        TootParser(this@ActPost, account),
                        sv.decodeJsonObject(),
                        log
                    )
                    if (item != null) {
                        scheduledStatus = item

                        timeSchedule = item.timeScheduledAt

                        val text = item.text
                        etContent.setText(text)

                        val cw = item.spoiler_text
                        if (cw?.isNotEmpty() == true) {
                            etContentWarning.setText(cw)
                            cbContentWarning.isChecked = true
                        } else {
                            cbContentWarning.isChecked = false
                        }
                        visibility = item.visibility

                        // 2019/1/7 どうも添付データを古い投稿から引き継げないようだ…。
                        // 2019/1/22 https://github.com/tootsuite/mastodon/pull/9894 で直った。
                        val src_attachments = item.media_attachments
                        if (src_attachments?.isNotEmpty() == true) {
                            app_state.attachment_list = this.attachment_list
                            this.attachment_list.clear()
                            try {
                                for (src in src_attachments) {
                                    if (src is TootAttachment) {
                                        src.redraft = true
                                        val pa = PostAttachment(src)
                                        pa.status = PostAttachment.STATUS_UPLOADED
                                        this.attachment_list.add(pa)
                                    }
                                }
                            } catch (ex: Throwable) {
                                log.trace(ex)
                            }
                        }
                        cbNSFW.isChecked = item.sensitive
                    }
                } catch (ex: Throwable) {
                    log.trace(ex)
                }
            }
        }

        visibility = visibility ?: account?.visibility ?: TootVisibility.Public
        // 2017/9/13 VISIBILITY_WEB_SETTING から VISIBILITY_PUBLICに変更した
        // VISIBILITY_WEB_SETTING だと 1.5未満のタンスでトラブルになるので…

        if (this.account == null) {
            // 表示を未選択に更新
            selectAccount(null)
        }

        updateContentWarning()
        showMediaAttachment()
        showVisibility()
        updateTextCount()
        showReplyTo()
        showEnquete()
        showQuotedRenote()
        showSchedule()
    }

    override fun onDestroy() {
        post_helper.onDestroy()
        attachment_worker?.cancel()
        super.onDestroy()
    }

    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)

        outState.putInt(STATE_MUSHROOM_INPUT, mushroom_input)
        outState.putInt(STATE_MUSHROOM_START, mushroom_start)
        outState.putInt(STATE_MUSHROOM_END, mushroom_end)
        redraft_status_id?.putTo(outState, STATE_REDRAFT_STATUS_ID)

        outState.putLong(STATE_TIME_SCHEDULE, timeSchedule)

        if (uriCameraImage != null) {
            outState.putString(STATE_URI_CAMERA_IMAGE, uriCameraImage.toString())
        }

        val account = this.account
        if (account != null) {
            outState.putLong(KEY_ACCOUNT_DB_ID, account.db_id)
        }

        visibility?.let {
            outState.putInt(KEY_VISIBILITY, it.id)
        }

        val array = attachment_list
            // アップロード完了したものだけ保持する
            .filter { it.status == PostAttachment.STATUS_UPLOADED }
            .mapNotNull { it.attachment?.encodeJson() }
            .toJsonArray()
            .notEmpty()

        if (array != null) outState.putString(KEY_ATTACHMENT_LIST, array.toString())

        in_reply_to_id?.putTo(outState, KEY_IN_REPLY_TO_ID)
        outState.putString(KEY_IN_REPLY_TO_TEXT, in_reply_to_text)
        outState.putString(KEY_IN_REPLY_TO_IMAGE, in_reply_to_image)
        outState.putString(KEY_IN_REPLY_TO_URL, in_reply_to_url)
    }

    override fun onRestoreInstanceState(savedInstanceState: Bundle) {
        super.onRestoreInstanceState(savedInstanceState)
        updateContentWarning()
        showMediaAttachment()
        showVisibility()
        updateTextCount()
        showReplyTo()
        showEnquete()
        showQuotedRenote()
    }

    private fun appendContentText(
        src: String?,
        selectBefore: Boolean = false
    ) {
        if (src?.isEmpty() != false) return
        val svEmoji = DecodeOptions(
            context = this,
            decodeEmoji = true,
            mentionDefaultHostDomain = account ?: unknownHostAndDomain
        ).decodeEmoji(src)
        if (svEmoji.isEmpty()) return

        val editable = etContent.text
        if (editable == null) {
            val sb = StringBuilder()
            if (selectBefore) {
                val start = 0
                sb.append(' ')
                sb.append(svEmoji)
                etContent.setText(sb)
                etContent.setSelection(start)
            } else {
                sb.append(svEmoji)
                etContent.setText(sb)
                etContent.setSelection(sb.length)
            }
        } else {
            if (editable.isNotEmpty()
                && !CharacterGroup.isWhitespace(editable[editable.length - 1].code)
            ) {
                editable.append(' ')
            }

            if (selectBefore) {
                val start = editable.length
                editable.append(' ')
                editable.append(svEmoji)
                etContent.text = editable
                etContent.setSelection(start)
            } else {
                editable.append(svEmoji)
                etContent.text = editable
                etContent.setSelection(editable.length)
            }
        }
    }

    private fun appendContentText(src: Intent) {
        val list = ArrayList<String>()

        var sv: String?
        sv = src.getStringExtra(Intent.EXTRA_SUBJECT)
        if (sv?.isNotEmpty() == true) list.add(sv)
        sv = src.getStringExtra(Intent.EXTRA_TEXT)
        if (sv?.isNotEmpty() == true) list.add(sv)

        if (list.isNotEmpty()) {
            appendContentText(list.joinToString(" "))
        }
    }

    private fun initUI() {
        handler = App1.getAppState(this).handler
        density = resources.displayMetrics.density

        setContentView(R.layout.act_post)
        App1.initEdgeToEdge(this)

        if (Pref.bpPostButtonBarTop(this)) {
            val bar = findViewById<View>(R.id.llFooterBar)
            val parent = bar.parent as ViewGroup
            parent.removeView(bar)
            parent.addView(bar, 0)
        }

        Styler.fixHorizontalMargin(findViewById(R.id.scrollView))
        Styler.fixHorizontalMargin(findViewById(R.id.llFooterBar))

        formRoot = findViewById(R.id.viewRoot)
        scrollView = findViewById(R.id.scrollView)
        btnAccount = findViewById(R.id.btnAccount)
        btnVisibility = findViewById(R.id.btnVisibility)
        btnAttachment = findViewById(R.id.btnAttachment)
        btnPost = findViewById(R.id.btnPost)
        llAttachment = findViewById(R.id.llAttachment)

        cbNSFW = findViewById(R.id.cbNSFW)
        cbContentWarning = findViewById(R.id.cbContentWarning)
        etContentWarning = findViewById(R.id.etContentWarning)
        etContent = findViewById(R.id.etContent)
        // https://github.com/tateisu/SubwayTooter/issues/123
        // 早い段階で指定する必要がある
        etContent.inputType = InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_FLAG_MULTI_LINE
        etContent.imeOptions = EditorInfo.IME_ACTION_NONE


        cbQuote = findViewById(R.id.cbQuote)

        spEnquete = findViewById<Spinner>(R.id.spEnquete).apply {
            this.adapter = ArrayAdapter(
                this@ActPost,
                android.R.layout.simple_spinner_item,
                arrayOf(
                    getString(R.string.poll_dont_make),
                    getString(R.string.poll_make),
                    getString(R.string.poll_make_friends_nico)
                )
            ).apply {
                setDropDownViewResource(R.layout.lv_spinner_dropdown)
            }

            this.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
                override fun onNothingSelected(parent: AdapterView<*>?) {
                    showEnquete()
                    updateTextCount()
                }

                override fun onItemSelected(
                    parent: AdapterView<*>?,
                    view: View?,
                    position: Int,
                    id: Long
                ) {
                    showEnquete()
                    updateTextCount()
                }
            }
        }
        llEnquete = findViewById(R.id.llEnquete)
        llExpire = findViewById(R.id.llExpire)
        cbHideTotals = findViewById(R.id.cbHideTotals)
        cbMultipleChoice = findViewById(R.id.cbMultipleChoice)
        etExpireDays = findViewById(R.id.etExpireDays)
        etExpireHours = findViewById(R.id.etExpireHours)
        etExpireMinutes = findViewById(R.id.etExpireMinutes)

        ivMedia = listOf(
            findViewById(R.id.ivMedia1),
            findViewById(R.id.ivMedia2),
            findViewById(R.id.ivMedia3),
            findViewById(R.id.ivMedia4)
        )

        list_etChoice = listOf(
            findViewById(R.id.etChoice1),
            findViewById(R.id.etChoice2),
            findViewById(R.id.etChoice3),
            findViewById(R.id.etChoice4)
        )

        tvCharCount = findViewById(R.id.tvCharCount)

        llReply = findViewById(R.id.llReply)
        tvReplyTo = findViewById(R.id.tvReplyTo)
        btnRemoveReply = findViewById(R.id.btnRemoveReply)
        ivReply = findViewById(R.id.ivReply)

        tvSchedule = findViewById(R.id.tvSchedule)
        ibSchedule = findViewById(R.id.ibSchedule)
        ibScheduleReset = findViewById(R.id.ibScheduleReset)

        ibSchedule.setOnClickListener(this)
        ibScheduleReset.setOnClickListener(this)

        account_list = SavedAccount.loadAccountList(this@ActPost)
        SavedAccount.sort(account_list)

        btnAccount.setOnClickListener(this)
        btnVisibility.setOnClickListener(this)
        btnAttachment.setOnClickListener(this)
        btnPost.setOnClickListener(this)
        btnRemoveReply.setOnClickListener(this)

        btnFeaturedTag = findViewById(R.id.btnFeaturedTag)

        val btnPlugin: ImageButton = findViewById(R.id.btnPlugin)
        val btnEmojiPicker: ImageButton = findViewById(R.id.btnEmojiPicker)
        val btnMore: ImageButton = findViewById(R.id.btnMore)

        btnPlugin.setOnClickListener(this)
        btnEmojiPicker.setOnClickListener(this)
        btnFeaturedTag.setOnClickListener(this)
        btnMore.setOnClickListener(this)

        for (iv in ivMedia) {
            iv.setOnClickListener(this)
        }

        cbContentWarning.setOnCheckedChangeListener { _, _ ->
            updateContentWarning()
        }


        post_helper = PostHelper(this, pref, app_state.handler)
        post_helper.attachEditText(formRoot, etContent, false, object : PostHelper.Callback2 {
            override fun onTextUpdate() {
                updateTextCount()
            }

            override fun canOpenPopup(): Boolean {
                return true
            }
        })

        etContentWarning.addTextChangedListener(text_watcher)
        for (et in list_etChoice) {
            et.addTextChangedListener(text_watcher)
        }

        scrollView.viewTreeObserver.addOnScrollChangedListener(scroll_listener)


        etContent.contentMineTypeArray =
            acceptable_mime_types.toArray(arrayOfNulls<String>(acceptable_mime_types.size))
        etContent.commitContentListener = commitContentListener
    }

    private var lastInstanceTask: TootTaskRunner? = null

    private fun getMaxCharCount(): Int {

        val account = account

        when {
            account == null || account.isPseudo -> {
            }

            else -> {
                // インスタンス情報を確認する
                val info = TootInstance.getCached(account.apiHost.ascii)
                if (info == null || info.isExpire) {
                    // 情報がないか古いなら再取得

                    // 同時に実行するタスクは1つまで
                    if (lastInstanceTask?.isActive != true) {
                        lastInstanceTask = TootTaskRunner(this, TootTaskRunner.PROGRESS_NONE)
                            .run(account, object : TootTask {
                                var newInfo: TootInstance? = null

                                override suspend fun background(client: TootApiClient): TootApiResult? {
                                    val (ti, result) = TootInstance.get(client)
                                    newInfo = ti
                                    return result
                                }

                                override suspend fun handleResult(result: TootApiResult?) {
                                    if (isFinishing || isDestroyed) return
                                    if (newInfo != null) updateTextCount()
                                }
                            })
                        // fall thru
                    }
                    // fall thru
                }

                val max = info?.max_toot_chars
                if (max != null && max > 0) return max
            }
        }

        // アカウント設定で指定した値があるならそれを使う
        val forceMaxTootChars = account?.max_toot_chars
        return when {
            forceMaxTootChars != null && forceMaxTootChars > 0 -> forceMaxTootChars
            else -> 500
        }
    }

    private fun updateTextCount() {
        var length = 0

        length += TootAccount.countText(
            EmojiDecoder.decodeShortCode(etContent.text.toString())
        )

        length += TootAccount.countText(
            if (cbContentWarning.isChecked)
                EmojiDecoder.decodeShortCode(etContentWarning.text.toString())
            else
                ""
        )

        var max = getMaxCharCount()

        fun checkEnqueteLength() {
            for (et in list_etChoice) {
                length += TootAccount.countText(
                    EmojiDecoder.decodeShortCode(et.text.toString())
                )
            }
        }

        when (spEnquete.selectedItemPosition) {
            1 -> checkEnqueteLength()

            2 -> {
                max -= 150 // フレニコ固有。500-150で350になる
                checkEnqueteLength()
            }
        }

        val remain = max - length

        tvCharCount.text = remain.toString()
        tvCharCount.setTextColor(
            attrColor(
                if (remain < 0)
                    R.attr.colorRegexFilterError
                else
                    android.R.attr.textColorPrimary
            )
        )
    }

    class FeaturedTagCache(
        val list: List<TootTag>,
        val time: Long
    )

    // key is SavedAccount.acctAscii
    private val featuredTagCache = ConcurrentHashMap<String, FeaturedTagCache>()
    private var lastFeaturedTagTask: TootTaskRunner? = null

    private fun updateFeaturedTags() {

        val account = account
        if (account == null || account.isPseudo) {
            return
        }

        val cache = featuredTagCache[account.acct.ascii]

        val now = SystemClock.elapsedRealtime()
        if (cache != null && now - cache.time <= 300000L) return

        // 同時に実行するタスクは1つまで
        var lastTask = lastFeaturedTagTask
        if (lastTask?.isActive != true) {
            lastTask = TootTaskRunner(this, TootTaskRunner.PROGRESS_NONE)
            lastFeaturedTagTask = lastTask
            lastTask.run(account, object : TootTask {

                override suspend fun background(client: TootApiClient): TootApiResult? {
                    return if (account.isMisskey) {
                        client.request(
                            "/api/hashtags/trend",
                            jsonObject { }
                                .toPostRequestBuilder()
                        )?.also { result ->
                            val list = TootTag.parseList(
                                TootParser(this@ActPost, account),
                                result.jsonArray
                            )
                            featuredTagCache[account.acct.ascii] =
                                FeaturedTagCache(list, SystemClock.elapsedRealtime())
                        }
                    } else {
                        client.request("/api/v1/featured_tags")?.also { result ->
                            val list = TootTag.parseList(
                                TootParser(this@ActPost, account),
                                result.jsonArray
                            )
                            featuredTagCache[account.acct.ascii] =
                                FeaturedTagCache(list, SystemClock.elapsedRealtime())
                        }
                    }
                }

                override suspend fun handleResult(result: TootApiResult?) {
                    if (isFinishing || isDestroyed) return
                    updateFeaturedTags()
                }
            })
        }
    }

    private fun updateContentWarning() {
        etContentWarning.visibility = if (cbContentWarning.isChecked) View.VISIBLE else View.GONE
    }

    private fun selectAccount(a: SavedAccount?) {
        this.account = a

        post_helper.setInstance(a)

        if (a == null) {
            btnAccount.text = getString(R.string.not_selected)
            btnAccount.setTextColor(attrColor(android.R.attr.textColorPrimary))
            btnAccount.setBackgroundResource(R.drawable.btn_bg_transparent_round6dp)
        } else {

            // 先読みしてキャッシュに保持しておく
            App1.custom_emoji_lister.getList(a) {
                // 何もしない
            }

            val ac = AcctColor.load(a)
            btnAccount.text = ac.nickname

            if (AcctColor.hasColorBackground(ac)) {
                btnAccount.background =
                    getAdaptiveRippleDrawableRound(this, ac.color_bg, ac.color_fg)
            } else {
                btnAccount.setBackgroundResource(R.drawable.btn_bg_transparent_round6dp)
            }

            btnAccount.textColor = ac.color_fg.notZero()
                ?: attrColor(android.R.attr.textColorPrimary)
        }
        updateTextCount()
        updateFeaturedTags()
    }

    private fun performAccountChooser() {

        if (scheduledStatus != null) {
            // 予約投稿の再編集ではアカウントを切り替えられない
            showToast(false, R.string.cant_change_account_when_editing_scheduled_status)
            return
        }

        if (attachment_list.isNotEmpty()) {
            // 添付ファイルがあったら確認の上添付ファイルを捨てないと切り替えられない
            showToast(false, R.string.cant_change_account_when_attachment_specified)
            return
        }

        if (redraft_status_id != null) {
            // 添付ファイルがあったら確認の上添付ファイルを捨てないと切り替えられない
            showToast(false, R.string.cant_change_account_when_redraft)
            return
        }

        AccountPicker.pick(
            this,
            bAllowPseudo = false,
            bAuto = false,
            message = getString(R.string.choose_account)
        ) { ai ->

            // 別タンスのアカウントに変更したならならin_reply_toの変換が必要
            if (in_reply_to_id != null && ai.apiHost != account?.apiHost) {
                startReplyConversion(ai)
            } else {
                setAccountWithVisibilityConversion(ai)
            }
        }

        //		final ArrayList< SavedAccount > tmp_account_list = new ArrayList<>();
        //		tmp_account_list.addAll( account_list );
        //
        //		String[] caption_list = new String[ tmp_account_list.size() ];
        //		for( int i = 0, ie = tmp_account_list.size() ; i < ie ; ++ i ){
        //			caption_list[ i ] = tmp_account_list.get( i ).acct;
        //		}
        //
        //		new AlertDialog.Builder( this )
        //			.setTitle( R.string.choose_account )
        //			.setItems( caption_list, new DialogInterface.OnClickListener() {
        //				@Override
        //				public void onClick( DialogInterface dialog, int which ){
        //
        //					if( which < 0 || which >= tmp_account_list.size() ){
        //						// 範囲外
        //						return;
        //					}
        //
        //					SavedAccount ai = tmp_account_list.get( which );
        //
        //					if( ! ai.host.equals( account.host ) ){
        //						// 別タンスへの移動
        //						if( in_reply_to_id != - 1L ){
        //							// 別タンスのアカウントならin_reply_toの変換が必要
        //							startReplyConversion( ai );
        //
        //						}
        //					}
        //
        //					// リプライがないか、同タンスへの移動
        //					setAccountWithVisibilityConversion( ai );
        //				}
        //			} )
        //			.setNegativeButton( R.string.cancel, null )
        //			.show();
    }

    internal fun setAccountWithVisibilityConversion(a: SavedAccount) {
        selectAccount(a)
        try {
            if (TootVisibility.isVisibilitySpoilRequired(this.visibility, a.visibility)) {
                showToast(true, R.string.spoil_visibility_for_account)
                this.visibility = a.visibility
            }

        } catch (ex: Throwable) {
            log.trace(ex)
        }
        showVisibility()
        showQuotedRenote()
        updateTextCount()
    }

    @SuppressLint("StaticFieldLeak")
    private fun startReplyConversion(access_info: SavedAccount) {

        val in_reply_to_url = this.in_reply_to_url

        if (in_reply_to_url == null) {
            // 下書きが古い形式の場合、URLがないので別タンスへの移動ができない
            AlertDialog.Builder(this@ActPost)
                .setMessage(R.string.account_change_failed_old_draft_has_no_in_reply_to_url)
                .setNeutralButton(R.string.close, null)
                .show()
            return
        }

        TootTaskRunner(this)
            .progressPrefix(getString(R.string.progress_synchronize_toot))
            .run(access_info, object : TootTask {

                var target_status: TootStatus? = null
                override suspend fun background(client: TootApiClient): TootApiResult? {
                    val (result, localStatus) = client.syncStatus(access_info, in_reply_to_url)
                    target_status = localStatus
                    return result
                }

                override suspend fun handleResult(result: TootApiResult?) {
                    if (result == null) return  // cancelled.

                    val target_status = this.target_status
                    if (target_status != null) {
                        in_reply_to_id = target_status.id
                        setAccountWithVisibilityConversion(access_info)
                    } else {
                        showToast(
                            true,
                            getString(R.string.in_reply_to_id_conversion_failed) + "\n" + result.error
                        )
                    }
                }
            })

    }

    //////////////////////////////////////////////////////////
    // Attachment

    private fun showMediaAttachment() {

        if (isFinishing) return

        llAttachment.vg(attachment_list.isNotEmpty())
        ivMedia.forEachIndexed { i, v -> showAttachment_sub(v, i) }
    }

    private fun showAttachment_sub(iv: MyNetworkImageView, idx: Int) {
        if (idx >= attachment_list.size) {
            iv.visibility = View.GONE
        } else {
            iv.visibility = View.VISIBLE
            val pa = attachment_list[idx]
            val a = pa.attachment
            when {

                a == null || pa.status != PostAttachment.STATUS_UPLOADED -> {
                    iv.setDefaultImage(defaultColorIcon(this, R.drawable.ic_upload))
                    iv.setErrorImage(defaultColorIcon(this, R.drawable.ic_clip))
                    iv.setImageUrl(pref, Styler.calcIconRound(iv.layoutParams.width), null)
                }

                else -> {
                    val defaultIconId = when (a.type) {
                        TootAttachmentType.Image -> R.drawable.ic_image
                        TootAttachmentType.Video,
                        TootAttachmentType.GIFV -> R.drawable.ic_videocam
                        TootAttachmentType.Audio -> R.drawable.ic_music_note
                        else -> R.drawable.ic_clip
                    }
                    iv.setDefaultImage(defaultColorIcon(this, defaultIconId))
                    iv.setErrorImage(defaultColorIcon(this, defaultIconId))
                    iv.setImageUrl(pref, Styler.calcIconRound(iv.layoutParams.width), a.preview_url)
                }
            }
        }
    }

    // 添付した画像をタップ
    private fun performAttachmentClick(idx: Int) {
        val pa = try {
            attachment_list[idx]
        } catch (ex: Throwable) {
            showToast(false, ex.withCaption("can't get attachment item[$idx]."))
            return
        }

        val a = ActionsDialog()
            .addAction(getString(R.string.set_description)) {
                editAttachmentDescription(pa)
            }

        if (pa.attachment?.canFocus == true) {
            a.addAction(getString(R.string.set_focus_point)) {
                openFocusPoint(pa)
            }
        }
        if (account?.isMastodon == true) {
            when (pa.attachment?.type) {
                TootAttachmentType.Audio, TootAttachmentType.GIFV, TootAttachmentType.Video ->
                    a.addAction(getString(R.string.custom_thumbnail)) {
                        openCustomThumbnail(pa)
                    }

                else -> {
                }
            }
        }

        a.addAction(getString(R.string.delete)) {
            deleteAttachment(pa)
        }

        a.show(this, title = getString(R.string.media_attachment))
    }

    private fun openFocusPoint(pa: PostAttachment) {
        val attachment = pa.attachment ?: return
        DlgFocusPoint(this, attachment)
            .setCallback(object : FocusPointView.Callback {
                override fun onFocusPointUpdate(x: Float, y: Float) {
                    val account = this@ActPost.account ?: return

                    TootTaskRunner(this@ActPost, TootTaskRunner.PROGRESS_NONE).run(account,
                        object : TootTask {
                            override suspend fun background(client: TootApiClient): TootApiResult? {
                                try {
                                    val result = client.request(
                                        "/api/v1/media/${attachment.id}",
                                        jsonObject {
                                            put("focus", "%.2f,%.2f".format(x, y))
                                        }
                                            .toPutRequestBuilder()
                                    )
                                    new_attachment =
                                        parseItem(
                                            ::TootAttachment,
                                            ServiceType.MASTODON,
                                            result?.jsonObject
                                        )
                                    return result
                                } catch (ex: Throwable) {
                                    return TootApiResult(ex.withCaption("set focus point failed."))
                                }
                            }

                            var new_attachment: TootAttachment? = null

                            override suspend fun handleResult(result: TootApiResult?) {
                                result ?: return
                                if (new_attachment != null) {
                                    pa.attachment = attachment
                                } else {
                                    showToast(true, result.error)
                                }
                            }
                        })
                }
            })
            .show()
    }

    private fun openCustomThumbnail(pa: PostAttachment) {

        lastPostAttachment = pa

        val permissionCheck =
            ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
        if (permissionCheck != PackageManager.PERMISSION_GRANTED) {
            preparePermission()
            return
        }

        // SAFのIntentで開く
        try {
            val intent =
                intentGetContent(false, getString(R.string.pick_images), arrayOf("image/*"))
            startActivityForResult(intent, REQUEST_CODE_CUSTOM_THUMBNAIL)
        } catch (ex: Throwable) {
            log.trace(ex)
            showToast(ex, "ACTION_GET_CONTENT failed.")
        }
    }

    private var lastPostAttachment: PostAttachment? = null

    private fun uploadCustomThumbnail(srcList: ArrayList<GetContentResultEntry>?) {
        val src = srcList?.elementAtOrNull(0) ?: return

        val account = this@ActPost.account
        if (account == null) {
            showToast(false, R.string.account_select_please)
            return
        }

        val mime_type = getMimeType(src.uri, src.mimeType)
        if (mime_type?.isEmpty() != false) {
            showToast(false, R.string.mime_type_missing)
            return
        }

        val pa = lastPostAttachment
        if (pa == null || !attachment_list.contains(pa)) {
            showToast(true, "lost attachment information")
            return
        }

        TootTaskRunner(this).run(account, object : TootTask {

            @Suppress("BlockingMethodInNonBlockingContext")
            override suspend fun background(client: TootApiClient): TootApiResult? {
                try {
                    val (ti, tiResult) = TootInstance.get(client)
                    ti ?: return tiResult

                    val resizeConfig = ResizeConfig(ResizeType.SquarePixel, 400)

                    val opener = createOpener(src.uri, mime_type, resizeConfig)

                    val media_size_max = 1000000

                    val content_length = getStreamSize(true, opener.open())
                    if (content_length > media_size_max) {
                        return TootApiResult(
                            getString(
                                R.string.file_size_too_big,
                                media_size_max / 1000000
                            )
                        )
                    }

                    fun fixDocumentName(s: String): String {
                        val s_length = s.length
                        val m = """([^\x20-\x7f])""".asciiPattern().matcher(s)
                        m.reset()
                        val sb = StringBuilder(s_length)
                        var lastEnd = 0
                        while (m.find()) {
                            sb.append(s.substring(lastEnd, m.start()))
                            val escaped = m.groupEx(1)!!.encodeUTF8().encodeHex()
                            sb.append(escaped)
                            lastEnd = m.end()
                        }
                        if (lastEnd < s_length) sb.append(s.substring(lastEnd, s_length))
                        return sb.toString()
                    }

                    val fileName = fixDocumentName(getDocumentName(contentResolver, src.uri))

                    return if (account.isMisskey) {
                        opener.deleteTempFile()
                        TootApiResult("custom thumbnail is not supported on misskey account.")
                    } else {
                        val result = client.request(
                            "/api/v1/media/${pa.attachment?.id}",
                            MultipartBody.Builder()
                                .setType(MultipartBody.FORM)
                                .addFormDataPart(
                                    "thumbnail",
                                    fileName,
                                    object : RequestBody() {
                                        override fun contentType(): MediaType {
                                            return opener.mimeType.toMediaType()
                                        }

                                        @Throws(IOException::class)
                                        override fun contentLength(): Long {
                                            return content_length
                                        }

                                        @Throws(IOException::class)
                                        override fun writeTo(sink: BufferedSink) {
                                            opener.open().use { inData ->
                                                val tmp = ByteArray(4096)
                                                while (true) {
                                                    val r = inData.read(tmp, 0, tmp.size)
                                                    if (r <= 0) break
                                                    sink.write(tmp, 0, r)
                                                }
                                            }
                                        }
                                    }
                                )
                                .build().toPut()
                        )
                        opener.deleteTempFile()

                        val jsonObject = result?.jsonObject
                        if (jsonObject != null) {
                            val a = parseItem(::TootAttachment, ServiceType.MASTODON, jsonObject)
                            if (a == null) {
                                result.error = "TootAttachment.parse failed"
                            } else {
                                pa.attachment = a
                            }
                        }
                        result
                    }

                } catch (ex: Throwable) {
                    return TootApiResult(ex.withCaption("read failed."))
                }
            }

            override suspend fun handleResult(result: TootApiResult?) {
                showMediaAttachment()
                result?.error?.let { showToast(true, it) }
            }
        })
    }

    private fun deleteAttachment(pa: PostAttachment) {
        AlertDialog.Builder(this)
            .setTitle(R.string.confirm_delete_attachment)
            .setPositiveButton(R.string.ok) { _, _ ->
                try {
                    attachment_list.remove(pa)
                } catch (ignored: Throwable) {
                }

                showMediaAttachment()
            }
            .setNegativeButton(R.string.cancel, null)
            .show()

    }

    private fun editAttachmentDescription(pa: PostAttachment) {
        val a = pa.attachment
        if (a == null) {
            showToast(true, R.string.attachment_description_cant_edit_while_uploading)
            return
        }

        DlgTextInput.show(
            this,
            getString(R.string.attachment_description),
            a.description,
            callback = object : DlgTextInput.Callback {
                override fun onOK(dialog: Dialog, text: String) {
                    setAttachmentDescription(pa, dialog, text)
                }

                override fun onEmptyError() {
                    showToast(true, R.string.description_empty)
                }
            })
    }

    @SuppressLint("StaticFieldLeak")
    private fun setAttachmentDescription(pa: PostAttachment, dialog: Dialog, text: String) {

        val attachment_id = pa.attachment?.id ?: return

        TootTaskRunner(this).run(this@ActPost.account ?: return, object : TootTask {

            var new_attachment: TootAttachment? = null

            override suspend fun background(client: TootApiClient): TootApiResult? {
                val result = client.request(
                    "/api/v1/media/$attachment_id",
                    jsonObject {
                        put("description", text)
                    }
                        .toPutRequestBuilder()
                )
                new_attachment =
                    parseItem(::TootAttachment, ServiceType.MASTODON, result?.jsonObject)
                return result
            }

            override suspend fun handleResult(result: TootApiResult?) {
                if (result == null) return  // cancelled.

                val new_attachment = this.new_attachment
                if (new_attachment != null) {
                    pa.attachment = new_attachment
                    showMediaAttachment()

                    dialog.dismissSafe()

                } else {
                    showToast(true, result.error)
                }
            }
        })
    }

    private fun openAttachment() {

        if (attachment_list.size >= 4) {
            showToast(false, R.string.attachment_too_many)
            return
        }

        if (account == null) {
            showToast(false, R.string.account_select_please)
            return
        }

        val permissionCheck =
            ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
        if (permissionCheck != PackageManager.PERMISSION_GRANTED) {
            preparePermission()
            return
        }

        //		permissionCheck = ContextCompat.checkSelfPermission( this, Manifest.permission.CAMERA );
        //		if( permissionCheck != PackageManager.PERMISSION_GRANTED ){
        //			preparePermission();
        //			return;
        //		}

        val a = ActionsDialog()
        a.addAction(getString(R.string.pick_images)) {
            openAttachmentChooser(R.string.pick_images, "image/*", "video/*")
        }
        a.addAction(getString(R.string.pick_videos)) {
            openAttachmentChooser(R.string.pick_videos, "video/*")
        }
        a.addAction(getString(R.string.pick_audios)) {
            openAttachmentChooser(R.string.pick_audios, "audio/*")
        }
        a.addAction(getString(R.string.image_capture)) {
            performCamera()
        }
        a.addAction(getString(R.string.video_capture)) {
            performCapture(
                REQUEST_CODE_VIDEO,
                MediaStore.ACTION_VIDEO_CAPTURE,
                "can't open video capture app."
            )
        }
        a.addAction(getString(R.string.voice_capture)) {
            performCapture(
                REQUEST_CODE_SOUND,
                MediaStore.Audio.Media.RECORD_SOUND_ACTION,
                "can't open voice capture app."
            )
        }

        a.show(this, null)

    }

    private fun openAttachmentChooser(titleId: Int, vararg mimeTypes: String) {
        // SAFのIntentで開く
        try {
            val intent = intentGetContent(true, getString(titleId), mimeTypes)
            startActivityForResult(intent, REQUEST_CODE_ATTACHMENT_OLD)
        } catch (ex: Throwable) {
            log.trace(ex)
            showToast(ex, "ACTION_GET_CONTENT failed.")
        }
    }

    internal interface InputStreamOpener {

        val mimeType: String

        @Throws(IOException::class)
        fun open(): InputStream

        fun deleteTempFile()
    }

    private fun createOpener(
        uri: Uri,
        mime_type: String,
        resizeConfig: ResizeConfig
    ): InputStreamOpener {

        while (true) {
            try {

                // 画像の種別
                val is_jpeg = MIME_TYPE_JPEG == mime_type
                val is_png = MIME_TYPE_PNG == mime_type
                if (!is_jpeg && !is_png) {
                    log.d("createOpener: source is not jpeg or png")
                    break
                }

                val bitmap = createResizedBitmap(
                    this,
                    uri,
                    resizeConfig,
                    skipIfNoNeedToResizeAndRotate = true
                )
                if (bitmap != null) {
                    try {
                        val cache_dir = externalCacheDir
                        if (cache_dir == null) {
                            showToast(false, "getExternalCacheDir returns null.")
                            break
                        }

                        cache_dir.mkdir()

                        val temp_file = File(cache_dir, "tmp." + Thread.currentThread().id)
                        FileOutputStream(temp_file).use { os ->
                            if (is_jpeg) {
                                bitmap.compress(Bitmap.CompressFormat.JPEG, 95, os)
                            } else {
                                bitmap.compress(Bitmap.CompressFormat.PNG, 100, os)
                            }
                        }

                        return object : InputStreamOpener {

                            override val mimeType: String
                                get() = mime_type

                            @Throws(IOException::class)
                            override fun open(): InputStream {
                                return FileInputStream(temp_file)
                            }

                            override fun deleteTempFile() {
                                temp_file.delete()
                            }
                        }
                    } finally {
                        bitmap.recycle()
                    }
                }

            } catch (ex: Throwable) {
                log.trace(ex)
                showToast(ex, "Resizing image failed.")
            }

            break
        }

        return object : InputStreamOpener {

            override val mimeType: String
                get() = mime_type

            @Throws(IOException::class)
            override fun open(): InputStream {
                return contentResolver.openInputStream(uri) ?: error("openInputStream returns null")
            }

            override fun deleteTempFile() {

            }
        }
    }

    private fun getMimeType(uri: Uri, mimeTypeArg: String?): String? {

        // image/j()pg だの image/j(e)pg だの、mime type を誤記するアプリがあまりに多い
        // クレームで消耗するのを減らすためにファイルヘッダを確認する
        if (mimeTypeArg == null || mimeTypeArg.startsWith("image/")) {
            val sv = findMimeTypeByFileHeader(contentResolver, uri)
            if (sv != null) return sv
        }

        // 既に引数で与えられてる
        if (mimeTypeArg?.isNotEmpty() == true) {
            return mimeTypeArg
        }

        // ContentResolverに尋ねる
        var sv = contentResolver.getType(uri)
        if (sv?.isNotEmpty() == true) return sv

        // gboardのステッカーではUriのクエリパラメータにmimeType引数がある
        sv = uri.getQueryParameter("mimeType")
        if (sv?.isNotEmpty() == true) return sv

        return null
    }

    private fun checkAttachments(srcList: ArrayList<GetContentResultEntry>?) {
        srcList?.forEach {
            addAttachment(it.uri, it.mimeType)
        }
    }

    private class AttachmentRequest(
        val account: SavedAccount,
        val pa: PostAttachment,
        val uri: Uri,
        val mimeType: String,
        val onUploadEnd: () -> Unit
    )

    private val attachment_queue = ConcurrentLinkedQueue<AttachmentRequest>()
    private var attachment_worker: AttachmentWorker? = null
    private var lastAttachmentAdd: Long = 0L
    private var lastAttachmentComplete: Long = 0L

    @SuppressLint("StaticFieldLeak")
    private fun addAttachment(
        uri: Uri,
        mimeTypeArg: String? = null,
        onUploadEnd: () -> Unit = {}
    ) {

        if (attachment_list.size >= 4) {
            showToast(false, R.string.attachment_too_many)
            return
        }

        val account = this@ActPost.account
        if (account == null) {
            showToast(false, R.string.account_select_please)
            return
        }

        val mime_type = getMimeType(uri, mimeTypeArg)
        if (mime_type?.isEmpty() != false) {
            showToast(false, R.string.mime_type_missing)
            return
        }

        val instance = TootInstance.getCached(account.apiHost.ascii)
        if (instance?.instanceType == InstanceType.Pixelfed) {
            if (in_reply_to_id != null) {
                showToast(true, R.string.pixelfed_does_not_allow_reply_with_media)
                return
            }
            if (!acceptable_mime_types_pixelfed.contains(mime_type)) {
                showToast(true, R.string.mime_type_not_acceptable, mime_type)
                return
            }
        } else {
            if (!acceptable_mime_types.contains(mime_type)) {
                showToast(true, R.string.mime_type_not_acceptable, mime_type)
                return
            }
        }

        app_state.attachment_list = this.attachment_list

        val pa = PostAttachment(this)
        attachment_list.add(pa)
        showMediaAttachment()

        // アップロード開始トースト(連発しない)
        val now = System.currentTimeMillis()
        if (now - lastAttachmentAdd >= 5000L) {
            showToast(false, R.string.attachment_uploading)
        }
        lastAttachmentAdd = now

        // マストドンは添付メディアをID順に表示するため
        // 画像が複数ある場合は一つずつ処理する必要がある
        // 投稿画面ごとに1スレッドだけ作成してバックグラウンド処理を行う
        attachment_queue.add(AttachmentRequest(account, pa, uri, mime_type, onUploadEnd))
        val oldWorker = attachment_worker
        if (oldWorker == null || !oldWorker.isAlive || oldWorker.isCancelled.get()) {
            oldWorker?.cancel()
            attachment_worker = AttachmentWorker()
        } else {
            oldWorker.notifyEx()
        }
    }

    inner class AttachmentWorker : WorkerBase() {

        internal val isCancelled = AtomicBoolean(false)

        override fun cancel() {
            isCancelled.set(true)
            notifyEx()
        }

        override suspend fun run() {
            try {
                while (!isCancelled.get()) {
                    val item = attachment_queue.poll()
                    if (item == null) {
                        waitEx(86400000L)
                        continue
                    }
                    val result = item.upload()
                    handler.post {
                        item.handleResult(result)
                    }
                }
            } catch (ex: Throwable) {
                log.trace(ex)
                log.e(ex, "AttachmentWorker")
            }
        }

        @Suppress("BlockingMethodInNonBlockingContext")
        private suspend fun AttachmentRequest.upload(): TootApiResult? {

            if (mimeType.isEmpty()) {
                return TootApiResult("mime_type is empty.")
            }

            try {
                val client = TootApiClient(this@ActPost, callback = object : TootApiCallback {
                    override val isApiCancelled: Boolean
                        get() = isCancelled.get()
                })

                client.account = account

                val (ti, tiResult) = TootInstance.get(client)
                ti ?: return tiResult

                if (ti.instanceType == InstanceType.Pixelfed) {
                    if (in_reply_to_id != null) {
                        return TootApiResult(getString(R.string.pixelfed_does_not_allow_reply_with_media))
                    }
                    if (!acceptable_mime_types_pixelfed.contains(mimeType)) {
                        return TootApiResult(getString(R.string.mime_type_not_acceptable, mimeType))
                    }
                }
                // 設定からリサイズ指定を読む
                val resizeConfig = account.getResizeConfig()

                val opener = createOpener(uri, mimeType, resizeConfig)

                val media_size_max = when {
                    mimeType.startsWith("video") || mimeType.startsWith("audio") ->
                        account.getMovieMaxBytes(ti)

                    else ->
                        account.getImageMaxBytes(ti)
                }

                val content_length = getStreamSize(true, opener.open())
                if (content_length > media_size_max) {
                    return TootApiResult(
                        getString(
                            R.string.file_size_too_big,
                            media_size_max / 1000000
                        )
                    )
                }

                fun fixDocumentName(s: String): String {
                    val s_length = s.length
                    val m = """([^\x20-\x7f])""".asciiPattern().matcher(s)
                    m.reset()
                    val sb = StringBuilder(s_length)
                    var lastEnd = 0
                    while (m.find()) {
                        sb.append(s.substring(lastEnd, m.start()))
                        val escaped = m.groupEx(1)!!.encodeUTF8().encodeHex()
                        sb.append(escaped)
                        lastEnd = m.end()
                    }
                    if (lastEnd < s_length) sb.append(s.substring(lastEnd, s_length))
                    return sb.toString()
                }

                val fileName = fixDocumentName(getDocumentName(contentResolver, uri))

                return if (account.isMisskey) {
                    val multipart_builder = MultipartBody.Builder()
                        .setType(MultipartBody.FORM)

                    val apiKey = account.token_info?.string(TootApiClient.KEY_API_KEY_MISSKEY)
                    if (apiKey?.isNotEmpty() == true) {
                        multipart_builder.addFormDataPart("i", apiKey)
                    }

                    multipart_builder.addFormDataPart(
                        "file",
                        fileName,
                        object : RequestBody() {
                            override fun contentType(): MediaType {
                                return opener.mimeType.toMediaType()
                            }

                            @Throws(IOException::class)
                            override fun contentLength(): Long {
                                return content_length
                            }

                            @Throws(IOException::class)
                            override fun writeTo(sink: BufferedSink) {
                                opener.open().use { inData ->
                                    val tmp = ByteArray(4096)
                                    while (true) {
                                        val r = inData.read(tmp, 0, tmp.size)
                                        if (r <= 0) break
                                        sink.write(tmp, 0, r)
                                    }
                                }
                            }
                        }
                    )

                    val result = client.request(
                        "/api/drive/files/create",
                        multipart_builder.build().toPost()
                    )

                    opener.deleteTempFile()
                    onUploadEnd()

                    val jsonObject = result?.jsonObject
                    if (jsonObject != null) {
                        val a = parseItem(::TootAttachment, ServiceType.MISSKEY, jsonObject)
                        if (a == null) {
                            result.error = "TootAttachment.parse failed"
                        } else {
                            pa.attachment = a
                        }
                    }
                    result
                } else {
                    suspend fun postMedia(path: String) = client.request(
                        path,
                        MultipartBody.Builder()
                            .setType(MultipartBody.FORM)
                            .addFormDataPart(
                                "file",
                                fileName,
                                object : RequestBody() {
                                    override fun contentType(): MediaType {
                                        return opener.mimeType.toMediaType()
                                    }

                                    @Throws(IOException::class)
                                    override fun contentLength(): Long {
                                        return content_length
                                    }

                                    @Throws(IOException::class)
                                    override fun writeTo(sink: BufferedSink) {
                                        opener.open().use { inData ->
                                            val tmp = ByteArray(4096)
                                            while (true) {
                                                val r = inData.read(tmp, 0, tmp.size)
                                                if (r <= 0) break
                                                sink.write(tmp, 0, r)
                                            }
                                        }
                                    }
                                }
                            )
                            .build().toPost()
                    )

                    suspend fun postV1() = postMedia("/api/v1/media")

                    suspend fun postV2(): TootApiResult? {
                        // 3.1.3未満は v1 APIを使う
                        if (!ti.versionGE(TootInstance.VERSION_3_1_3))
                            return postV1()

                        // v2 APIを試す
                        val result = postMedia("/api/v2/media")
                        val code = result?.response?.code // complete,or 4xx error
                        when {
                            // 404ならv1 APIにフォールバック
                            code == 404 -> return postV1()
                            // 202 accepted 以外はポーリングしない
                            code != 202 -> return result
                        }

                        // ポーリングして処理完了を待つ
                        val id = parseItem(
                            ::TootAttachment,
                            ServiceType.MASTODON,
                            result?.jsonObject
                        )
                            ?.id
                            ?: return TootApiResult("/api/v2/media did not return the media ID.")

                        var lastResponse = SystemClock.elapsedRealtime()
                        loop@ while (true) {

                            delay(1000L)
                            val r2 = client.request("/api/v1/media/$id")
                                ?: return null // cancelled

                            val now = SystemClock.elapsedRealtime()
                            when (r2.response?.code) {
                                // complete,or 4xx error
                                200, in 400 until 500 -> return r2

                                // continue to wait
                                206 -> lastResponse = now

                                // too many temporary error without 206 response.
                                else ->
                                    if (now - lastResponse >= 120000L)
                                        return TootApiResult("timeout.")
                            }
                        }
                    }

                    val result = postV2()
                    opener.deleteTempFile()
                    onUploadEnd()

                    val jsonObject = result?.jsonObject
                    if (jsonObject != null) {
                        val a = parseItem(::TootAttachment, ServiceType.MASTODON, jsonObject)
                        if (a == null) {
                            result.error = "TootAttachment.parse failed"
                        } else {
                            pa.attachment = a
                        }
                    }
                    result
                }

            } catch (ex: Throwable) {
                return TootApiResult(ex.withCaption("read failed."))
            }
        }

        private fun AttachmentRequest.handleResult(result: TootApiResult?) {

            if (pa.attachment == null) {
                pa.status = PostAttachment.STATUS_UPLOAD_FAILED
                if (result != null) {
                    showToast(
                        true,
                        "${result.error} ${result.response?.request?.method} ${result.response?.request?.url}"
                    )
                }
            } else {
                pa.status = PostAttachment.STATUS_UPLOADED
            }
            // 投稿中に画面回転があった場合、新しい画面のコールバックを呼び出す必要がある
            pa.callback?.onPostAttachmentComplete(pa)
        }
    }

    // 添付メディア投稿が完了したら呼ばれる
    override fun onPostAttachmentComplete(pa: PostAttachment) {
        if (!attachment_list.contains(pa)) {
            // この添付メディアはリストにない
            return
        }

        when (pa.status) {
            PostAttachment.STATUS_UPLOAD_FAILED -> {
                // アップロード失敗
                attachment_list.remove(pa)
                showMediaAttachment()
            }

            PostAttachment.STATUS_UPLOADED -> {
                val a = pa.attachment
                if (a != null) {
                    // アップロード完了

                    val now = System.currentTimeMillis()
                    if (now - lastAttachmentComplete >= 5000L) {
                        showToast(false, R.string.attachment_uploaded)
                    }
                    lastAttachmentComplete = now

                    if (Pref.bpAppendAttachmentUrlToContent(pref)) {
                        // 投稿欄の末尾に追記する
                        val selStart = etContent.selectionStart
                        val selEnd = etContent.selectionEnd
                        val e = etContent.editableText
                        val len = e.length
                        val last_char = if (len <= 0) ' ' else e[len - 1]
                        if (!CharacterGroup.isWhitespace(last_char.code)) {
                            e.append(" ").append(a.text_url)
                        } else {
                            e.append(a.text_url)
                        }
                        etContent.setSelection(selStart, selEnd)
                    }

                }

                showMediaAttachment()
            }

            else -> {
                // アップロード中…？
            }
        }
    }

    private fun performCamera() {
        try {
            val filename = System.currentTimeMillis().toString() + ".jpg"
            val values = ContentValues()
            values.put(MediaStore.Images.Media.TITLE, filename)
            values.put(MediaStore.Images.Media.MIME_TYPE, "image/jpeg")
            uriCameraImage =
                contentResolver.insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values)

            val intent = Intent(MediaStore.ACTION_IMAGE_CAPTURE)
            intent.putExtra(MediaStore.EXTRA_OUTPUT, uriCameraImage)

            startActivityForResult(intent, REQUEST_CODE_CAMERA)
        } catch (ex: Throwable) {
            log.trace(ex)
            showToast(ex, "opening camera app failed.")
        }

    }

    private fun performCapture(requestCode: Int, action: String, errorCaption: String) {
        try {
            startActivityForResult(Intent(action), requestCode)
        } catch (ex: Throwable) {
            log.trace(ex)
            showToast(ex, errorCaption)
        }
    }

    private fun preparePermission() {
        if (Build.VERSION.SDK_INT >= 23) {
            ActivityCompat.requestPermissions(
                this,
                arrayOf(Manifest.permission.WRITE_EXTERNAL_STORAGE),
                PERMISSION_REQUEST_CODE
            )
        } else {
            showToast(true, R.string.missing_permission_to_access_media)
        }
    }

    override fun onRequestPermissionsResult(
        requestCode: Int, permissions: Array<String>, grantResults: IntArray
    ) {
        when (requestCode) {
            PERMISSION_REQUEST_CODE -> {
                var bNotGranted = false
                var i = 0
                val ie = permissions.size
                while (i < ie) {
                    if (grantResults[i] != PackageManager.PERMISSION_GRANTED) {
                        bNotGranted = true
                    }
                    ++i
                }
                if (bNotGranted) {
                    showToast(true, R.string.missing_permission_to_access_media)
                } else {
                    openAttachment()
                }
            }
        }
    }

    private fun showVisibility() {
        btnVisibility.setImageResource(
            Styler.getVisibilityIconId(
                account?.isMisskey == true, visibility ?: TootVisibility.Public
            )
        )
    }

    private fun performVisibility() {
        val ti = account?.let { TootInstance.getCached(it.apiHost.ascii) }

        val list = when {
            account?.isMisskey == true ->
                arrayOf(
                    //	TootVisibility.WebSetting,
                    TootVisibility.Public,
                    TootVisibility.UnlistedHome,
                    TootVisibility.PrivateFollowers,
                    TootVisibility.LocalPublic,
                    TootVisibility.LocalHome,
                    TootVisibility.LocalFollowers,
                    TootVisibility.DirectSpecified,
                    TootVisibility.DirectPrivate
                )

            true == ti?.hasCapability(InstanceCapability.VisibilityMutual) ->
                arrayOf(
                    TootVisibility.WebSetting,
                    TootVisibility.Public,
                    TootVisibility.UnlistedHome,
                    TootVisibility.PrivateFollowers,
                    TootVisibility.Limited,
                    TootVisibility.Mutual,
                    TootVisibility.DirectSpecified
                )

            true == ti?.hasCapability(InstanceCapability.VisibilityLimited) ->
                arrayOf(
                    TootVisibility.WebSetting,
                    TootVisibility.Public,
                    TootVisibility.UnlistedHome,
                    TootVisibility.PrivateFollowers,
                    TootVisibility.Limited,
                    TootVisibility.DirectSpecified
                )

            else ->
                arrayOf(
                    TootVisibility.WebSetting,
                    TootVisibility.Public,
                    TootVisibility.UnlistedHome,
                    TootVisibility.PrivateFollowers,
                    TootVisibility.DirectSpecified
                )

        }
        val caption_list = list
            .map { Styler.getVisibilityCaption(this, account?.isMisskey == true, it) }
            .toTypedArray()

        AlertDialog.Builder(this)
            .setTitle(R.string.choose_visibility)
            .setItems(caption_list) { _, which ->
                if (which in list.indices) {
                    visibility = list[which]
                    showVisibility()
                }
            }
            .setNegativeButton(R.string.cancel, null)
            .show()

    }

    ///////////////////////////////////////////////////////////////////////////////////////

    private fun performMore() {
        val dialog = ActionsDialog()

        dialog.addAction(getString(R.string.open_picker_emoji)) {
            post_helper.openEmojiPickerFromMore()
        }

        dialog.addAction(getString(R.string.clear_text)) {
            etContent.setText("")
            etContentWarning.setText("")
        }

        dialog.addAction(getString(R.string.clear_text_and_media)) {
            etContent.setText("")
            etContentWarning.setText("")
            attachment_list.clear()
            showMediaAttachment()
        }

        if (PostDraft.hasDraft()) dialog.addAction(getString(R.string.restore_draft)) {
            openDraftPicker()
        }

        dialog.addAction(getString(R.string.recommended_plugin)) {
            showRecommendedPlugin(null)
        }

        dialog.show(this, null)
    }

    ///////////////////////////////////////////////////////////////////////////////////////
    // post

    private fun performPost() {
        val account = this.account ?: return

        // アップロード中は投稿できない
        for (pa in attachment_list) {
            if (pa.status == PostAttachment.STATUS_UPLOADING) {
                showToast(false, R.string.media_attachment_still_uploading)
                return
            }
        }

        post_helper.content = etContent.text.toString().trim { it <= ' ' }

        fun copyEnqueteText() {
            val enquete_items = ArrayList<String>()
            for (et in list_etChoice) {
                enquete_items.add(et.text.toString().trim { it <= ' ' })
            }
            post_helper.enquete_items = enquete_items
        }

        fun getExpireSeconds(): Int {

            fun Double?.finiteOrZero(): Double = if (this?.isFinite() == true) this else 0.0

            val d = etExpireDays.text.toString().trim().toDoubleOrNull().finiteOrZero()
            val h = etExpireHours.text.toString().trim().toDoubleOrNull().finiteOrZero()
            val m = etExpireMinutes.text.toString().trim().toDoubleOrNull().finiteOrZero()

            return (d * 86400.0 + h * 3600.0 + m * 60.0).toInt()
        }

        when (spEnquete.selectedItemPosition) {
            1 -> {
                copyEnqueteText()
                post_helper.poll_type = TootPollsType.Mastodon
                post_helper.poll_expire_seconds = getExpireSeconds()
                post_helper.poll_hide_totals = cbHideTotals.isChecked
                post_helper.poll_multiple_choice = cbMultipleChoice.isChecked
            }

            2 -> {
                copyEnqueteText()
                post_helper.poll_type = TootPollsType.FriendsNico

            }

            else -> {
                post_helper.enquete_items = null
                post_helper.poll_type = null
            }
        }


        if (!cbContentWarning.isChecked) {
            post_helper.spoiler_text = null // nullはCWチェックなしを示す
        } else {
            post_helper.spoiler_text = etContentWarning.text.toString().trim { it <= ' ' }
        }

        post_helper.visibility = this.visibility ?: TootVisibility.Public
        post_helper.bNSFW = cbNSFW.isChecked

        post_helper.in_reply_to_id = this.in_reply_to_id

        post_helper.attachment_list = this.attachment_list

        post_helper.emojiMapCustom = App1.custom_emoji_lister.getMap(account)

        post_helper.redraft_status_id = redraft_status_id

        post_helper.useQuoteToot = cbQuote.isChecked

        post_helper.scheduledAt = timeSchedule

        post_helper.scheduledId = scheduledStatus?.id

        post_helper.post(account, callback = object : PostHelper.PostCompleteCallback {
            override fun onPostComplete(
                target_account: SavedAccount,
                status: TootStatus
            ) {
                val data = Intent()
                data.putExtra(EXTRA_POSTED_ACCT, target_account.acct.ascii)
                status.id.putTo(data, EXTRA_POSTED_STATUS_ID)
                redraft_status_id?.putTo(data, EXTRA_POSTED_REDRAFT_ID)
                status.in_reply_to_id?.putTo(data, EXTRA_POSTED_REPLY_ID)
                setResult(RESULT_OK, data)
                isPostComplete = true
                this@ActPost.finish()
            }

            override fun onScheduledPostComplete(target_account: SavedAccount) {
                showToast(false, getString(R.string.scheduled_status_sent))
                val data = Intent()
                data.putExtra(EXTRA_POSTED_ACCT, target_account.acct.ascii)
                setResult(RESULT_OK, data)
                isPostComplete = true
                this@ActPost.finish()
            }
        })
    }

    private fun showQuotedRenote() {
        cbQuote.visibility = if (in_reply_to_id != null) View.VISIBLE else View.GONE
    }

    private fun showReplyTo() {
        if (in_reply_to_id == null) {
            llReply.visibility = View.GONE
        } else {
            llReply.visibility = View.VISIBLE
            tvReplyTo.text = DecodeOptions(
                this@ActPost,
                linkHelper = account,
                short = true,
                decodeEmoji = true,
                mentionDefaultHostDomain = account ?: unknownHostAndDomain
            ).decodeHTML(in_reply_to_text)
            ivReply.setImageUrl(pref, Styler.calcIconRound(ivReply.layoutParams), in_reply_to_image)
        }
    }

    private fun removeReply() {
        in_reply_to_id = null
        in_reply_to_text = null
        in_reply_to_image = null
        in_reply_to_url = null
        showReplyTo()
        showQuotedRenote()
    }

    private fun saveDraft() {
        val content = etContent.text.toString()
        val content_warning =
            if (cbContentWarning.isChecked) etContentWarning.text.toString() else ""

        val isEnquete = spEnquete.selectedItemPosition > 0

        val str_choice = arrayOf(
            if (isEnquete) list_etChoice[0].text.toString() else "",
            if (isEnquete) list_etChoice[1].text.toString() else "",
            if (isEnquete) list_etChoice[2].text.toString() else "",
            if (isEnquete) list_etChoice[3].text.toString() else ""
        )

        var hasContent = false
        if (content.isNotBlank()) hasContent = true
        if (content_warning.isNotBlank()) hasContent = true
        for (s in str_choice) {
            if (s.isNotBlank()) hasContent = true
        }
        if (!hasContent) {
            log.d("saveDraft: dont save empty content")
            return
        }

        try {
            val tmp_attachment_list = attachment_list
                .mapNotNull { it.attachment?.encodeJson() }
                .toJsonArray()

            val json = JsonObject()
            json[DRAFT_CONTENT] = content
            json[DRAFT_CONTENT_WARNING] = content_warning
            json[DRAFT_CONTENT_WARNING_CHECK] = cbContentWarning.isChecked
            json[DRAFT_NSFW_CHECK] = cbNSFW.isChecked
            visibility?.let { json.put(DRAFT_VISIBILITY, it.id.toString()) }
            json[DRAFT_ACCOUNT_DB_ID] = account?.db_id ?: -1L
            json[DRAFT_ATTACHMENT_LIST] = tmp_attachment_list
            in_reply_to_id?.putTo(json, DRAFT_REPLY_ID)
            json[DRAFT_REPLY_TEXT] = in_reply_to_text
            json[DRAFT_REPLY_IMAGE] = in_reply_to_image
            json[DRAFT_REPLY_URL] = in_reply_to_url

            json[DRAFT_QUOTE] = cbQuote.isChecked

            // deprecated. but still used in old draft.
            // json.put(DRAFT_IS_ENQUETE, isEnquete)

            json[DRAFT_POLL_TYPE] = spEnquete.selectedItemPosition.toPollTypeString()

            json[DRAFT_POLL_MULTIPLE] = cbMultipleChoice.isChecked
            json[DRAFT_POLL_HIDE_TOTALS] = cbHideTotals.isChecked
            json[DRAFT_POLL_EXPIRE_DAY] = etExpireDays.text.toString()
            json[DRAFT_POLL_EXPIRE_HOUR] = etExpireHours.text.toString()
            json[DRAFT_POLL_EXPIRE_MINUTE] = etExpireMinutes.text.toString()

            json[DRAFT_ENQUETE_ITEMS] = str_choice.toJsonArray()

            PostDraft.save(System.currentTimeMillis(), json)

        } catch (ex: Throwable) {
            log.trace(ex)
        }

    }

    // poll type string to spinner index
    private fun String?.toPollTypeIndex() = when (this) {
        "mastodon" -> 1
        "friendsNico" -> 2
        else -> 0
    }

    private fun Int?.toPollTypeString() = when (this) {
        1 -> "mastodon"
        2 -> "friendsNico"
        else -> ""
    }

    private fun openDraftPicker() {

        DlgDraftPicker().open(this) { draft -> restoreDraft(draft) }

    }

    private fun restoreDraft(draft: JsonObject) {

        val list_warning = ArrayList<String>()
        var target_account: SavedAccount? = null

        runWithProgress(
            "restore from draft",
            { progress ->
                fun isTaskCancelled() = !this.coroutineContext.isActive

                var content = draft.string(DRAFT_CONTENT) ?: ""
                val account_db_id = draft.long(DRAFT_ACCOUNT_DB_ID) ?: -1L
                val tmp_attachment_list =
                    draft.jsonArray(DRAFT_ATTACHMENT_LIST)?.objectList()?.toMutableList()

                val account = SavedAccount.loadAccount(this@ActPost, account_db_id)
                if (account == null) {
                    list_warning.add(getString(R.string.account_in_draft_is_lost))
                    try {
                        if (tmp_attachment_list != null) {
                            // 本文からURLを除去する
                            tmp_attachment_list.forEach {
                                val text_url = TootAttachment.decodeJson(it).text_url
                                if (text_url?.isNotEmpty() == true) {
                                    content = content.replace(text_url, "")
                                }
                            }
                            tmp_attachment_list.clear()
                            draft[DRAFT_ATTACHMENT_LIST] = tmp_attachment_list.toJsonArray()
                            draft[DRAFT_CONTENT] = content
                            draft.remove(DRAFT_REPLY_ID)
                            draft.remove(DRAFT_REPLY_TEXT)
                            draft.remove(DRAFT_REPLY_IMAGE)
                            draft.remove(DRAFT_REPLY_URL)
                        }
                    } catch (ignored: JsonException) {
                    }

                    return@runWithProgress "OK"
                }

                target_account = account

                // アカウントがあるなら基本的にはすべての情報を復元できるはずだが、いくつか確認が必要だ
                val api_client = TootApiClient(this@ActPost, callback = object : TootApiCallback {

                    override val isApiCancelled: Boolean
                        get() = isTaskCancelled()

                    override suspend fun publishApiProgress(s: String) {
                        progress.setMessageEx(s)
                    }
                })

                api_client.account = account

                if (in_reply_to_id != null) {
                    val result = api_client.request("/api/v1/statuses/$in_reply_to_id")
                    if (isTaskCancelled()) return@runWithProgress null
                    val jsonObject = result?.jsonObject
                    if (jsonObject == null) {
                        list_warning.add(getString(R.string.reply_to_in_draft_is_lost))
                        draft.remove(DRAFT_REPLY_ID)
                        draft.remove(DRAFT_REPLY_TEXT)
                        draft.remove(DRAFT_REPLY_IMAGE)
                    }
                }
                try {
                    if (tmp_attachment_list != null) {
                        // 添付メディアの存在確認
                        var isSomeAttachmentRemoved = false
                        val it = tmp_attachment_list.iterator()
                        while (it.hasNext()) {
                            if (isTaskCancelled()) return@runWithProgress null
                            val ta = TootAttachment.decodeJson(it.next())
                            if (check_exist(ta.url)) continue
                            it.remove()
                            isSomeAttachmentRemoved = true
                            // 本文からURLを除去する
                            val text_url = ta.text_url
                            if (text_url?.isNotEmpty() == true) {
                                content = content.replace(text_url, "")
                            }
                        }
                        if (isSomeAttachmentRemoved) {
                            list_warning.add(getString(R.string.attachment_in_draft_is_lost))
                            draft[DRAFT_ATTACHMENT_LIST] = tmp_attachment_list.toJsonArray()
                            draft[DRAFT_CONTENT] = content
                        }
                    }
                } catch (ex: JsonException) {
                    log.trace(ex)
                }

                "OK"
            },
            { result ->
                // cancelled.
                if (result == null) return@runWithProgress

                val content = draft.string(DRAFT_CONTENT) ?: ""
                val content_warning = draft.string(DRAFT_CONTENT_WARNING) ?: ""
                val content_warning_checked = draft.optBoolean(DRAFT_CONTENT_WARNING_CHECK)
                val nsfw_checked = draft.optBoolean(DRAFT_NSFW_CHECK)
                val tmp_attachment_list = draft.jsonArray(DRAFT_ATTACHMENT_LIST)
                val reply_id = EntityId.from(draft, DRAFT_REPLY_ID)
                val reply_text = draft.string(DRAFT_REPLY_TEXT)
                val reply_image = draft.string(DRAFT_REPLY_IMAGE)
                val reply_url = draft.string(DRAFT_REPLY_URL)
                val draft_visibility = TootVisibility
                    .parseSavedVisibility(draft.string(DRAFT_VISIBILITY))

                val evEmoji = DecodeOptions(
                    this@ActPost,
                    decodeEmoji = true
                ).decodeEmoji(content)
                etContent.setText(evEmoji)
                etContent.setSelection(evEmoji.length)
                etContentWarning.setText(content_warning)
                etContentWarning.setSelection(content_warning.length)
                cbContentWarning.isChecked = content_warning_checked
                cbNSFW.isChecked = nsfw_checked
                if (draft_visibility != null) this@ActPost.visibility = draft_visibility

                cbQuote.isChecked = draft.optBoolean(DRAFT_QUOTE)

                val sv = draft.string(DRAFT_POLL_TYPE)
                if (sv != null) {
                    spEnquete.setSelection(sv.toPollTypeIndex())
                } else {
                    // old draft
                    val bv = draft.optBoolean(DRAFT_IS_ENQUETE, false)
                    spEnquete.setSelection(if (bv) 2 else 0)
                }

                cbMultipleChoice.isChecked = draft.optBoolean(DRAFT_POLL_MULTIPLE)
                cbHideTotals.isChecked = draft.optBoolean(DRAFT_POLL_HIDE_TOTALS)
                etExpireDays.setText(draft.optString(DRAFT_POLL_EXPIRE_DAY, "1"))
                etExpireHours.setText(draft.optString(DRAFT_POLL_EXPIRE_HOUR, ""))
                etExpireMinutes.setText(draft.optString(DRAFT_POLL_EXPIRE_MINUTE, ""))

                val array = draft.jsonArray(DRAFT_ENQUETE_ITEMS)
                if (array != null) {
                    var src_index = 0
                    for (et in list_etChoice) {
                        if (src_index < array.size) {
                            et.setText(array.optString(src_index))
                            ++src_index
                        } else {
                            et.setText("")
                        }
                    }
                }

                if (target_account != null) selectAccount(target_account)

                if (tmp_attachment_list?.isNotEmpty() == true) {
                    attachment_list.clear()
                    tmp_attachment_list.forEach {
                        if (it !is JsonObject) return@forEach
                        val pa = PostAttachment(TootAttachment.decodeJson(it))
                        attachment_list.add(pa)
                    }
                }

                if (reply_id != null) {
                    in_reply_to_id = reply_id
                    in_reply_to_text = reply_text
                    in_reply_to_image = reply_image
                    in_reply_to_url = reply_url
                }

                updateContentWarning()
                showMediaAttachment()
                showVisibility()
                updateTextCount()
                showReplyTo()
                showEnquete()
                showQuotedRenote()

                if (list_warning.isNotEmpty()) {
                    val sb = StringBuilder()
                    for (s in list_warning) {
                        if (sb.isNotEmpty()) sb.append("\n")
                        sb.append(s)
                    }
                    AlertDialog.Builder(this@ActPost)
                        .setMessage(sb)
                        .setNeutralButton(R.string.close, null)
                        .show()
                }
            }
        )
    }

    private fun prepareMushroomText(et: EditText): String {
        mushroom_start = et.selectionStart
        mushroom_end = et.selectionEnd
        return if (mushroom_end > mushroom_start) {
            et.text.toString().substring(mushroom_start, mushroom_end)
        } else {
            ""
        }
    }

    private fun applyMushroomText(et: EditText, text: String) {
        val src = et.text.toString()
        if (mushroom_start > src.length) mushroom_start = src.length
        if (mushroom_end > src.length) mushroom_end = src.length

        val sb = StringBuilder()
        sb.append(src.substring(0, mushroom_start))
        // int new_sel_start = sb.length();
        sb.append(text)
        val new_sel_end = sb.length
        sb.append(src.substring(mushroom_end))
        et.setText(sb)
        et.setSelection(new_sel_end, new_sel_end)
    }

    private fun openMushroom() {
        try {
            var text: String? = null
            when {
                etContentWarning.hasFocus() -> {
                    mushroom_input = 1
                    text = prepareMushroomText(etContentWarning)
                }

                etContent.hasFocus() -> {
                    mushroom_input = 0
                    text = prepareMushroomText(etContent)
                }

                else -> for (i in 0..3) {
                    if (list_etChoice[i].hasFocus()) {
                        mushroom_input = i + 2
                        text = prepareMushroomText(list_etChoice[i])
                    }
                }
            }
            if (text == null) {
                mushroom_input = 0
                text = prepareMushroomText(etContent)
            }

            val intent = Intent("com.adamrocker.android.simeji.ACTION_INTERCEPT")
            intent.addCategory("com.adamrocker.android.simeji.REPLACE")
            intent.putExtra("replace_key", text)

            // Create intent to show chooser
            val chooser = Intent.createChooser(intent, getString(R.string.select_plugin))

            // Verify the intent will resolve to at least one activity
            if (intent.resolveActivity(packageManager) == null) {
                showRecommendedPlugin(getString(R.string.plugin_not_installed))
                return
            }
            startActivityForResult(chooser, REQUEST_CODE_MUSHROOM)

        } catch (ex: Throwable) {
            log.trace(ex)
            showRecommendedPlugin(getString(R.string.plugin_not_installed))
        }

    }

    private fun applyMushroomResult(text: String) {
        when (mushroom_input) {
            0 -> applyMushroomText(etContent, text)
            1 -> applyMushroomText(etContentWarning, text)
            else -> for (i in 0..3) {
                if (mushroom_input == i + 2) {
                    applyMushroomText(list_etChoice[i], text)
                }
            }
        }
    }

    @SuppressLint("InflateParams")
    private fun showRecommendedPlugin(title: String?) {

        val res_id = when (getString(R.string.language_code)) {
            "ja" -> R.raw.recommended_plugin_ja
            "fr" -> R.raw.recommended_plugin_fr
            else -> R.raw.recommended_plugin_en
        }

        this.loadRawResource(res_id).let { data ->
            val text = data.decodeUTF8()
            val viewRoot = layoutInflater.inflate(R.layout.dlg_plugin_missing, null, false)

            val tvText = viewRoot.findViewById<TextView>(R.id.tvText)

            val sv = DecodeOptions(
                this@ActPost,
                linkHelper = LinkHelper.unknown,
            ).decodeHTML(text)

            tvText.text = sv
            tvText.movementMethod = LinkMovementMethod.getInstance()

            val tvTitle = viewRoot.findViewById<TextView>(R.id.tvTitle)
            if (title?.isEmpty() != false) {
                tvTitle.visibility = View.GONE
            } else {
                tvTitle.text = title
            }

            AlertDialog.Builder(this)
                .setView(viewRoot)
                .setCancelable(true)
                .setNeutralButton(R.string.close, null)
                .show()

        }

    }

    private fun showEnquete() {
        val i = spEnquete.selectedItemPosition
        llEnquete.vg(i != 0)
        llExpire.vg(i == 1)
        cbHideTotals.vg(i == 1)
        cbMultipleChoice.vg(i == 1)
    }

    private val commitContentListener =
        InputConnectionCompat.OnCommitContentListener { inputContentInfo: InputContentInfoCompat,
                                                        flags: Int,
                                                        _: Bundle? ->

            // Intercepts InputConnection#commitContent API calls.
            // - inputContentInfo : content to be committed
            // - flags : {@code 0} or {@link #INPUT_CONTENT_GRANT_READ_URI_PERMISSION}
            // - opts : optional bundle data. This can be {@code null}
            // return
            // - true if this request is accepted by the application,
            //   no matter if the request is already handled or still being handled in background.
            // - false to use the default implementation

            // read and display inputContentInfo asynchronously

            if (Build.VERSION.SDK_INT >= 25
                && flags and InputConnectionCompat.INPUT_CONTENT_GRANT_READ_URI_PERMISSION != 0
            ) {
                try {
                    inputContentInfo.requestPermission()
                } catch (e: Exception) {
                    return@OnCommitContentListener false // return false if failed
                }
            }

            addAttachment(inputContentInfo.contentUri) {
                inputContentInfo.releasePermission()
            }

            true
        }

    private fun showSchedule() {
        tvSchedule.text = when (timeSchedule) {
            0L -> getString(R.string.unspecified)
            else -> TootStatus.formatTime(this, timeSchedule, true)
        }
    }

    private fun performSchedule() {
        DlgDateTime(this).open(timeSchedule) { t ->
            timeSchedule = t
            showSchedule()
        }
    }

    private fun resetSchedule() {
        timeSchedule = 0L
        showSchedule()
    }
}