package jp.juggler.subwaytooter.appsetting

import android.content.Intent
import android.content.res.ColorStateList
import android.os.Build
import android.view.View
import android.widget.ImageView
import android.widget.Spinner
import android.widget.TextView
import androidx.annotation.StringRes
import androidx.appcompat.widget.AppCompatImageView
import jp.juggler.subwaytooter.*
import jp.juggler.subwaytooter.actmain.selectPushDistributor
import jp.juggler.subwaytooter.dialog.runInProgress
import jp.juggler.subwaytooter.drawable.MediaBackgroundDrawable
import jp.juggler.subwaytooter.itemviewholder.AdditionalButtonsPosition
import jp.juggler.subwaytooter.notification.showAlertNotification
import jp.juggler.subwaytooter.pref.*
import jp.juggler.subwaytooter.pref.impl.*
import jp.juggler.subwaytooter.table.daoSavedAccount
import jp.juggler.subwaytooter.table.sortedByNickname
import jp.juggler.subwaytooter.util.CustomShareTarget
import jp.juggler.subwaytooter.util.openBrowser
import jp.juggler.util.coroutine.launchAndShowError
import jp.juggler.util.data.cast
import jp.juggler.util.data.intentOpenDocument
import jp.juggler.util.data.notZero
import jp.juggler.util.log.showToast
import jp.juggler.util.ui.InputTypeEx
import jp.juggler.util.ui.attrColor
import jp.juggler.util.ui.getAdaptiveRippleDrawable
import jp.juggler.util.ui.getAdaptiveRippleDrawableRound
import kotlinx.coroutines.delay
import org.jetbrains.anko.backgroundDrawable
import java.util.concurrent.atomic.AtomicInteger

enum class SettingType(val id: Int) {
    Path(0),
    Divider(1),
    Switch(2),
    EditText(3),
    Spinner(4),
    ColorOpaque(5),
    ColorAlpha(6),
    Action(7),
    Sample(8),
    Group(9),
    TextWithSelector(10),
    CheckBox(11),
    Section(12)

    ;

    companion object {
        val map = values().associateBy { it.id }
    }
}

class AppSettingItem(
    val parent: AppSettingItem?,
    val type: SettingType,
    @StringRes val caption: Int,
    val pref: BasePref<*>? = null,
) {
    val id = idSeed.incrementAndGet()

    @StringRes
    var desc: Int = 0
    var descClickSet = false
    var descClick: ActAppSetting.() -> Unit = {}
        set(value) {
            field = value
            descClickSet = true
        }

    var getError: ActAppSetting.(String) -> String? = { null }

    // may be open exportAppData() or importAppData()
    var action: ActAppSetting.() -> Unit = {}

    var changed: ActAppSetting.() -> Unit = {}

    // used for EditText
    var inputType = InputTypeEx.text

    var sampleLayoutId: Int = 0
    var sampleUpdate: (ActAppSetting, View) -> Unit = { _, _ -> }

    var spinnerArgs: IntArray? = null
    var spinnerArgsProc: (ActAppSetting) -> List<String> = { _ -> emptyList() }
    var spinnerInitializer: ActAppSetting.(Spinner) -> Unit = {}
    var spinnerOnSelected: ActAppSetting.(Spinner, Int) -> Unit = { _, _ -> }

    var enabled: Boolean = true

    var onClickEdit: ActAppSetting.() -> Unit = {}
    var onClickReset: ActAppSetting.() -> Unit = {}
    var showTextView: ActAppSetting.(TextView) -> Unit = {}

    // for EditText
    var hint: String? = null
    var filter: (String) -> String = { it.trim() }
    var captionFontSize: ActAppSetting.() -> Float? = { null }
    var captionSpacing: ActAppSetting.() -> Float? = { null }

    // cast before save
    var toFloat: ActAppSetting.(String) -> Float = { 0f }
    var fromFloat: ActAppSetting.(Float) -> String = { it.toString() }

    val items = ArrayList<AppSettingItem>()

    fun section(
        @StringRes caption: Int,
        initializer: AppSettingItem.() -> Unit = {},
    ) {
        items.add(AppSettingItem(this, SettingType.Section, caption).apply { initializer() })
    }

    fun group(
        @StringRes caption: Int,
        initializer: AppSettingItem.() -> Unit = {},
    ) {
        items.add(AppSettingItem(this, SettingType.Group, caption).apply { initializer() })
    }

    fun item(
        type: SettingType,
        pref: BasePref<*>?,
        @StringRes caption: Int,
        initializer: AppSettingItem.() -> Unit = {},
    ): AppSettingItem {
        val item = AppSettingItem(this, type, caption, pref).apply { initializer() }
        items.add(item)
        return item
    }

    fun spinnerSimple(
        pref: IntPref,
        @StringRes caption: Int,
        vararg args: Int,
        initializer: (AppSettingItem.() -> Unit)? = null,
    ) = item(SettingType.Spinner, pref, caption) {
        spinnerArgs = args
        initializer?.invoke(this)
    }

    fun spinner(
        pref: IntPref,
        @StringRes caption: Int,
        argsProc: (ActAppSetting) -> List<String>,
    ) = item(SettingType.Spinner, pref, caption) {
        spinnerArgsProc = argsProc
    }

    fun sw(
        pref: BooleanPref,
        @StringRes caption: Int,
        initializer: AppSettingItem.() -> Unit = {},
    ) = item(SettingType.Switch, pref, caption, initializer)

    fun checkbox(
        pref: BooleanPref,
        @StringRes caption: Int,
        initializer: AppSettingItem.() -> Unit = {},
    ) = item(SettingType.CheckBox, pref, caption, initializer)

    fun action(
        @StringRes caption: Int,
        initializer: AppSettingItem.() -> Unit = {},
    ) = item(SettingType.Action, null, caption, initializer)

    fun colorOpaque(
        pref: IntPref,
        @StringRes caption: Int,
        initializer: AppSettingItem.() -> Unit = {},
    ) = item(SettingType.ColorOpaque, pref, caption, initializer)

    fun colorAlpha(
        pref: IntPref,
        @StringRes caption: Int,
        initializer: AppSettingItem.() -> Unit = {},
    ) = item(SettingType.ColorAlpha, pref, caption, initializer)

    fun text(
        pref: StringPref,
        @StringRes caption: Int,
        inputType: Int,
        initializer: AppSettingItem.() -> Unit = {},
    ) = item(SettingType.EditText, pref, caption) {
        this.inputType = inputType
        this.initializer()
    }

    fun textX(
        pref: BasePref<*>,
        @StringRes caption: Int,
        inputType: Int,
        initializer: AppSettingItem.() -> Unit = {},
    ) = item(SettingType.EditText, pref, caption) {
        this.inputType = inputType
        this.initializer()
    }

    fun sample(
        sampleLayoutId: Int = 0,
        sampleUpdate: (ActAppSetting, View) -> Unit = { _, _ -> },
        // ,initializer : AppSettingItem.() -> Unit = {}
    ) = item(SettingType.Sample, pref, caption) {
        this.sampleLayoutId = sampleLayoutId
        this.sampleUpdate = sampleUpdate
    }

    fun scan(block: (AppSettingItem) -> Unit) {
        block(this)
        for (item in items) item.scan(block)
    }

    override fun hashCode() = id
    override fun equals(other: Any?) = (other as? AppSettingItem)?.id == this.id

    companion object {
        var idSeed = AtomicInteger(0)

        var SAMPLE_CCD_HEADER: AppSettingItem? = null
        var SAMPLE_CCD_BODY: AppSettingItem? = null
        var SAMPLE_FOOTER: AppSettingItem? = null

        var TIMELINE_FONT: AppSettingItem? = null
        var TIMELINE_FONT_BOLD: AppSettingItem? = null

        var FONT_SIZE_TIMELINE: AppSettingItem? = null
        var FONT_SIZE_NOTIFICATION_TL: AppSettingItem? = null
    }
}

val appSettingRoot = AppSettingItem(null, SettingType.Section, R.string.app_setting).apply {

    section(R.string.notifications) {
        action(R.string.push_distributor) {
            action = { selectPushDistributor() }
            desc = R.string.push_distributor_desc
        }

        text(
            PrefS.spPullNotificationCheckInterval,
            R.string.pull_notification_check_interval,
            InputTypeEx.number
        )

        sw(PrefB.bpShowAcctInSystemNotification, R.string.show_acct_in_system_notification)

        sw(PrefB.bpSeparateReplyNotificationGroup, R.string.separate_notification_group_for_reply)

        sw(PrefB.bpDivideNotification, R.string.divide_notification)

        // sw(PrefB.bpMisskeyNotificationCheck, R.string.enable_misskey_notification_check)

        sample(R.layout.setting_sample_notification_desc)
    }

    section(R.string.behavior) {

        sw(PrefB.bpDontConfirmBeforeCloseColumn, R.string.dont_confirm_before_close_column)

        spinnerSimple(
            PrefI.ipBackButtonAction,
            R.string.back_button_action,
            R.string.ask_always,
            R.string.close_column,
            R.string.open_column_list,
            R.string.app_exit
        )

        sw(PrefB.bpExitAppWhenCloseProtectedColumn, R.string.exit_app_when_close_protected_column)
        sw(PrefB.bpScrollTopFromColumnStrip, R.string.scroll_top_from_column_strip)
        sw(PrefB.bpDontScreenOff, R.string.dont_screen_off)
        sw(PrefB.bpDontUseCustomTabs, R.string.dont_use_custom_tabs)
        sw(PrefB.bpPriorChrome, R.string.prior_chrome_custom_tabs)

//        item(
//            SettingType.TextWithSelector,
//            PrefS.spWebBrowser,
//            R.string.web_browser
//        ) {
//            onClickEdit = {
//                openWebBrowserChooser(
//                    this@item,
//                    intent = Intent(Intent.ACTION_VIEW, "https://joinmastodon.org/".toUri()).apply {
//                        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
//                        addCategory(Intent.CATEGORY_BROWSABLE)
//                    },
//                    filter = {
//                        when {
//                            it.activityInfo.packageName == packageName -> false
//                            !it.activityInfo.exported -> false
//
//                            // Huaweiの謎Activityのせいでうまく働かないことがある
//                            -1 != it.activityInfo.packageName.indexOf("com.huawei.android.internal") -> false
//
//                            // 標準アプリが設定されていない場合、アプリを選択するためのActivityが出てくる場合がある
//                            it.activityInfo.packageName == "android" -> false
//                            it.activityInfo.javaClass.name.startsWith("com.android.internal") -> false
//                            it.activityInfo.javaClass.name.startsWith("com.android.systemui") -> false
//
//                            // たぶんChromeとかfirefoxとか
//                            else -> true
//                        }
//                    }
//                )
//            }
//            onClickReset = { setWebBrowser(this@item, "") }
//            showTextView = {
//                showWebBrowser(it, this@item.pref.cast<StringPref>()!!.invoke(pref))
//            }
//        }

        sw(PrefB.bpAllowColumnDuplication, R.string.allow_column_duplication)
        sw(PrefB.bpForceGap, R.string.force_gap_when_refresh)
        spinnerSimple(
            PrefI.ipGapHeadScrollPosition,
            R.string.scroll_position_after_read_gap_from_head,
            R.string.gap_head,
            R.string.gap_tail,
        )
        spinnerSimple(
            PrefI.ipGapTailScrollPosition,
            R.string.scroll_position_after_read_gap_from_tail,
            R.string.gap_head,
            R.string.gap_tail,
        )
        text(PrefS.spClientName, R.string.client_name, InputTypeEx.text)

        text(PrefS.spUserAgent, R.string.user_agent, InputTypeEx.textMultiLine) {
            hint = App1.userAgentDefault
            filter = { it.replace(ActAppSetting.reLinefeed, " ").trim() }
            getError = {
                val m = App1.reNotAllowedInUserAgent.matcher(it)
                when (m.find()) {
                    true -> getString(R.string.user_agent_error, m.group())
                    else -> null
                }
            }
        }

        sw(PrefB.bpDontRemoveDeletedToot, R.string.dont_remove_deleted_toot_from_timeline)
        sw(PrefB.bpShowTranslateButton, R.string.show_translate_button)

        item(
            SettingType.TextWithSelector,
            PrefS.spTranslateAppComponent,
            R.string.translation_app
        ) {
            val target = CustomShareTarget.Translate
            onClickEdit = { openCustomShareChooser(this@item, target) }
            onClickReset = { setCustomShare(this@item, target, "") }
            showTextView = { showCustomShareIcon(it, target) }
        }

        item(
            SettingType.TextWithSelector,
            PrefS.spCustomShare1,
            R.string.custom_share_button_1
        ) {
            val target = CustomShareTarget.CustomShare1
            onClickEdit = { openCustomShareChooser(this@item, target) }
            onClickReset = { setCustomShare(this@item, target, "") }
            showTextView = { showCustomShareIcon(it, target) }
        }

        item(
            SettingType.TextWithSelector,
            PrefS.spCustomShare2,
            R.string.custom_share_button_2
        ) {
            val target = CustomShareTarget.CustomShare2
            onClickEdit = { openCustomShareChooser(this@item, target) }
            onClickReset = { setCustomShare(this@item, target, "") }
            showTextView = { showCustomShareIcon(it, target) }
        }
        item(
            SettingType.TextWithSelector,
            PrefS.spCustomShare3,
            R.string.custom_share_button_3
        ) {
            val target = CustomShareTarget.CustomShare3
            onClickEdit = { openCustomShareChooser(this@item, target) }
            onClickReset = { setCustomShare(this@item, target, "") }
            showTextView = { showCustomShareIcon(it, target) }
        }

        spinnerSimple(
            PrefI.ipAdditionalButtonsPosition,
            R.string.additional_buttons_position,
            *(AdditionalButtonsPosition.values().sortedBy { it.idx }.map { it.captionId }
                .toIntArray())
        )

        sw(PrefB.bpEnablePixelfed, R.string.enable_connect_to_pixelfed_server)

        sw(PrefB.bpShowFilteredWord, R.string.show_filtered_word)
        sw(PrefB.bpShowUsernameFilteredPost, R.string.show_username_on_filtered_post)

        sw(PrefB.bpEnableDomainTimeline, R.string.enable_domain_timeline)
    }

    section(R.string.post) {

        item(
            SettingType.Spinner,
            PrefL.lpDefaultPostAccount,
            R.string.post_compose_button_default_account
        ) {
            val lp = pref.cast<LongPref>()!!
            spinnerInitializer = { spinner ->
                launchAndShowError {
                    val list = daoSavedAccount.loadRealAccounts()
                        .sortedByNickname()
                    val listAdapter = AccountAdapter(list)
                    spinner.adapter = listAdapter
                    spinner.setSelection(listAdapter.getIndexFromId(lp.value))
                }
            }
            spinnerOnSelected = { spinner, index ->
                spinner.adapter.cast<ActAppSetting.AccountAdapter>()
                    ?.getIdFromIndex(index)
                    ?.let { lp.value = it }
            }
        }

        spinnerSimple(
            PrefI.ipRefreshAfterToot,
            R.string.refresh_after_toot,
            R.string.refresh_scroll_to_toot,
            R.string.refresh_no_scroll,
            R.string.dont_refresh
        )

        sw(PrefB.bpPostButtonBarTop, R.string.show_post_button_bar_top)

        sw(
            PrefB.bpDontDuplicationCheck,
            R.string.dont_add_duplication_check_header
        )

        sw(PrefB.bpQuickPostBar, R.string.show_quick_toot_bar)

        sw(
            PrefB.bpDontUseActionButtonWithQuickPostBar,
            R.string.dont_use_action_button_with_quick_toot_bar
        )

        text(PrefS.spQuoteNameFormat, R.string.format_of_quote_name, InputTypeEx.text) {
            filter = { it } // don't trim
        }

        sw(
            PrefB.bpAppendAttachmentUrlToContent,
            R.string.append_attachment_url_to_content
        )

        sw(
            PrefB.bpWarnHashtagAsciiAndNonAscii,
            R.string.warn_hashtag_ascii_and_non_ascii
        )


        sw(PrefB.bpIgnoreTextInSharedMedia, R.string.ignore_text_in_shared_media)
    }

    section(R.string.tablet_mode) {

        sw(PrefB.bpDisableTabletMode, R.string.disable_tablet_mode)

        text(PrefS.spColumnWidth, R.string.minimum_column_width, InputTypeEx.number)

        sw(
            PrefB.bpQuickTootOmitAccountSelection,
            R.string.quick_toot_omit_account_selection
        )

        spinnerSimple(
            PrefI.ipJustifyWindowContentPortrait,
            R.string.justify_window_content_portrait,
            R.string.default_,
            R.string.start,
            R.string.end
        )

        sw(
            PrefB.bpMultiWindowPost,
            R.string.multi_window_post
        )
        sw(
            PrefB.bpManyWindowPost,
            R.string.many_window_post
        )
        sw(
            PrefB.bpTabletSnap,
            R.string.tablet_snap
        )
    }

    section(R.string.media_attachment) {
        sw(PrefB.bpUseInternalMediaViewer, R.string.use_internal_media_viewer)

        spinner(PrefI.ipMediaBackground, R.string.background_pattern) {
            MediaBackgroundDrawable.Kind.values()
                .filter { it.isMediaBackground }
                .map { it.name }
        }

        sw(PrefB.bpPriorLocalURL, R.string.prior_local_url_when_open_attachment)
        text(PrefS.spMediaThumbHeight, R.string.media_thumbnail_height, InputTypeEx.number)
        sw(PrefB.bpDontCropMediaThumb, R.string.dont_crop_media_thumbnail)
        sw(PrefB.bpVerticalArrangeThumbnails, R.string.thumbnails_arrange_vertically)
    }

    section(R.string.animation) {
        sw(PrefB.bpImageAnimationEnable, R.string.image_animation_enable)
        sw(PrefB.bpDisableEmojiAnimation, R.string.disable_custom_emoji_animation)
    }

    section(R.string.emoji){

        sw(PrefB.bpUseTwemoji, R.string.use_twemoji_emoji)

        sw(PrefB.bpEmojioneShortcode, R.string.emojione_shortcode_support) {
            desc = R.string.emojione_shortcode_support_desc
        }

        sw(PrefB.bpEmojiPickerCategoryOther, R.string.show_emoji_picker_other_category)

        sw(
            PrefB.bpEmojiPickerCloseOnSelected,
            R.string.close_emoji_picker_when_selected
        )

        sw(PrefB.bpCustomEmojiSeparatorZwsp, R.string.custom_emoji_separator_zwsp)

        text(
            PrefS.spEmojiSizeMastodon,
            R.string.emoji_size_mastodon,
            InputTypeEx.number
        )
        text(
            PrefS.spEmojiSizeMisskey,
            R.string.emoji_size_misskey,
            InputTypeEx.number
        )
        text(
            PrefS.spEmojiSizeReaction,
            R.string.emoji_size_reaction,
            InputTypeEx.number
        )
        text(
            PrefS.spEmojiSizeUserName,
            R.string.emoji_size_user_name,
            InputTypeEx.number
        )

        spinnerSimple(
            PrefI.ipEmojiWideMode,
            R.string.emoji_wide_mode,
            R.string.auto,
            R.string.enabled,
            R.string.disabled,
        )
        text(
            PrefS.spEmojiPixels,
            R.string.emoji_texture_pixels,
            InputTypeEx.number
        )
    }

    section(R.string.appearance) {
        sw(PrefB.bpSimpleList, R.string.simple_list)
        sw(PrefB.bpShowFollowButtonInButtonBar, R.string.show_follow_button_in_button_bar)
        sw(PrefB.bpDontShowPreviewCard, R.string.dont_show_preview_card)
        sw(PrefB.bpShortAcctLocalUser, R.string.short_acct_local_user)
        sw(PrefB.bpMentionFullAcct, R.string.mention_full_acct)
        sw(PrefB.bpRelativeTimestamp, R.string.relative_timestamp)

        item(
            SettingType.Spinner,
            PrefS.spTimeZone,
            R.string.timezone
        ) {
            val sp: StringPref = pref.cast()!!
            spinnerInitializer = { spinner ->
                val adapter = TimeZoneAdapter()
                spinner.adapter = adapter
                spinner.setSelection(adapter.getIndexFromId(sp.value))
            }
            spinnerOnSelected = { spinner, index ->
                val adapter = spinner.adapter.cast<ActAppSetting.TimeZoneAdapter>()
                    ?: error("spinnerOnSelected: missing TimeZoneAdapter")
                sp.value = adapter.getIdFromIndex(index)
            }
        }

        sw(PrefB.bpShowAppName, R.string.always_show_application)
        sw(PrefB.bpShowLanguage, R.string.always_show_language)
        text(PrefS.spAutoCWLines, R.string.auto_cw, InputTypeEx.number)
        text(PrefS.spCardDescriptionLength, R.string.card_description_length, InputTypeEx.number)

        spinnerSimple(
            PrefI.ipRepliesCount,
            R.string.display_replies_count,
            R.string.replies_count_simple,
            R.string.replies_count_actual,
            R.string.replies_count_none
        )
        spinnerSimple(
            PrefI.ipBoostsCount,
            R.string.display_boost_count,
            R.string.replies_count_simple,
            R.string.replies_count_actual,
            R.string.replies_count_none
        )
        spinnerSimple(
            PrefI.ipFavouritesCount,
            R.string.display_favourite_count,
            R.string.replies_count_simple,
            R.string.replies_count_actual,
            R.string.replies_count_none
        )

        spinnerSimple(
            PrefI.ipVisibilityStyle,
            R.string.visibility_style,
            R.string.visibility_style_by_account,
            R.string.mastodon,
            R.string.misskey
        )

        AppSettingItem.TIMELINE_FONT = item(
            SettingType.TextWithSelector,
            PrefS.spTimelineFont,
            R.string.timeline_font
        ) {
            val item = this
            onClickEdit = {
                try {
                    val intent = intentOpenDocument("*/*")
                    arTimelineFont.launch(intent)
                } catch (ex: Throwable) {
                    showToast(ex, "could not open picker for font")
                }
            }
            onClickReset = {
                item.pref?.removeValue()
                showTimelineFont(item)
            }
            showTextView = { showTimelineFont(item, it) }
        }

        AppSettingItem.TIMELINE_FONT_BOLD = item(
            SettingType.TextWithSelector,
            PrefS.spTimelineFontBold,
            R.string.timeline_font_bold
        ) {
            val item = this
            onClickEdit = {
                try {
                    val intent = intentOpenDocument("*/*")
                    arTimelineFontBold.launch(intent)
                } catch (ex: Throwable) {
                    showToast(ex, "could not open picker for font")
                }
            }
            onClickReset = {
                item.pref?.removeValue()
                showTimelineFont(AppSettingItem.TIMELINE_FONT_BOLD)
            }
            showTextView = { showTimelineFont(item, it) }
        }

        AppSettingItem.FONT_SIZE_TIMELINE = textX(
            PrefF.fpTimelineFontSize,
            R.string.timeline_font_size,
            InputTypeEx.numberDecimal
        ) {

            val item = this
            val fp: FloatPref = item.pref.cast()!!

            toFloat = { parseFontSize(it) }
            fromFloat = { formatFontSize(it) }

            captionFontSize = {
                val fv = fp.value
                when {
                    !fv.isFinite() -> PrefF.default_timeline_font_size
                    fv < 1f -> 1f
                    else -> fv
                }
            }
            captionSpacing = {
                PrefS.spTimelineSpacing.value.toFloatOrNull()
            }
            changed = {
                findItemViewHolder(item)?.updateCaption()
            }
        }

        textX(PrefF.fpAcctFontSize, R.string.acct_font_size, InputTypeEx.numberDecimal) {
            val item = this
            val fp: FloatPref = item.pref.cast()!!

            toFloat = { parseFontSize(it) }
            fromFloat = { formatFontSize(it) }

            captionFontSize = {
                val fv = fp.value
                when {
                    !fv.isFinite() -> PrefF.default_acct_font_size
                    fv < 1f -> 1f
                    else -> fv
                }
            }

            changed = { findItemViewHolder(item)?.updateCaption() }
        }

        AppSettingItem.FONT_SIZE_NOTIFICATION_TL = textX(
            PrefF.fpNotificationTlFontSize,
            R.string.notification_tl_font_size,
            InputTypeEx.numberDecimal
        ) {
            val item = this
            val fp: FloatPref = item.pref.cast()!!

            toFloat = { parseFontSize(it) }
            fromFloat = { formatFontSize(it) }

            captionFontSize = {
                val fv = fp.value
                when {
                    !fv.isFinite() -> PrefF.default_notification_tl_font_size
                    fv < 1f -> 1f
                    else -> fv
                }
            }
            captionSpacing = {
                PrefS.spTimelineSpacing.value.toFloatOrNull()
            }
            changed = {
                findItemViewHolder(item)?.updateCaption()
            }
        }

        text(
            PrefS.spNotificationTlIconSize,
            R.string.notification_tl_icon_size,
            InputTypeEx.numberDecimal
        )

        text(PrefS.spTimelineSpacing, R.string.timeline_line_spacing, InputTypeEx.numberDecimal) {
            changed = {
                findItemViewHolder(AppSettingItem.FONT_SIZE_TIMELINE)?.updateCaption()
                findItemViewHolder(AppSettingItem.FONT_SIZE_NOTIFICATION_TL)?.updateCaption()
            }
        }

        text(PrefS.spBoostButtonSize, R.string.boost_button_size, InputTypeEx.numberDecimal)

        spinnerSimple(
            PrefI.ipBoostButtonJustify,
            R.string.boost_button_alignment,
            R.string.start,
            R.string.center,
            R.string.end
        )

        text(PrefS.spAvatarIconSize, R.string.avatar_icon_size, InputTypeEx.numberDecimal)
        text(PrefS.spRoundRatio, R.string.avatar_icon_round_ratio, InputTypeEx.numberDecimal)
        sw(PrefB.bpDontRound, R.string.avatar_icon_dont_round)
        text(PrefS.spReplyIconSize, R.string.reply_icon_size, InputTypeEx.numberDecimal)
        text(PrefS.spHeaderIconSize, R.string.header_icon_size, InputTypeEx.numberDecimal)
        textX(PrefF.fpHeaderTextSize, R.string.header_text_size, InputTypeEx.numberDecimal) {
            val item = this
            val fp: FloatPref = item.pref.cast()!!

            toFloat = { parseFontSize(it) }
            fromFloat = { formatFontSize(it) }

            captionFontSize = {
                val fv = fp.value
                when {
                    !fv.isFinite() -> PrefF.default_header_font_size
                    fv < 1f -> 1f
                    else -> fv
                }
            }

            changed = {
                findItemViewHolder(item)?.updateCaption()
            }
        }

        text(PrefS.spStripIconSize, R.string.strip_icon_size, InputTypeEx.numberDecimal)

        text(PrefS.spScreenBottomPadding, R.string.screen_bottom_padding, InputTypeEx.numberDecimal)

        sw(PrefB.bpOpenSticker, R.string.show_open_sticker) {
            desc = R.string.powered_by_open_sticker
            descClick = { openBrowser("https://github.com/cutls/OpenSticker") }
        }

        sw(PrefB.bpLinksInContextMenu, R.string.show_links_in_context_menu)
        sw(PrefB.bpShowLinkUnderline, R.string.show_link_underline)

        sw(PrefB.bpMfmDecorationEnabled, R.string.mfm_decoration_enabled)
        sw(PrefB.bpMfmDecorationShowUnsupportedMarkup, R.string.mfm_show_unsupported_markup)

        sw(
            PrefB.bpMoveNotificationsQuickFilter,
            R.string.move_notifications_quick_filter_to_column_setting
        )
        sw(PrefB.bpShowSearchClear, R.string.show_clear_button_in_search_bar)
        sw(
            PrefB.bpDontShowColumnBackgroundImage,
            R.string.dont_show_column_background_image
        )

        group(R.string.show_in_directory) {
            checkbox(PrefB.bpDirectoryLastActive, R.string.last_active)
            checkbox(PrefB.bpDirectoryFollowers, R.string.followers)
            checkbox(PrefB.bpDirectoryTootCount, R.string.toot_count)
            checkbox(PrefB.bpDirectoryNote, R.string.note)
        }

        sw(
            PrefB.bpAlwaysExpandContextMenuItems,
            R.string.always_expand_context_menu_sub_items
        )
        sw(PrefB.bpShowBookmarkButton, R.string.show_bookmark_button)
        sw(PrefB.bpHideFollowCount, R.string.hide_followers_count)

        sw(PrefB.bpKeepReactionSpace, R.string.keep_reaction_space)

        text(PrefS.spEventTextAlpha, R.string.event_text_alpha, InputTypeEx.numberDecimal)
    }

    section(R.string.color) {

        spinnerSimple(
            PrefI.ipUiTheme,
            R.string.ui_theme,
            R.string.theme_light,
            R.string.theme_dark,
            R.string.theme_mastodon_dark,
        )

        colorAlpha(PrefI.ipListDividerColor, R.string.list_divider_color)
        colorAlpha(PrefI.ipLinkColor, R.string.link_color)

        group(R.string.toot_background_color) {
            colorAlpha(PrefI.ipTootColorUnlisted, R.string.unlisted_visibility)
            colorAlpha(PrefI.ipTootColorFollower, R.string.followers_visibility)
            colorAlpha(PrefI.ipTootColorDirectUser, R.string.direct_with_user_visibility)
            colorAlpha(PrefI.ipTootColorDirectMe, R.string.direct_only_me_visibility)
        }

        group(R.string.event_background_color) {
            colorAlpha(PrefI.ipEventBgColorBoost, R.string.boost)
            colorAlpha(PrefI.ipEventBgColorFavourite, R.string.favourites)
            colorAlpha(PrefI.ipEventBgColorBookmark, R.string.bookmarks)
            colorAlpha(PrefI.ipEventBgColorMention, R.string.reply)
            colorAlpha(PrefI.ipEventBgColorFollow, R.string.follow)
            colorAlpha(PrefI.ipEventBgColorUnfollow, R.string.unfollow_misskey)
            colorAlpha(PrefI.ipEventBgColorFollowRequest, R.string.follow_request)
            colorAlpha(PrefI.ipEventBgColorReaction, R.string.reaction)
            colorAlpha(PrefI.ipEventBgColorQuote, R.string.quote_renote)
            colorAlpha(PrefI.ipEventBgColorVote, R.string.vote_polls)
            colorAlpha(PrefI.ipEventBgColorStatus, R.string.status)
            colorAlpha(PrefI.ipEventBgColorUpdate, R.string.notification_type_update)
            colorAlpha(
                PrefI.ipEventBgColorStatusReference,
                R.string.notification_type_status_reference
            )
            colorAlpha(PrefI.ipEventBgColorSignUp, R.string.notification_type_signup)
            colorAlpha(PrefI.ipEventBgColorReport, R.string.notification_type_report)

            colorAlpha(
                PrefI.ipConversationMainTootBgColor,
                R.string.conversation_main_toot_background_color
            )

            colorAlpha(PrefI.ipEventBgColorGap, R.string.gap)
            colorAlpha(PrefI.ipEventBgColorFiltered, R.string.filtered)
        }

        group(R.string.button_accent_color) {
            colorAlpha(PrefI.ipButtonBoostedColor, R.string.boost)
            colorAlpha(PrefI.ipButtonFavoritedColor, R.string.favourites)
            colorAlpha(PrefI.ipButtonBookmarkedColor, R.string.bookmarks)
            colorAlpha(PrefI.ipButtonFollowingColor, R.string.follow)
            colorAlpha(PrefI.ipButtonFollowRequestColor, R.string.follow_request)
            colorAlpha(PrefI.ipButtonReactionedColor, R.string.reaction)
        }

        group(R.string.column_color_default) {
            AppSettingItem.SAMPLE_CCD_HEADER =
                sample(R.layout.setting_sample_column_header) { activity, viewRoot ->

                    val llColumnHeader: View = viewRoot.findViewById(R.id.llColumnHeader)
                    val ivColumnHeader: ImageView = viewRoot.findViewById(R.id.ivColumnHeader)
                    val tvColumnName: TextView = viewRoot.findViewById(R.id.tvColumnName)

                    val colorColumnHeaderBg = PrefI.ipCcdHeaderBg.value
                    val colorColumnHeaderFg = PrefI.ipCcdHeaderFg.value

                    val headerBg = when {
                        colorColumnHeaderBg != 0 -> colorColumnHeaderBg
                        else -> activity.attrColor(R.attr.color_column_header)
                    }

                    val headerFg = when {
                        colorColumnHeaderFg != 0 -> colorColumnHeaderFg
                        else -> activity.attrColor(R.attr.colorColumnHeaderName)
                    }

                    llColumnHeader.background = getAdaptiveRippleDrawable(headerBg, headerFg)

                    tvColumnName.setTextColor(headerFg)
                    ivColumnHeader.setImageResource(R.drawable.ic_bike)
                    ivColumnHeader.imageTintList = ColorStateList.valueOf(headerFg)
                }

            colorOpaque(PrefI.ipCcdHeaderBg, R.string.header_background_color) {
                changed = { showSample(AppSettingItem.SAMPLE_CCD_HEADER) }
            }
            colorOpaque(PrefI.ipCcdHeaderFg, R.string.header_foreground_color) {
                changed = { showSample(AppSettingItem.SAMPLE_CCD_HEADER) }
            }

            AppSettingItem.SAMPLE_CCD_BODY =
                sample(R.layout.setting_sample_column_body) { activity, viewRoot ->
                    val flColumnBackground: View = viewRoot.findViewById(R.id.flColumnBackground)
                    val tvSampleAcct: TextView = viewRoot.findViewById(R.id.tvSampleAcct)
                    val tvSampleContent: TextView = viewRoot.findViewById(R.id.tvSampleContent)

                    val colorColumnBg = PrefI.ipCcdContentBg.value
                    val colorColumnAcct = PrefI.ipCcdContentAcct.value
                    val colorColumnText = PrefI.ipCcdContentText.value

                    flColumnBackground.setBackgroundColor(colorColumnBg) // may 0

                    tvSampleAcct.setTextColor(
                        colorColumnAcct.notZero()
                            ?: activity.attrColor(R.attr.colorTimeSmall)
                    )

                    tvSampleContent.setTextColor(
                        colorColumnText.notZero()
                            ?: activity.attrColor(R.attr.colorTextContent)
                    )
                }

            colorOpaque(PrefI.ipCcdContentBg, R.string.content_background_color) {
                changed = { showSample(AppSettingItem.SAMPLE_CCD_BODY) }
            }
            colorAlpha(PrefI.ipCcdContentAcct, R.string.content_acct_color) {
                changed = { showSample(AppSettingItem.SAMPLE_CCD_BODY) }
            }
            colorAlpha(PrefI.ipCcdContentText, R.string.content_text_color) {
                changed = { showSample(AppSettingItem.SAMPLE_CCD_BODY) }
            }
        }

        text(PrefS.spBoostAlpha, R.string.boost_button_alpha, InputTypeEx.numberDecimal)

        group(R.string.footer_color) {
            AppSettingItem.SAMPLE_FOOTER =
                sample(R.layout.setting_sample_footer) { activity, viewRoot ->
                    val ivFooterToot: AppCompatImageView = viewRoot.findViewById(R.id.ivFooterToot)
                    val ivFooterMenu: AppCompatImageView = viewRoot.findViewById(R.id.ivFooterMenu)
                    val llFooterBG: View = viewRoot.findViewById(R.id.llFooterBG)
                    val vFooterDivider1: View = viewRoot.findViewById(R.id.vFooterDivider1)
                    val vFooterDivider2: View = viewRoot.findViewById(R.id.vFooterDivider2)
                    val vIndicator: View = viewRoot.findViewById(R.id.vIndicator)

                    val footerButtonBgColor = PrefI.ipFooterButtonBgColor.value
                    val footerButtonFgColor = PrefI.ipFooterButtonFgColor.value
                    val footerTabBgColor = PrefI.ipFooterTabBgColor.value
                    val footerTabDividerColor = PrefI.ipFooterTabDividerColor.value
                    val footerTabIndicatorColor = PrefI.ipFooterTabIndicatorColor.value

                    val colorColumnStripBackground = footerTabBgColor.notZero()
                        ?: activity.attrColor(R.attr.colorColumnStripBackground)

                    llFooterBG.setBackgroundColor(colorColumnStripBackground)

                    val colorButtonBg = footerButtonBgColor.notZero()
                        ?: colorColumnStripBackground

                    val colorButtonFg = footerButtonFgColor.notZero()
                        ?: activity.attrColor(R.attr.colorRippleEffect)

                    ivFooterMenu.backgroundDrawable =
                        getAdaptiveRippleDrawableRound(activity, colorButtonBg, colorButtonFg)
                    ivFooterToot.backgroundDrawable =
                        getAdaptiveRippleDrawableRound(activity, colorButtonBg, colorButtonFg)

                    val csl = ColorStateList.valueOf(
                        footerButtonFgColor.notZero()
                            ?: activity.attrColor(R.attr.colorTextContent)
                    )
                    ivFooterToot.imageTintList = csl
                    ivFooterMenu.imageTintList = csl

                    val c = footerTabDividerColor.notZero()
                        ?: colorColumnStripBackground
                    vFooterDivider1.setBackgroundColor(c)
                    vFooterDivider2.setBackgroundColor(c)

                    vIndicator.setBackgroundColor(
                        footerTabIndicatorColor.notZero()
                            ?: activity.attrColor(R.attr.colorTextHelp)
                    )
                }

            colorOpaque(PrefI.ipFooterButtonBgColor, R.string.button_background_color) {
                changed = { showSample(AppSettingItem.SAMPLE_FOOTER) }
            }
            colorOpaque(PrefI.ipFooterButtonFgColor, R.string.button_foreground_color) {
                changed = { showSample(AppSettingItem.SAMPLE_FOOTER) }
            }
            colorOpaque(PrefI.ipFooterTabBgColor, R.string.quick_toot_bar_background_color) {
                changed = { showSample(AppSettingItem.SAMPLE_FOOTER) }
            }
            colorOpaque(PrefI.ipFooterTabDividerColor, R.string.tab_divider_color) {
                changed = { showSample(AppSettingItem.SAMPLE_FOOTER) }
            }
            colorAlpha(PrefI.ipFooterTabIndicatorColor, R.string.tab_indicator_color) {
                changed = { showSample(AppSettingItem.SAMPLE_FOOTER) }
            }
        }

        colorOpaque(PrefI.ipSwitchOnColor, R.string.switch_button_color) {
            changed = { setSwitchColor() }
        }

        colorOpaque(PrefI.ipStatusBarColor, R.string.status_bar_color) {
            changed = { setStatusBarColor() }
        }

        colorOpaque(PrefI.ipNavigationBarColor, R.string.navigation_bar_color) {
            changed = { setStatusBarColor() }
        }

        colorOpaque(PrefI.ipSearchBgColor, R.string.search_bar_background_color)
        colorAlpha(PrefI.ipPopupBgColor, R.string.popup_background_color)
        colorAlpha(PrefI.ipAnnouncementsBgColor, R.string.announcement_background_color)
        colorAlpha(PrefI.ipVerifiedLinkBgColor, R.string.verified_link_background_color)
        colorAlpha(PrefI.ipVerifiedLinkFgColor, R.string.verified_link_foreground_color)
    }

    section(R.string.performance) {
        sw(PrefB.bpShareViewPool, R.string.share_view_pool)
        sw(PrefB.bpDontUseStreaming, R.string.dont_use_streaming_api)
        sw(PrefB.bpDontRefreshOnResume, R.string.dont_refresh_on_activity_resume)
        text(PrefS.spMediaReadTimeout, R.string.timeout_for_embed_media_viewer, InputTypeEx.number)
        text(PrefS.spApiReadTimeout, R.string.timeout_for_server_api, InputTypeEx.number)
        action(R.string.delete_custom_emoji_cache) {
            action = {
                App1.custom_emoji_cache.delete()
            }
        }
    }

    section(R.string.developer_options) {
        sw(PrefB.bpCheckBetaVersion, R.string.check_beta_release)

        sw(PrefB.bpEnableDeprecatedSomething,R.string.enable_deprecated_something)

        action(R.string.drawable_list) {
            action = { startActivity(Intent(this, ActDrawableList::class.java)) }
        }

        action(R.string.exit_reasons) {
            action = {
                if (Build.VERSION.SDK_INT >= 30) {
                    startActivity(Intent(this, ActExitReasons::class.java))
                } else {
                    showToast(false, "this feature requires Android 11")
                }
            }
        }

        action(R.string.test_progress_dialog) {
            action = {
                launchAndShowError {
                    runInProgress(cancellable = true) {
                        it.setMessage("message")
                        it.setTitle("title")
                        delay(2000L)
                        it.setMessage("message ".repeat(30))
                        it.setTitle("title ".repeat(30))
                        delay(2000L)
                    }
                }
            }
        }

        action(R.string.glide_test) {
            action = {
                startActivity(Intent(this, ActGlideTest::class.java))
            }
        }

        action(R.string.alert_test) {
            action = { showAlertNotification("this is a test.") }
        }

    }

    section(R.string.bug_report){
        spinnerSimple(
            PrefI.ipLogSaveLevel,
            R.string.log_save_level, // name
            R.string.log_all, //0
            R.string.log_all, //1
            R.string.log_verbose, //2
            R.string.log_debug, //3
            R.string.log_info, //4
            R.string.log_warn, //5
            R.string.log_error, //6
            R.string.log_assert, //7
        ){
            desc = R.string.log_save_level_desc
        }

        action(R.string.send_log_email) {
            action = { exportLog() }
            desc = R.string.bug_report_desc
        }
    }

    action(R.string.app_data_export) {
        action = { exportAppData() }
    }

    action(R.string.app_data_import) {
        action = { importAppData1() }
        desc = R.string.app_data_import_desc
    }
}