package com.lemenzo.calculator

import android.app.Activity
import android.app.AlertDialog
import android.content.ClipData
import android.content.ClipDescription
import android.content.ClipboardManager
import android.os.Bundle
import android.os.PersistableBundle
import android.text.Editable
import android.text.InputFilter
import android.text.TextWatcher
import android.view.HapticFeedbackConstants
import android.view.View
import android.view.WindowInsets
import android.widget.*
import com.lemenzo.calculator.engine.ConversionEngine
import com.lemenzo.calculator.engine.DisplayFormatter
import com.lemenzo.calculator.engine.ExpressionEngine
import com.lemenzo.calculator.engine.ExpressionCodec
import com.lemenzo.calculator.engine.ProgrammerEngine
import com.lemenzo.calculator.engine.NumberInputParser
import com.lemenzo.calculator.model.HistoryStore
import java.math.BigDecimal
import java.math.BigInteger
import java.text.DecimalFormatSymbols
import java.util.Locale

class CalculatorActivity : Activity() {
    private lateinit var expressionView: EditText
    private lateinit var resultView: TextView
    private lateinit var keypad: GridLayout
    private lateinit var converterPanel: LinearLayout
    private lateinit var calculatorDisplayPanel: LinearLayout
    private lateinit var modeLabel: TextView
    private lateinit var history: HistoryStore
    private lateinit var programmerBases: TextView
    private lateinit var conversionCategory: Spinner
    private lateinit var conversionFrom: Spinner
    private lateinit var conversionTo: Spinner
    private lateinit var conversionInput: EditText

    private val engine = ExpressionEngine()
    private val programmer = ProgrammerEngine()
    private var expression = ""
    private var calculatorExpression = ""
    private var programmerExpression = ""
    private var calculatorLastValue: BigDecimal? = null
    private var memory = BigDecimal.ZERO
    private var lastValue: BigDecimal? = null
    private var mode = Mode.BASIC
    private var scientificSecondary = false
    private var notation = DisplayFormatter.Notation.AUTO
    private var syncingExpression = false

    private val localeSymbols by lazy { DecimalFormatSymbols.getInstance(Locale.getDefault()) }
    private val decimalSeparator: Char get() = localeSymbols.decimalSeparator
    private val groupingSeparator: Char get() = localeSymbols.groupingSeparator

    enum class Mode { BASIC, SCIENTIFIC, CONVERTER, PROGRAMMER }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_calculator)

        findViewById<View>(R.id.root).setOnApplyWindowInsetsListener { v, insets ->
            val bars = insets.getInsets(WindowInsets.Type.systemBars() or WindowInsets.Type.displayCutout())
            v.setPadding(0, bars.top, 0, bars.bottom)
            insets
        }

        expressionView = findViewById(R.id.expression)
        expressionView.showSoftInputOnFocus = false
        resultView = findViewById(R.id.result)
        keypad = findViewById(R.id.keypad)
        converterPanel = findViewById(R.id.converterPanel)
        calculatorDisplayPanel = findViewById(R.id.calculatorDisplayPanel)
        modeLabel = findViewById(R.id.modeLabel)
        history = HistoryStore(this)
        programmerBases = findViewById(R.id.programmerBases)

        expressionView.filters = arrayOf(InputFilter.LengthFilter(512))
        expressionView.addTextChangedListener(object : TextWatcher {
            override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) = Unit
            override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {
                if (syncingExpression) return
                expression = canonicalizeDisplayExpression(s?.toString().orEmpty())
                if (mode == Mode.PROGRAMMER) calculateProgrammer(false) else calculateLive()
            }
            override fun afterTextChanged(s: Editable?) = Unit
        })

        findViewById<View>(R.id.modeBasic).setOnClickListener { setMode(Mode.BASIC) }
        findViewById<View>(R.id.modeScientific).setOnClickListener { setMode(Mode.SCIENTIFIC) }
        findViewById<View>(R.id.modeConverter).setOnClickListener { setMode(Mode.CONVERTER) }
        findViewById<View>(R.id.modeProgrammer).setOnClickListener { setMode(Mode.PROGRAMMER) }
        findViewById<View>(R.id.historyButton).setOnClickListener { showHistory() }

        resultView.setOnLongClickListener {
            val clipboard = getSystemService(ClipboardManager::class.java)
            val copy = if (mode == Mode.PROGRAMMER) resultView.text.toString() else lastValue?.let(engine::format) ?: resultView.text.toString()
            val clip = ClipData.newPlainText(getString(R.string.clipboard_result_label), copy)
            clip.description.extras = PersistableBundle().apply {
                putBoolean(ClipDescription.EXTRA_IS_SENSITIVE, true)
            }
            clipboard.setPrimaryClip(clip)
            Toast.makeText(this, R.string.result_copied, Toast.LENGTH_SHORT).show()
            true
        }

        setupConverter()

        if (savedInstanceState != null) {
            expression = savedInstanceState.getString("expression", "")
            calculatorExpression = savedInstanceState.getString("calculatorExpression", expression)
            programmerExpression = savedInstanceState.getString("programmerExpression", "")
            memory = savedInstanceState.getString("memory", "0")!!.toBigDecimalOrNull() ?: BigDecimal.ZERO
            lastValue = savedInstanceState.getString("lastValue")?.toBigDecimalOrNull()
            mode = runCatching { Mode.valueOf(savedInstanceState.getString("mode", Mode.BASIC.name)!!) }.getOrDefault(Mode.BASIC)
            engine.angleMode = runCatching { ExpressionEngine.AngleMode.valueOf(savedInstanceState.getString("angle", "DEG")!!) }.getOrDefault(ExpressionEngine.AngleMode.DEG)
            programmer.base = runCatching { ProgrammerEngine.Base.valueOf(savedInstanceState.getString("base", "DEC")!!) }.getOrDefault(ProgrammerEngine.Base.DEC)
            programmer.wordSize = runCatching { ProgrammerEngine.WordSize.valueOf(savedInstanceState.getString("word", "B64")!!) }.getOrDefault(ProgrammerEngine.WordSize.B64)
            scientificSecondary = savedInstanceState.getBoolean("scientificSecondary", false)
            notation = runCatching { DisplayFormatter.Notation.valueOf(savedInstanceState.getString("notation", "AUTO")!!) }.getOrDefault(DisplayFormatter.Notation.AUTO)
        }

        setMode(mode, preserveExpression = true)
        syncExpressionView()
        if (mode == Mode.PROGRAMMER) calculateProgrammer(false) else calculateLive()
        savedInstanceState?.let { restoreConverterState(it) }
    }

    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        outState.putString("expression", expression)
        outState.putString("calculatorExpression", calculatorExpression)
        outState.putString("programmerExpression", programmerExpression)
        outState.putString("memory", memory.toPlainString())
        outState.putString("lastValue", lastValue?.toPlainString())
        outState.putString("mode", mode.name)
        outState.putString("angle", engine.angleMode.name)
        outState.putString("base", programmer.base.name)
        outState.putString("word", programmer.wordSize.name)
        outState.putBoolean("scientificSecondary", scientificSecondary)
        outState.putString("notation", notation.name)
        if (::conversionCategory.isInitialized) {
            outState.putInt("converterCategory", conversionCategory.selectedItemPosition)
            outState.putInt("converterFrom", conversionFrom.selectedItemPosition)
            outState.putInt("converterTo", conversionTo.selectedItemPosition)
            outState.putString("converterInput", conversionInput.text?.toString().orEmpty())
        }
    }

    private fun setMode(newMode: Mode, preserveExpression: Boolean = false) {
        val oldMode = mode
        if (!preserveExpression && newMode != oldMode) {
            when (oldMode) {
                Mode.BASIC, Mode.SCIENTIFIC -> { calculatorExpression = expression; calculatorLastValue = lastValue }
                Mode.PROGRAMMER -> programmerExpression = expression
                Mode.CONVERTER -> Unit
            }
        }
        mode = newMode
        if (!preserveExpression && newMode != oldMode) {
            when (newMode) {
                Mode.BASIC, Mode.SCIENTIFIC -> { expression = calculatorExpression; lastValue = calculatorLastValue }
                Mode.PROGRAMMER -> { expression = programmerExpression; lastValue = null }
                Mode.CONVERTER -> Unit
            }
        }
        converterPanel.visibility = if (mode == Mode.CONVERTER) View.VISIBLE else View.GONE
        calculatorDisplayPanel.visibility = if (mode == Mode.CONVERTER) View.GONE else View.VISIBLE
        keypad.visibility = if (mode == Mode.CONVERTER) View.GONE else View.VISIBLE
        programmerBases.visibility = if (mode == Mode.PROGRAMMER) View.VISIBLE else View.GONE
        updateModeButtons(); buildKeys(); updateModeLabel(); syncExpressionView()
        when (mode) { Mode.BASIC, Mode.SCIENTIFIC -> if (expression.isNotBlank()) calculateLive(); Mode.PROGRAMMER -> if (expression.isNotBlank()) calculateProgrammer(false); Mode.CONVERTER -> Unit }
    }

    private fun updateModeButtons() {
        val mapping = mapOf(
            R.id.modeBasic to Mode.BASIC,
            R.id.modeScientific to Mode.SCIENTIFIC,
            R.id.modeConverter to Mode.CONVERTER,
            R.id.modeProgrammer to Mode.PROGRAMMER
        )
        mapping.forEach { (id, m) ->
            val selected = m == mode
            val button = findViewById<Button>(id)
            button.setBackgroundResource(if (selected) R.drawable.mode_selected else R.drawable.mode_unselected)
            button.setTextColor(getColor(if (selected) R.color.lemenzo_text else R.color.lemenzo_silver))
            button.isSelected = selected
        }
    }

    private fun updateModeLabel() {
        modeLabel.text = when (mode) {
            Mode.BASIC -> getString(R.string.mode_label_basic)
            Mode.SCIENTIFIC -> getString(R.string.mode_label_scientific, engine.angleMode.name, notation.name)
            Mode.CONVERTER -> getString(R.string.mode_label_converter)
            Mode.PROGRAMMER -> getString(R.string.mode_label_programmer, programmer.base.name, programmer.wordSize.bits)
        }
    }

    private fun buildKeys() {
        keypad.removeAllViews()
        val keys = when (mode) {
            Mode.SCIENTIFIC -> scientificKeys()
            Mode.PROGRAMMER -> listOf(
                "HEX", "DEC", "OCT", "BIN",
                "${programmer.wordSize.bits}-bit", "NOT", "(", ")",
                "A", "B", "C", "D",
                "E", "F", "⌫", "AC",
                "7", "8", "9", "AND",
                "4", "5", "6", "OR",
                "1", "2", "3", "XOR",
                "0", "<<", ">>", "÷",
                "%", "×", "+", "−",
                "="
            )
            else -> listOf(
                "MC", "MR", "M+", "M−",
                "(", ")", "%", "⌫",
                "7", "8", "9", "÷",
                "4", "5", "6", "×",
                "1", "2", "3", "−",
                "±", "0", decimalSeparator.toString(), "+",
                "C", "00", "π", "="
            )
        }
        keys.forEach { addKey(it) }
    }

    private fun scientificKeys(): List<String> {
        val header = listOf(engine.angleMode.name, "2nd", notationLabel(), if (scientificSecondary) "MS" else "MR")
        val functions = if (!scientificSecondary) {
            listOf(
                "sin", "cos", "tan", "π",
                "ln", "log", "√", "e",
                "x²", "xʸ", "1/x", "φ",
                "nCr", "nPr", "!", "abs"
            )
        } else {
            listOf(
                "asin", "acos", "atan", "π",
                "sinh", "cosh", "tanh", "e",
                "exp", "log₂", "∛", "φ",
                "floor", "ceil", "!", "abs"
            )
        }
        return header + functions + listOf(
            "(", ")", "%", "⌫",
            "7", "8", "9", "÷",
            "4", "5", "6", "×",
            "1", "2", "3", "−",
            "±", "0", decimalSeparator.toString(), "+",
            "C", "M+", "M−", "="
        )
    }

    private fun notationLabel() = when (notation) {
        DisplayFormatter.Notation.AUTO -> "AUTO"
        DisplayFormatter.Notation.SCIENTIFIC -> "SCI"
        DisplayFormatter.Notation.ENGINEERING -> "ENG"
    }

    private fun addKey(label: String) {
    val button = Button(this).apply {
        text = label
        textSize = if (mode == Mode.SCIENTIFIC && label.length > 4) 15f else 17f
        isAllCaps = false
        setTextColor(getColor(R.color.lemenzo_text))
        minimumWidth = 0
        minimumHeight = 0
        contentDescription = keyDescription(label)
        stateListAnimator = null

        setBackgroundResource(
            when {
                label == "=" -> R.drawable.key_equals
                label in listOf("+", "−", "×", "÷", "AND", "OR", "XOR", "NOT", "xʸ", "<<", ">>") ->
                    R.drawable.key_operator
                label == "2nd" && scientificSecondary ->
                    R.drawable.mode_selected
                label in listOf("AUTO", "SCI", "ENG", "DEG", "RAD", "GRAD") ->
                    R.drawable.mode_selected
                else ->
                    R.drawable.key_number
            }
        )

        if (mode == Mode.PROGRAMMER && label.length == 1 && label[0] in '0'..'9') {
            val digit = label[0].digitToInt()
            isEnabled = digit < programmer.base.radix
            alpha = if (isEnabled) 1f else 0.30f
        }

        if (mode == Mode.PROGRAMMER && label in listOf("A", "B", "C", "D", "E", "F")) {
            isEnabled = programmer.base == ProgrammerEngine.Base.HEX
            alpha = if (isEnabled) 1f else 0.30f
        }

        if (mode == Mode.PROGRAMMER && label in listOf("HEX", "DEC", "OCT", "BIN")) {
            setBackgroundResource(
                if (label == programmer.base.name) {
                    R.drawable.mode_selected
                } else {
                    R.drawable.key_number
                }
            )
        }

        if (mode == Mode.PROGRAMMER && label.endsWith("-bit")) {
            setBackgroundResource(R.drawable.mode_selected)
        }

        setOnClickListener {
            performHapticFeedback(HapticFeedbackConstants.KEYBOARD_TAP)
            press(label)
        }
    }

    val lp = GridLayout.LayoutParams().apply {
        width = 0
        height = (if (mode == Mode.SCIENTIFIC) 56 else 62).dp
            columnSpec = if (mode == Mode.PROGRAMMER && label == "=") GridLayout.spec(GridLayout.UNDEFINED, 4, 1f) else GridLayout.spec(GridLayout.UNDEFINED, 1f)
            setMargins(4.dp, 4.dp, 4.dp, 4.dp)
        }
        button.layoutParams = lp
        keypad.addView(button)
    }

    private fun keyDescription(label: String): String = when (label) {
        "⌫" -> getString(R.string.key_backspace)
        "÷" -> getString(R.string.key_divide)
        "×" -> getString(R.string.key_multiply)
        "−" -> getString(R.string.key_subtract)
        "+" -> getString(R.string.key_add)
        "=" -> getString(R.string.key_equals)
        "%" -> getString(R.string.key_percent)
        "±" -> getString(R.string.key_toggle_sign)
        "π" -> getString(R.string.key_pi)
        "φ" -> getString(R.string.key_phi)
        "√" -> getString(R.string.key_square_root)
        "∛" -> getString(R.string.key_cube_root)
        "2nd" -> getString(R.string.key_secondary)
        "SCI" -> getString(R.string.key_scientific_notation)
        "ENG" -> getString(R.string.key_engineering_notation)
        "AUTO" -> getString(R.string.key_auto_format)
        else -> label
    }

    private fun press(key: String) {
        if (mode == Mode.PROGRAMMER) {
            pressProgrammer(key)
            return
        }
        when (key) {
            "C" -> { expression = ""; lastValue = null; resultView.text = "0" }
            "⌫" -> deleteAtCursor()
            "=" -> calculate(true)
            "π" -> insertText("pi")
            "e" -> insertText("e")
            "φ" -> insertText("phi")
            "±" -> toggleSignAtCursor()
            "MC" -> memory = BigDecimal.ZERO
            "MR" -> insertText(engine.format(memory))
            "MS" -> lastValue?.let { memory = it }
            "M+" -> { calculateLive(); lastValue?.let { memory = memory.add(it) } }
            "M−" -> { calculateLive(); lastValue?.let { memory = memory.subtract(it) } }
            "DEG", "RAD", "GRAD" -> cycleAngleMode()
            "2nd" -> { scientificSecondary = !scientificSecondary; buildKeys() }
            "AUTO", "SCI", "ENG" -> cycleNotation()
            "sin", "cos", "tan", "asin", "acos", "atan", "sinh", "cosh", "tanh", "ln", "log", "exp", "abs", "floor", "ceil" -> insertText("$key(")
            "log₂" -> insertText("log2(")
            "√" -> insertText("sqrt(")
            "∛" -> insertText("cbrt(")
            "nCr" -> beginCombinatoric("nCr")
            "nPr" -> beginCombinatoric("nPr")
            "x²" -> insertText("^2")
            "xʸ" -> insertText("^")
            "1/x" -> wrapReciprocal()
            decimalSeparator.toString() -> insertText(".")
            else -> insertText(key)
        }
        syncExpressionView()
        if (key != "=") calculateLive()
    }

    private fun cycleAngleMode() {
        engine.angleMode = when (engine.angleMode) {
            ExpressionEngine.AngleMode.DEG -> ExpressionEngine.AngleMode.RAD
            ExpressionEngine.AngleMode.RAD -> ExpressionEngine.AngleMode.GRAD
            ExpressionEngine.AngleMode.GRAD -> ExpressionEngine.AngleMode.DEG
        }
        buildKeys()
        updateModeLabel()
    }

    private fun cycleNotation() {
        notation = when (notation) {
            DisplayFormatter.Notation.AUTO -> DisplayFormatter.Notation.SCIENTIFIC
            DisplayFormatter.Notation.SCIENTIFIC -> DisplayFormatter.Notation.ENGINEERING
            DisplayFormatter.Notation.ENGINEERING -> DisplayFormatter.Notation.AUTO
        }
        buildKeys()
        updateModeLabel()
        lastValue?.let { showResult(it) }
    }

    private fun wrapReciprocal() {
        expression = if (expression.isBlank()) "1/(" else "1/($expression)"
        syncExpressionView()
    }

    private fun beginCombinatoric(name: String) {
        expression = if (expression.isBlank()) "$name(" else "$name($expression,"
        syncExpressionView()
    }

    private fun pressProgrammer(key: String) {
        when (key) {
            "HEX", "DEC", "OCT", "BIN" -> {
                val current = runCatching { if (expression.isBlank()) BigInteger.ZERO else programmer.evaluate(expression) }.getOrDefault(BigInteger.ZERO)
                programmer.base = ProgrammerEngine.Base.valueOf(key)
                expression = programmer.format(current)
                buildKeys(); updateModeLabel()
            }
            "8-bit", "16-bit", "32-bit", "64-bit" -> {
                programmer.wordSize = when (programmer.wordSize) {
                    ProgrammerEngine.WordSize.B8 -> ProgrammerEngine.WordSize.B16
                    ProgrammerEngine.WordSize.B16 -> ProgrammerEngine.WordSize.B32
                    ProgrammerEngine.WordSize.B32 -> ProgrammerEngine.WordSize.B64
                    ProgrammerEngine.WordSize.B64 -> ProgrammerEngine.WordSize.B8
                }
                buildKeys(); updateModeLabel()
            }
            "AC" -> { expression = ""; resultView.text = "0"; programmerBases.text = "" }
            "⌫" -> deleteAtCursor()
            "=" -> calculateProgrammer(true)
            "×" -> insertText("*")
            "÷" -> insertText("/")
            "−" -> insertText("-")
            "AND", "OR", "XOR" -> insertText(" $key ")
            "NOT" -> insertText("NOT ")
            else -> insertText(key)
        }
        syncExpressionView()
        if (key != "=") calculateProgrammer(false)
    }

    private fun calculateLive() = calculate(false)

    private fun calculate(commit: Boolean) {
        if (expression.isBlank()) return
        try {
            val value = engine.evaluate(expression)
            lastValue = value
            showResult(value)
            if (commit) {
                val canonical = engine.format(value)
                history.add(HistoryStore.Entry(expression, canonical, System.currentTimeMillis(), mode.name, engine.angleMode.name))
                expression = canonical
                syncExpressionView()
            }
        } catch (_: IllegalArgumentException) {
            if (commit) {
                lastValue = null
                resultView.text = getString(R.string.math_error)
            }
        } catch (_: ArithmeticException) {
            if (commit) {
                lastValue = null
                resultView.text = getString(R.string.math_error)
            }
        }
    }

    private fun showResult(value: BigDecimal) {
        val formatted = DisplayFormatter.format(value, notation, decimalSeparator, groupingSeparator, grouping = true)
        resultView.text = formatted
        resultView.contentDescription = "${getString(R.string.result_description)}: $formatted"
    }

    private fun calculateProgrammer(commit: Boolean) {
        if (expression.isBlank()) return
        try {
            val value = programmer.evaluate(expression)
            val formatted = programmer.format(value)
            resultView.text = formatted
            resultView.contentDescription = "${getString(R.string.result_description)}: $formatted"
            updateProgrammerBases(value)
            if (commit) {
                history.add(HistoryStore.Entry(expression, formatted, System.currentTimeMillis(), Mode.PROGRAMMER.name, programmerBase = programmer.base.name, wordSize = programmer.wordSize.bits))
                expression = formatted
                syncExpressionView()
            }
        } catch (_: IllegalArgumentException) {
            if (commit) resultView.text = getString(R.string.math_error)
        } catch (_: ArithmeticException) {
            if (commit) resultView.text = getString(R.string.math_error)
        }
    }

    private fun toggleSignAtCursor() {
        val rawStart = expressionView.selectionStart.coerceIn(0, expression.length)
        val rawEnd = expressionView.selectionEnd.coerceIn(0, expression.length)
        val selectionStart = minOf(rawStart, rawEnd)
        val selectionEnd = maxOf(rawStart, rawEnd)

        val start = if (selectionStart != selectionEnd) selectionStart else findOperandStart(selectionEnd)
        val end = selectionEnd
        if (start == end) {
            insertText("-")
            return
        }

        val segment = expression.substring(start, end)
        val replacement = when {
            segment.startsWith("-(") && segment.endsWith(")") -> segment.substring(2, segment.length - 1)
            segment.startsWith("-") && segment.drop(1).toBigDecimalOrNull() != null -> segment.drop(1)
            else -> "-($segment)"
        }
        expression = expression.substring(0, start) + replacement + expression.substring(end)
        syncExpressionView(start + replacement.length)
    }

    private fun findOperandStart(cursor: Int): Int {
        var depth = 0
        var i = cursor - 1
        while (i >= 0) {
            when (val c = expression[i]) {
                ')' -> depth++
                '(' -> if (depth > 0) depth-- else return i + 1
                '+', '*', '/', '^', ',' -> if (depth == 0) return i + 1
                '-' -> if (depth == 0) {
                    val unary = i == 0 || expression[i - 1] in charArrayOf('+', '-', '*', '/', '^', '(', ',')
                    if (!unary) return i + 1
                }
            }
            i--
        }
        return 0
    }

    private fun deleteAtCursor() {
        if (expression.isEmpty()) return
        val cursor = expressionView.selectionStart.coerceIn(0, expression.length)
        if (cursor == 0) return
        val before = expression.substring(0, cursor)
        val tokens = listOf("asin(", "acos(", "atan(", "sinh(", "cosh(", "tanh(", "cbrt(", "log2(", "sqrt(", "nCr(", "nPr(", "floor(", "ceil(", "sin(", "cos(", "tan(", "log(", "ln(", "exp(", "abs(", "phi", "pi", "AND ", "OR ", "XOR ", "NOT ")
        val token = tokens.firstOrNull { before.endsWith(it) }
        val remove = token?.length ?: 1
        expression = expression.removeRange(cursor - remove, cursor)
        syncExpressionView(cursor - remove)
    }

    private fun <T> lemenzoAdapter(items: List<T>): ArrayAdapter<T> =
        ArrayAdapter(this, R.layout.spinner_item, android.R.id.text1, items).also {
            it.setDropDownViewResource(R.layout.spinner_dropdown_item)
        }

    private fun setupConverter() {
        conversionCategory = findViewById(R.id.conversionCategory)
        conversionFrom = findViewById(R.id.fromUnit)
        conversionTo = findViewById(R.id.toUnit)
        conversionInput = findViewById(R.id.conversionInput)
        val category = conversionCategory
        val from = conversionFrom
        val to = conversionTo
        val input = conversionInput
        val output = findViewById<TextView>(R.id.conversionResult)
        val swap = findViewById<Button>(R.id.swapUnits)

        category.adapter = lemenzoAdapter(ConversionEngine.categories.keys.toList())

        fun refreshUnits() {
            val units = ConversionEngine.categories[category.selectedItem.toString()] ?: return
            val labels = units.map { "${it.name} (${it.symbol})" }
            from.adapter = lemenzoAdapter(labels)
            to.adapter = lemenzoAdapter(labels)
            if (units.size > 1) to.setSelection(1)
        }

        fun convert() {
            val value = parseLocalizedDecimal(input.text.toString()) ?: run {
                output.text = "0"
                output.contentDescription = "${getString(R.string.conversion_result_description)}: 0"
                return
            }
            val units = ConversionEngine.categories[category.selectedItem.toString()] ?: return
            if (from.selectedItemPosition !in units.indices || to.selectedItemPosition !in units.indices) return
            val converted = runCatching { ConversionEngine.convert(value, units[from.selectedItemPosition], units[to.selectedItemPosition]) }.getOrNull() ?: return
            val formatted = DisplayFormatter.format(converted, DisplayFormatter.Notation.AUTO, decimalSeparator, groupingSeparator, true)
            output.text = "$formatted ${units[to.selectedItemPosition].symbol}"
            output.contentDescription = "${getString(R.string.conversion_result_description)}: ${output.text}"
        }

        category.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
            override fun onNothingSelected(parent: AdapterView<*>?) = Unit
            override fun onItemSelected(parent: AdapterView<*>?, view: View?, position: Int, id: Long) { refreshUnits(); convert() }
        }
        val unitListener = object : AdapterView.OnItemSelectedListener {
            override fun onNothingSelected(parent: AdapterView<*>?) = Unit
            override fun onItemSelected(parent: AdapterView<*>?, view: View?, position: Int, id: Long) = convert()
        }
        from.onItemSelectedListener = unitListener
        to.onItemSelectedListener = unitListener
        input.addTextChangedListener(object : TextWatcher {
            override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) = Unit
            override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) = convert()
            override fun afterTextChanged(s: Editable?) = Unit
        })
        swap.setOnClickListener {
            val a = from.selectedItemPosition
            val b = to.selectedItemPosition
            from.setSelection(b)
            to.setSelection(a)
            swap.performHapticFeedback(HapticFeedbackConstants.KEYBOARD_TAP)
            convert()
        }
        refreshUnits()
    }

    private fun showHistory() {
        val items = history.all()
        val labels = if (items.isEmpty()) arrayOf(getString(R.string.no_calculations)) else items.map { "${localizeCanonical(it.expression)}\n= ${localizeCanonical(it.result)}" }.toTypedArray()
        AlertDialog.Builder(this)
            .setTitle(R.string.calculation_history)
            .setItems(labels) { _, which ->
                if (items.isNotEmpty()) restoreHistoryItem(items[which])
            }
            .setNegativeButton(R.string.clear_history) { _, _ -> confirmClearHistory() }
            .setPositiveButton(R.string.close, null)
            .show()
    }

    private fun restoreHistoryItem(item: HistoryStore.Entry) {
        if (item.mode == Mode.PROGRAMMER.name) {
            programmer.base = runCatching { ProgrammerEngine.Base.valueOf(item.programmerBase ?: ProgrammerEngine.Base.DEC.name) }.getOrDefault(ProgrammerEngine.Base.DEC)
            programmer.wordSize = when (item.wordSize ?: 64) { 8 -> ProgrammerEngine.WordSize.B8; 16 -> ProgrammerEngine.WordSize.B16; 32 -> ProgrammerEngine.WordSize.B32; else -> ProgrammerEngine.WordSize.B64 }
            programmerExpression = item.expression; expression = programmerExpression; mode = Mode.PROGRAMMER; setMode(Mode.PROGRAMMER, preserveExpression = true); calculateProgrammer(false)
        } else {
            engine.angleMode = runCatching { ExpressionEngine.AngleMode.valueOf(item.angleMode ?: ExpressionEngine.AngleMode.DEG.name) }.getOrDefault(ExpressionEngine.AngleMode.DEG)
            calculatorExpression = item.expression; expression = calculatorExpression; mode = if (item.mode == Mode.SCIENTIFIC.name) Mode.SCIENTIFIC else Mode.BASIC; setMode(mode, preserveExpression = true)
            runCatching { engine.evaluate(expression) }.getOrNull()?.let { calculatorLastValue = it; lastValue = it; showResult(it) }
        }
    }

    private fun confirmClearHistory() {
        AlertDialog.Builder(this)
            .setMessage(R.string.confirm_clear_history)
            .setNegativeButton(R.string.cancel, null)
            .setPositiveButton(R.string.clear_history) { _, _ -> history.clear() }
            .show()
    }

    private fun insertText(text: String) {
        val start = expressionView.selectionStart.coerceIn(0, expression.length)
        val end = expressionView.selectionEnd.coerceIn(0, expression.length)
        expression = expression.substring(0, minOf(start, end)) + text + expression.substring(maxOf(start, end))
        syncExpressionView((minOf(start, end) + text.length).coerceAtMost(expression.length))
    }

    private fun syncExpressionView(cursor: Int = expression.length) {
        val display = localizeCanonical(expression)
        syncingExpression = true
        if (expressionView.text.toString() != display) expressionView.setText(display)
        expressionView.setSelection(cursor.coerceIn(0, display.length))
        syncingExpression = false
    }

    private fun canonicalizeDisplayExpression(value: String): String =
        ExpressionCodec.toCanonical(value, decimalSeparator)

    private fun localizeCanonical(value: String): String =
        ExpressionCodec.toDisplay(value, decimalSeparator)


    private fun restoreConverterState(state: Bundle) {
        if (!::conversionCategory.isInitialized) return
        val categoryIndex = state.getInt("converterCategory", 0)
            .coerceIn(0, maxOf(0, ConversionEngine.categories.size - 1))
        conversionCategory.setSelection(categoryIndex)
        conversionCategory.post {
            val fromMax = maxOf(0, conversionFrom.count - 1)
            val toMax = maxOf(0, conversionTo.count - 1)
            conversionFrom.setSelection(state.getInt("converterFrom", 0).coerceIn(0, fromMax))
            conversionTo.setSelection(state.getInt("converterTo", 1).coerceIn(0, toMax))
            conversionInput.setText(state.getString("converterInput", ""))
        }
    }

    private fun parseLocalizedDecimal(raw: String): BigDecimal? =
        NumberInputParser.parse(raw, decimalSeparator, groupingSeparator)

    private fun updateProgrammerBases(value: BigInteger) {
        if (mode != Mode.PROGRAMMER) return
        val all = programmer.allBases(value)
        val bin = groupBinary(all[ProgrammerEngine.Base.BIN].orEmpty())
        programmerBases.text = buildString {
            append(getString(R.string.programmer_hex)).append("  ").append(all[ProgrammerEngine.Base.HEX]).append('\n')
            append(getString(R.string.programmer_dec)).append("  ").append(all[ProgrammerEngine.Base.DEC]).append('\n')
            append(getString(R.string.programmer_oct)).append("  ").append(all[ProgrammerEngine.Base.OCT]).append('\n')
            append(getString(R.string.programmer_bin)).append("  ").append(bin)
        }
    }

    private fun groupBinary(value: String): String {
        if (value.isEmpty()) return value
        val pad = (4 - value.length % 4) % 4
        val padded = "0".repeat(pad) + value
        return padded.chunked(4).joinToString(" ").trimStart('0', ' ').ifEmpty { "0" }
    }

    private val Int.dp: Int get() = (this * resources.displayMetrics.density).toInt()
}