val entered = "7345678"
val price = "7 345 678"

fun originalToTransformed(offset: Int): Int {

    val ensureOffset = minOf(offset, entered.length)
    val entered = entered.subSequence(0, minOf(ensureOffset + 1, entered.length))
    var spacesCount = 0
    for (i in entered.indices) {
        if (entered[i] != price[i + spacesCount] && price.getOrNull(i + spacesCount + 1) != null) {
            spacesCount++
        }
    }
    return ensureOffset + spacesCount
}

fun transformedToOriginal(offset: Int): Int {
    val ensureOffset = minOf(price.length, offset)
    return offset - price.subSequence(0, ensureOffset + 1).trim()
        .sumOf { if (it == ' ') 1L else 0L }.toInt()
}

class AmountTransformation(private val integersCount: Int) : VisualTransformation, OffsetMapping {

    private lateinit var input: AmountInput

    override fun filter(text: AnnotatedString): TransformedText {
        input = AmountInput.from(text.toString(), integersCount)
        return TransformedText(AnnotatedString(input.format(beautify = true)), this)
    }

    override fun originalToTransformed(offset: Int): Int {
        return input.originalToTransformed(offset)
    }

    override fun transformedToOriginal(offset: Int): Int {
        return input.transformedToOriginal(offset)
    }
}

@OptIn(ExperimentalAnimationApi::class)
@Composable
internal fun EnterAmountTextField(
    priceIntegersCount: Int,
    amount: Amount,
    onValueChange: (Amount) -> Unit
) {
    val transformation by remember { mutableStateOf(AmountTransformation(integersCount = priceIntegersCount)) }
    var enteredCount by remember { mutableStateOf(0) }
    var hasComma by remember { mutableStateOf(false) }

    Column(modifier = Modifier.fillMaxWidth(), horizontalAlignment = Alignment.CenterHorizontally) {
        Row(
            modifier = Modifier.wrapContentWidth(),
            verticalAlignment = Alignment.CenterVertically,
            horizontalArrangement = Arrangement.spacedBy(8.dp)
        ) {
            BasicTextField(
                AmountInput.from(amount, priceIntegersCount, hasComma, enteredCount).format(),
                onValueChange = { newValue ->
                    val input = AmountInput.from(newValue, priceIntegersCount)
                    hasComma = input.hasComma
                    enteredCount = input.pennies.enteredCount
                    onValueChange(input.amount)
                },
                singleLine = true,
                modifier = Modifier.width(IntrinsicSize.Min),
                textStyle = Typography.heading0.copy(fontWeight = FontWeight.Normal),
                cursorBrush = SolidColor(Palette.Primary.Purple),
                keyboardOptions = KeyboardOptions.Default.copy(keyboardType = KeyboardType.Number),
                visualTransformation = transformation
            )
            Text(
                stringResource(R.string.currency),
                style = Typography.heading0.copy(fontWeight = FontWeight.Normal, color = Palette.Transparent.o25)
            )
        }

        AnimatedVisibility(PaymentRuleTypes.isAmountInvalid(amount)) {
            Text(amount.errorText(), style = Typography.descriptionRegular.copy(color = Palette.System.Error))
        }
    }
}

data class Amount(val value: Int) {

    constructor(
        rubles: Int = 0,
        pennies: Int = 0
    ) : this((rubles + pennies / kopeckInRuble) * kopeckInRuble + pennies % kopeckInRuble)

    val rubles: Int
        get() = value / kopeckInRuble

    val pennies: Int
        get() = value.absoluteValue % kopeckInRuble

    fun formatPrice(showCurrencySign: Boolean = false): String =
        "${formatPrice()}${if (showCurrencySign) " ₽" else "" }"

    fun formatPrice(): String = buildString {
        val integer = "$rubles".replace(NON_DIGIT_REGEX, DASH)
        mutableListOf<CharSequence>().apply {
            for (i in integer.length downTo 1 step DIGIT_GROUP_LENGTH) {
                add(integer.subSequence(maxOf(i - DIGIT_GROUP_LENGTH, 0), i))
            }
        }.reversed().apply {
            forEachIndexed { index, charSequence ->
                append(charSequence)
                if (index != lastIndex && charSequence != DASH) append(' ')
            }
        }
        if (pennies > 0) append(",$pennies")
    }

    operator fun plus(amount: Amount): Amount = Amount(value + amount.value)

    operator fun minus(amount: Amount): Amount = Amount(value - amount.value)

    operator fun times(times: Int): Amount = Amount(value * times)

    operator fun compareTo(amount: Amount): Int = value.compareTo(amount.value)

    operator fun compareTo(amount: Int): Int = value.compareTo(amount)

    fun positive(): Boolean = value > 0

    fun negative(): Boolean = value < 0

    companion object {

        private const val kopeckInRuble = 100

        private const val DIGIT_GROUP_LENGTH = 3

        private const val DASH = "−"

        private val NON_DIGIT_REGEX by lazy { Regex("\\D") }

        val DEFAULT = Amount(-1)
        val EMPTY = Amount(0)
    }
}