data class KeyboardConfiguration(
    val language: LanguageConfiguration,
    val typing: TypingConfiguration,
    val privacy: PrivacyConfiguration,
    val style: StyleConfiguration,
    val features: FeaturesConfiguration,
    val predictions: PredictionsConfiguration,
    val legacy: LegacyConfiguration,
    val capture: CaptureConfiguration,
    val monitor: MonitorConfiguration,
    val emoji: EmojiConfiguration,
    val feedback: FeedbackConfiguration,
    val customizationBundle: CustomizationBundleConfiguration
)

KeyboardConfiguration(
    language = LanguageConfiguration(
      current = KeyboardLanguage(“de-DE”, “QWERTZ”)
    ),
    style = StyleConfiguration(
      forceTheme = SystemThemes.lightTheme,
      forceDarkTheme = SystemThemes.darkTheme
    )
)

data class LanguageConfiguration(
    var current: KeyboardLanguage = DEFAULT_KEYBOARD_LANGUAGE,
    val userLanguages: List<KeyboardLanguage> = listOf(current),
    val automaticDownload: Boolean = false,
    val repository: LanguageRepository = LanguageRepository.PRODUCTION
)

LanguageConfiguration(
    current = KeyboardLanguage(“de-DE”, “QWERTZ”),
    userLanguages = listOf(
        KeyboardLanguage(“de-DE”, “QWERTZ”),
        KeyboardLanguage(“es-ES”)
    ),
    automaticDownload = true,
    repository = LanguageRepository.BETA
)

data class TypingConfiguration(
    val caseSensitive: Boolean = true,
    val smartPunctuation: Boolean = false,
    val autoCapsBox: Boolean = true,
    val autoCorrect: Boolean = true,
    val autoLearn: Boolean = true,
    val allowBackspaceToUndoAC: Boolean = true,
    val doubleSpaceTapAddsPunctuation: Boolean = true,
    val tripleSpaceAddsSpaceKey: Boolean = true,
    val holdMode: HoldMode = HoldMode.POP,
    val maxPopColumns: Int = 4,
    val longPressForAccents: Boolean = true,
    val magicButtonIcon: Icon = Icon.EMOJI,
    val magicButtonActions: List<Icon>? = null,
    val magicButtonTypeface: Typeface? = null,
    val isMinimal: Boolean = false,
    val minimalGestures: Boolean = false,
    val swipeTyping: Boolean = true,
    val punctuationSymbols: List<String>? = null,
    val swipeTriggerFactor: Float = 0.5f,
    val swipeGesturesLength: Float = 1.0f,
    val swipeRightToAddSpace: Boolean = true,
    val spaceBarLanguageGesture: Boolean = true,
    val spaceBarTypingGesture: Boolean = true,
    val dragAndHoldToDelete: Boolean = false,
    val invertSwipeGestures: Boolean = false,
    val swipeLeftToDelete: Boolean = true,
    val autoCorrectAfterPunctuation: Boolean = false
)

TypingConfiguration(
    caseSensitive = true,
    smartPunctuation = false,
    autoCapsBox = true,
    autoCorrect = true,
    autoLearn = true,
    doubleSpaceTapAddsPunctuation = true,
    tripleSpaceAddsSpaceKey = true,
    holdMode = HoldMode.POP,
    maxPopColumns = 8,
    longPressForAccents = true,
    magicButtonIcon = Icon.COMMA,
    magicButtonActions = listOf(Icon.EMOJI, Icon.COMMA, Icon.AC_TOGGLE)
    isMinimal = false,
    swipeTyping = true,
    punctuationSymbols = listOf(“!”, “?”, “,”, “@”, “#”),
    swipeTriggerFactor = 0.5f,
    swipeGesturesLength = 1.0f,
    swipeRightToAddSpace = true,
    invertSwipeGestures = false
)

sealed class MagicAction {
    data class DefaultAction(
        val icon: Icon, 
        val iconLabel: String = icon.text
    ) : MagicAction()

    data class CustomAction(
        val iconLabel: String, 
        val callback: () -> Unit
    ) : MagicAction()
}

val magicAction = MagicAction.DefaultAction(Icon.EMOJI, “\u6832”)

val magicActions = listOf(
    MagicAction.DefaultAction(Icon.MIC_ON),
    MagicAction.CustomAction(“\u6833”) { PanelHelper.openApp(“giphy”) } 
)

@Keep
    data class TypingConfiguration(
        ...
        val magicButtonTypeface: Typeface? = null,
        
        customMagicAction = MagicAction.DefaultAction(
            Icon.COMMA, //The button action will be typing a comma
            Icon.IMOJI.text //The icon shown will be the "imoji" logo
        ),
        
        customMagicActions = listOf(
            //Action implicit in the icon enum. In this chase, change language.
            MagicAction.DefaultAction(Icon.GLOBE), 
            
            //Action is read from the Icon.AC_OFF. The icon to be show is the code "\uE654"
            MagicAction.DefaultAction(Icon.AC_OFF, "\uE654"), 
            
            //A custom action has an icon (in this case a custom icon code) and a function
            MagicAction.CustomAction("\uE619"){ 
                TODO("Do custom action")
            }
        ),
    ...
}

data class PrivacyConfiguration(
    val trackingEnabled: Boolean = false,
    val updateNoiseEstimation: Boolean = false,
    val reportAnalytics: Boolean = false
)

PrivacyConfiguration(
    trackingEnabled = true,
    updateNoiseEstimation = true
)

data class StyleConfiguration(
    val keyboardSize: KeyboardSize = KeyboardSize.MEDIUM,
    val themeKey: String? = null,
    val darkThemeKey: String? = null,
    val userFont: KeyboardFont = KeyboardFont.ROBOT_REGULAR,
    val useStandardLayoutSystem: Boolean = true,
    val forceTheme: KeyboardTheme? = null,
    val forceDarkTheme: KeyboardTheme? = null,
    val themeImagesPath: String? = null,
    val userImagesPath: String? = null,
    val keyboardInsets: KeyboardInsets? = null,
    val spacebarLogo: Drawable? = null,
    val fitSpacebarLogo: Boolean = true,
    val swipeDuration: Long = 800,
    val hoverStyle: HoverStyle? = null,
    val hoverTileSizeFactor: Float = 1.0,
    val drawHomeRow: Boolean = false,
    val spacebarStyle: SpacebarStyle = SpacebarStyle.Automatic,
    val firstRowHints: Boolean = false,
    val allRowsHints: Boolean = false,
    val keyboardFontRation: Float = 1.0f
)

StyleConfiguration(
    keyboardSize = KeyboardSize.MEDIUM,
    userFont = KeyboardFont.GILROY_MEDIUM,
    useStandardLayoutSystem = true,
    forceTheme = SystemThemes.lightTheme,
    forceDarkTheme = SystemThemes.darkTheme,
    keyboardInsets = KeyboardInsets(left=SIDE_MARGIN_PX, right=SIDE_MARGIN_PX),
    spacebarLogo = ContextCompat.getDrawable(context, R.drawable.logo),
    fitSpacebarLogo = true,
    swipeDuration = 300,
    hoverStyle = HoverStyle.FactorSizeBar(
        widthFactor = 1.1f,
        heightFactor = 1.75f,
        maxWidth = resources.getDimensionPixelOffset(R.dimen.max_hover_width),
        maxHeight = resources.getDimensionPixelOffset(R.dimen.max_hover_height)
    ),
    hoverTileSizeFactor = 1.0f,
    drawHomeRow = false
)

HoverStyle.FixedSizeBar(
    width = resources.getDimensionPixelOffset(R.dimen.hover_bar_width),
    height = resources.getDimensionPixelOffset(R.dimen.hover_bar_height)
)

HoverStyle.FactorSizeBar(
    widthFactor = 1.1f,
    heightFactor = 1.75f,
    width = resources.getDimensionPixelOffset(R.dimen.hover_max_width),
    height = resources.getDimensionPixelOffset(R.dimen.hover_max_height)
)

abstract class Custom : HoverStyle() {
    val listener: Listener? = null
    val context: Context? = null
    val keyboardBounds: RectF? = null
    val theme: KeyboardTheme? = null
    val typeface: Typeface? = null
 
    var hoverKey: Key? = null
    var holdKey: Key? = null
 
    val isReady : Boolean
    val isHover : Boolean
    val isHold : Boolean
 
    abstract val willDrawCustomHover: Boolean
    abstract val willDrawCustomHoldPanel: Boolean
 
    open fun onDraw(canvas: Canvas) {}
    open fun onHoverStart() {}
    open fun onHoverEnd() {}
    open fun onHoldStart() {}
    open fun onHoldEnd() {}
    open fun onHoldDrag(x: Float, y: Float) : Boolean = true
    open fun onHoldRelease(): String? = null
    open fun onThemeChanged(theme: KeyboardTheme) {}
}

class MyCustomHover : HoverStyle.Custom() {
    private val tempRect = Rect();
 
    override val willDrawCustomHover: Boolean get() = true
    override val willDrawCustomHoldPanel: Boolean get() = false
 
    private val drawable by lazy {
        context?.let {
            ContextCompat.getDrawable(it, R.drawable.circle)
        }
    }
 
    override fun onDraw(canvas: Canvas) {
        hoverKey?.also { key ->
            if (!key.isButton) {
                drawable?.apply {
                    tempRect.set(
                        key.x.toInt() - intrinsicWidth / 2,
                        key.y.toInt() - intrinsicHeight / 2,
                        key.x.toInt() + intrinsicWidth / 2,
                        key.y.toInt() + intrinsicHeight / 2
                    )
                    bounds = tempRect
                    draw(canvas)
                }
                listener?.drawText(canvas, key.x, key.y, key.label, Color.WHITE)
            }
        }
    }
}

interface Listener {
    fun redraw()
    fun drawText(
        canvas: Canvas, 
        x: Float, 
        y: Float, 
        label: String, 
        @ColorInt letterColor: Int? = null
    )
}

data class Key(
    val x: Float,
    val y: Float,
    val width: Float,
    val height: Float,
    val label: String,
    val labels: List<String>,
    val isButton: Boolean
)

abstract class Custom : SpacebarStyle() {
    var listener : Listener? = null
    var context : Context? = null
    var theme : KeyboardTheme? = null
    val state : State = State()
 
    abstract val willDrawKeycap: Boolean
    abstract val willDrawLanguages: Boolean
    abstract val willDrawIcons: Boolean
 
    open fun onLanguageSet(currentLanguage: String, languages: Set<String>) {}
    open fun onStateUpdated(state: State) {}
    open fun onThemeSet(theme: KeyboardTheme) {}
    open fun onDrawKeyCap(canvas: Canvas) {}
    open fun onDrawLabels(canvas: Canvas) {}
    open fun onDrawIcons(canvas: Canvas) {}
 
    interface Listener {
        fun redraw()
    }
 
    data class State(
        var x: Float = 0f,
        var y: Float = 0f,
        var width: Float = 0f,
        var height: Float = 0f,
        var pressed: Boolean = false,
        var autoCorrectEnabled: Boolean = false,
        var currentLanguage: String = String.empty(),
        var sortedUserLanguages: Set<String> = emptySet()
    )
}

private val spaceBarExample: SpacebarStyle = object : SpacebarStyle.Custom() {
    override val willDrawIcons: Boolean get() = true
    override val willDrawKeycap: Boolean get() = true
    override val willDrawLanguages: Boolean get() = true
 
    private val keyPaint = Paint()
    private val keyPaintPressed = Paint()
    private val labelPaint = Paint().apply { textAlign = CENTER; textSize = 14f }
    private val iconPaint = Paint().apply { textAlign = RIGHT; textSize = 10f }
    private var keyRect: RectF = RectF()
 
    override fun onThemeSet(theme: KeyboardTheme) {
        keyPaint.color = Color.RED
        keyPaintPressed.color = Color.BLUE
        labelPaint.color = Color.BLACK
        iconPaint.color = Color.BLACK
 
        onStateUpdated(state)
    }
 
    override fun onStateUpdated(state: State) {
        val hs = context?.dp2px((theme?.keycapSpacingHorizontal ?: 0f)) ?: 0f
        val vs = context?.dp2px((theme?.keycapSpacingVertical ?: 0f)) ?: 0f
 
        keyRect.set(
            state.x - state.width / 2f + hs,
            state.y - state.height / 2f + vs,
            state.x + state.width / 2f - hs,
            state.y + state.height / 2f - vs
        )
 
        labelPaint.textSize = keyRect.height() / 3f
        iconPaint.textSize = keyRect.height() / 6f
    }
 
    override fun onDrawKeyCap(canvas: Canvas) {
        canvas.drawRect(keyRect, if (state.pressed) keyPaintPressed else keyPaint)
    }
 
    override fun onDrawLabels(canvas: Canvas) {
        canvas.drawText(state.currentLanguage, state.x, state.y, labelPaint)
    }
 
    override fun onDrawIcons(canvas: Canvas) {
        if (!state.autoCorrectEnabled) {
            canvas.drawText("AC OFF", keyRect.right, keyRect.bottom, iconPaint)
        }
    }
}

data class FeaturesConfiguration(
    val suggestions: Boolean = true,
    val suggestionGestures: Boolean = suggestions,
    val nsp: Boolean = false,
    val emojiPrediction: Boolean = false,
    val textToSpeech: Boolean = false,
    val speechMode: SpeechMode = SpeechMode.SystemIME,
    val maxTextToSpeechQueuedUtterances: Int = 2,
    val numberRow: Boolean = false
)

FeaturesConfiguration(
    suggestions = false,
    nsp = false,
    emojiPrediction = false,
    textToSpeech = false,
    speechMode = SpeechMode.Recognizer
)

data class PredictionsConfiguration(
    val predictionTypes: List<PredictionModelType> = listOf(PredictionModelType.WORD),
    val predictionStrategy: PredictionStrategy = CoreContainerStrategy(),
    val showEnteredText: Boolean = true,
    val showEmojiSuggestions: Boolean = false
)

PredictionsConfiguration(
    keyboardApps = emptyList(),
    predictionTypes = listOf(PredictionModelType.WORD, PredictionModelType.EMOJI)
)

interface PredictionStrategy {
    fun setNextWordPredictionEnabled(enabled: Boolean)
    fun init(parent: FrameLayout, listener: PredictionListener)
    fun onPredictionsChanged(predictions: List<PredictionModel>)
    fun addNextSearch(search: PredictionModel.Search)
    fun reset()
    fun onThemeChanged(theme: KeyboardTheme)
}

interface PredictionListener {
    fun emojiClicked(emoji: String)
    fun wordClicked(nextWord: PredictionModel.Word)
}

private val predictionStrategy: PredictionStrategy by lazy {
    object : PredictionStrategy.DefaultPredictionStrategy() {
        lateinit var listener: PredictionListener
        lateinit var firstPrediction: TextView


        override fun init(parent: FrameLayout, listener: PredictionListener) {
            this.listener = listener
            firstPrediction = TextView(parent.context)
            parent.addView(firstPrediction)
        }
 
        override fun onPredictionsChanged(predictions: List<PredictionModel>) {
            var wordPredictions = predictions.filterIsInstance<PredictionModel.Word>()
            wordPredictions.firstorNull()?.also { prediction ->
                firstPrediction.text = prediction.content
                firstPrediction.setOnClickListener { listener.wordClicked(prediction) }
            }
        }
 
        override fun reset() {
            firstPrediction.text = ""
        }
 
        override fun onThemeChanged(theme: KeyboardTheme) {
            firstPrediction.setTextColor(theme.keyLetters)
        }
    }
}

data class LegacyConfiguration(
    val useLegacyLayout: Boolean = false,
    val useAllAccents: Boolean = false,
    val swapEnterDelete: Boolean = false
)

data class DataCaptureMode.EventBased(
    EventDataConfiguration(
        keyStroke = true,
        delete = true,
        keyPlane = true,
        word = true,
        swipe = true,
        sessionUpdate = true,
        stressUpdate = true
    )

data class CaptureConfiguration(
    val enabled: Boolean = false,
    val logEvents: Boolean = false,
    val sendDataEvents: Boolean = false,
    val storeData: Boolean = true,
    val location: String = ”resources”,
    val dataConfiguration: FLDataConfiguration = FLDataConfiguration()
)

CaptureConfiguration(
    enabled = true,
    logEvents = BuildConfig.DEBUG,
    location = “captures”,
    dataConfiguration = FLDataConfiguration(dataText = false)
)

data class FLDataConfiguration(
    val dataText: Boolean = true,
    val dataSwipe: Boolean = true,
    val dataEmoji: Boolean = true,
    val dataLayout: Boolean = true,
    val dataTextField: Boolean = true,
    val dataLanguage: Boolean = true,
    val dataType: Boolean = true,
    val dataArea: Boolean = true,
    val dataCode: Boolean = true,
    val dataPosition: Boolean = true,
    val dataPress: Boolean = true,
    val dataKeyPress: Boolean = true,
    val dataKeyCenter: Boolean = true,
    val dataKeyBounds: Boolean = true,
    val dataConfigCoordinate: Int = DataConfigCoordinate.SCREEN_PIXEL
)

data class MonitorConfiguration(
    val extractionMode: ExtractionMode = ExtractionMode.DISABLED,
    val composing: Boolean = false
    val input: Boolean = false 
)

MonitorConfiguration(
    extractionMode = ExtractionMode.AGGREGATE,
    composing = true
    input = true
)

data class EmojiConfiguration(
    val animatePanel: Boolean = true,
    val swipeDownToClose: Boolean = true,
    val keepVariations: Boolean = true,
    val recent: Set<String> = emptySet(),
    val variations: Map<String, String> = emptyMap(),
    val defaultSkinTone: EmojiSkinTone = EmojiSkinTone.NEUTRAL,
    val defaultGender: EmojiGender = EmojiGender.NEUTRAL,
    val androidOnly: Boolean = true,
    val addsSpaceAfterEmojiKey: Boolean = true
)

EmojiConfiguration(
    animatePanel = false,
    swipeDownToCLose = false,
    recent = listOf("😂", "😍", "😭", "☺️"),
    variations = mapOf(“👩” to "👩🏿”),
    defaultSkinTone = EmojiSkinTone.MEDIUM_DARK,
    defaultGender = EmojiGender.WOMAN,
    androidOnly = true,
    addsSpaceAfterEmojiKey = true
)

data class AppConfiguration(
    val keyboardApps: List<KeyboardApp> = emptyList(),
    val shareAuthority: String? = null,
    val shareDirectory: String = "SharedContent",
    val shareContentExpiration: Long = TimeUnit.DAYS.toMillis(1),
    val showAppsInCarousel: Boolean = true
)

val apps by lazy { listOf(GiphyApp(“key”)) }

AppsConfiguration(
    keyboardApps = apps,
    shareAuthority = "$packageName.fileprovider",
    shareDirectory = "SharedContent",
    shareContentExpiration = TimeUnit.HOURS.toMillis(1),
    showAppsInCarousel = false
)

data class LicenseConfiguration(
    val licenseKey: String? = null,
    val licenseSecret: String? = null
)

data class FeedbackConfiguration(
    val soundMode: SoundMode = SoundMode.Silent,
    val vibrationMode: VibrationMode = VibrationMode.Haptic(true)
)

FeedbackConfiguration(
    soundMode = SoundMode.Resources(
        ResourceSoundSet(
            tap = R.raw.v2_tap,
            spacebar = R.raw.v2_spacebar,
            backspace = R.raw.v2_backspace,
            hold = R.raw.v2_hold,
            modifier = R.raw.v2_modifier,
            swipeHorizontal = R.raw.v2_swipe_h
        ), 
        1f
    ),
    vibrationMode = VibrationMode.Haptic(true)
)

FeedbackConfiguration(
    soundMode = SoundMode.Silent
)

SoundMode.Resources(
    soundSet = ResourceSoundSet(
        tap = R.raw.v2_tap,
        spacebar = R.raw.v2_spacebar,
        backspace = R.raw.v2_backspace,
        hold = R.raw.v2_hold,
        modifier = R.raw.v2_modifier,
        swipeHorizontal = R.raw.v2_swipe_h
    ), 
    volume = 0.5f
)

VibrationMode.Haptic(fallbackVibration = true)

VibrationMode.Duration(duration = 8L)

data class CustomizationBundleConfiguration {
        /**
         * The name of the bundle file that needs to be used for the keyboard layout customization.
         * Do not include the ".bundle" extension in the `bundleFileName` parameter.
         * Defaults to "fleksy-custom".
         *
         * Passing an empty string or a name for a bundle file that does not exist has no layout
         * customization effect.
         */
        val bundleFileName: String = "fleksy-custom",

        /**
         * The array of custom `Button`s to define the look and behavior of the custom buttons
         * declared in the bundle file.
         *
         * If two buttons in the array have the same label (case insensitive) then only the first
         * one in the array will be considered.
         */
        val buttons: List<Button> = listOf()
}

// Custom Action Button
class Button {
    /**
     * The case-insensitive label of the custom button. This string must match (case insensitively)
     * the `label` of the custom button defined in `keyboard-global.json` file.
     */
    val label: String,

    /**
     * The image to be shown in the custom button. If the image is null, then the label
     * will be shown and it will be shown in uppercase or lowercase depending of the state of
     * the shift button.
     */
    val image: Int?,

    /**
     * How the image fits in the button. @see ScaleMode
     */
    val scaleMode: ScaleMode = ScaleMode.CENTER_INSIDE,

    /**
     * The action to perform when the user taps the custom button, containing the label of the
     * tapped button.
     *
     * @return the case-insensitive label of the tapped button. When comparing this parameter,
     * note that the case of the label will match the keyboard's state.
     */
    val action: (String) -> Unit
) {

    /**
     * Defines how an image will fit in the custom action button.
     */
    @Keep
    enum class ScaleMode {
        /**
         * Scale the image uniformly (maintain the image's aspect ratio) so that both dimensions
         * (width and height) of the image will be equal to or larger than the corresponding
         * dimension of the button.
         */
        CENTER_CROP,

        /**
         * Scale the image uniformly (maintain the image's aspect ratio) so that both dimensions
         * (width and height) of the image will be equal to or less than the corresponding
         * dimension of the button..
         */
        CENTER_INSIDE
    }
}