Jetpack Compose 中实现长按拖拽排序

请在现有 Android Jetpack Compose 列表页面中实现“长按拖拽排序”能力，要求尽量复用当前页面、ViewModel 和保存接口，不引入不必要的新库。

交互要求：
1. 用户长按列表行后进入拖动状态，整行跟随手指移动。
2. 长按生效时需要有明确反馈，例如背景高亮、轻微缩放、透明度变化或触觉反馈。
3. 拖动过程中展示一条高亮插入线，表示松手后条目会插入的位置。
4. 拖动过程中，被拖动条目跨过的其他行要动态让位。例如向下拖时，中间行上移；向上拖时，中间行下移。
5. 普通行间分隔线需要跟随对应行一起移动，插入线替换对应位置的分隔线，不要出现分隔线丢失或覆盖文字。
6. 松手后再真正修改数据顺序，不要在拖动过程中反复重排真实列表。
7. 当列表超过一屏时，拖动到列表顶部或底部附近需要自动滚动，让用户可以跨屏幕拖动条目。
8. 被挤压行移动时，行内容、行间分隔线、行间空白要作为一个完整视觉单元移动，不要把外边距或分隔线残留在原地。
9. 最终顺序应能通过现有保存流程持久化。

实现约束：
1. 使用 detectDragGesturesAfterLongPress 监听长按拖动。
2. 使用稳定 key 保持行身份，避免滚动或重排后移动到错误条目。
3. pointerInput 尽量保持稳定；如果回调依赖最新 index 或状态，用 rememberUpdatedState 转接最新回调。
4. 拖动开始时记录起始 index、起始手指 Y 坐标，并冻结一份当前可见行的真实屏幕坐标，拖动过程中用冻结坐标计算插入位置，避免视觉位移反过来影响命中判断导致抖动。
5. 插入位置使用 insertionIndex 表示，范围为 0..items.size；松手时把 fromIndex 转换成实际 targetIndex。
6. 用 onGloballyPositioned / positionInWindow 记录每一行 top、bottom，用 onSizeChanged 或兜底 dp 值记录行高。
7. 对被挤压的行使用 graphicsLayer.translationY 做视觉位移，不在拖动中修改真实列表顺序。
8. 行位移步长不要只用行内容高度，优先用相邻两行 top 坐标差，确保步长包含行间分隔线和行间空白。
9. LazyColumn 使用 rememberLazyListState，并记录列表 viewport 的 top、bottom；拖动时如果手指靠近 viewport 顶部或底部，使用 scrollBy 持续自动滚动。
10. 自动滚动会改变内容相对屏幕的位置，需要维护 dragScrollOffset：被拖动行的 translationY 要补上滚动消耗，命中插入位置时则用 fingerY = dragStartFingerY + dragOffset - dragScrollOffset，并让冻结坐标按 scrollOffset 修正。
11. 完成后运行 Kotlin/Gradle 编译检查，并说明验证结果。

请先阅读现有代码结构，再按项目已有风格实现。保持改动聚焦，避免重构无关逻辑。

var draggingCode by remember { mutableStateOf<String?>(null) }
var dragStartIndex by remember { mutableIntStateOf(-1) }
var dragInsertionIndex by remember { mutableIntStateOf(-1) }
var dragStartFingerY by remember { mutableFloatStateOf(0f) }
var dragOffset by remember { mutableFloatStateOf(0f) }
var dragScrollOffset by remember { mutableFloatStateOf(0f) }
val rowBounds = remember { mutableMapOf<String, StockManagerRowBounds>() }
var dragRowBounds by remember { mutableStateOf<Map<String, StockManagerRowBounds>>(emptyMap()) }

pointerInput(code) {
    detectDragGesturesAfterLongPress(
        onDragStart = { offset -> currentOnDragStart(offset.y) },
        onDragEnd = { currentOnDragEnd() },
        onDragCancel = { currentOnDragEnd() },
        onDrag = { change, dragAmount ->
            change.consume()
            currentOnDragMove(dragAmount.y)
        },
    )
}

onGloballyPositioned { coordinates ->
    val top = coordinates.positionInWindow().y
    onPositioned(top, top + coordinates.size.height)
}

val boundsSnapshot = rowBounds.toMap()
dragRowBounds = boundsSnapshot

dragOffset += deltaY
val fingerY = dragStartFingerY + dragOffset - dragScrollOffset
dragInsertionIndex = resolveStockManagerDragInsertionIndex(
    fingerY = fingerY,
    entries = uiState.entries,
    rowBounds = dragRowBounds.ifEmpty { rowBounds },
    scrollOffset = dragScrollOffset,
) ?: fallback

if (fingerY <= bounds.bottom) {
    val center = (bounds.top + bounds.bottom) / 2f
    return if (fingerY < center) bounds.index else bounds.index + 1
}

val listState = rememberLazyListState()
var listViewportTop by remember { mutableFloatStateOf(0f) }
var listViewportBottom by remember { mutableFloatStateOf(0f) }

LazyColumn(
    state = listState,
    modifier = Modifier
        .fillMaxSize()
        .onGloballyPositioned { coordinates ->
            val top = coordinates.positionInWindow().y
            listViewportTop = top
            listViewportBottom = top + coordinates.size.height
        },
) {
    // ...
}

LaunchedEffect(draggingCode) {
    while (draggingCode != null) {
        val fingerY = dragStartFingerY + dragOffset - dragScrollOffset
        val scrollDelta = stockManagerAutoScrollDelta(
            fingerY = fingerY,
            viewportTop = listViewportTop,
            viewportBottom = listViewportBottom,
            edgeThresholdPx = autoScrollEdgePx,
            maxScrollStepPx = autoScrollStepPx,
        )
        if (scrollDelta != 0f) {
            val consumed = listState.scrollBy(scrollDelta)
            if (consumed != 0f) {
                dragOffset += consumed
                dragScrollOffset += consumed
                // 继续用新的手指位置刷新插入线
            }
        }
        withFrameNanos { }
    }
}

val fingerY = dragStartFingerY + dragOffset - dragScrollOffset

val visibleBounds = entries.mapNotNull { entry -> rowBounds[entry.code] }
    .map { bounds ->
        bounds.copy(
            top = bounds.top - scrollOffset,
            bottom = bounds.bottom - scrollOffset,
        )
    }

return when {
    dragInsertionIndex > dragStartIndex &&
        index > dragStartIndex &&
        index < dragInsertionIndex -> -rowDragStepPx

    dragInsertionIndex < dragStartIndex &&
        index >= dragInsertionIndex &&
        index < dragStartIndex -> rowDragStepPx

    else -> 0f
}

translationY = if (isDragging) dragOffset else rowDisplacement

private fun stockManagerRowStepPx(
    index: Int,
    entries: List<StockEntry>,
    rowBounds: Map<String, StockManagerRowBounds>,
    fallback: Float,
): Float {
    val current = entries.getOrNull(index)?.let { rowBounds[it.code] } ?: return fallback
    val next = entries.getOrNull(index + 1)?.let { rowBounds[it.code] }
    if (next != null) {
        return (next.top - current.top).takeIf { it > 0f } ?: fallback
    }

    val previous = entries.getOrNull(index - 1)?.let { rowBounds[it.code] }
    if (previous != null) {
        return (current.top - previous.top).takeIf { it > 0f } ?: fallback
    }

    return (current.bottom - current.top).takeIf { it > 0f } ?: fallback
}

@Composable
private fun StockManagerDropIndicator(
    modifier: Modifier = Modifier,
) {
    Box(
        modifier = modifier
            .fillMaxWidth()
            .height(7.dp),
        contentAlignment = Alignment.Center,
    ) {
        Box(
            modifier = Modifier
                .fillMaxWidth()
                .height(2.dp)
                .background(
                    color = MaterialTheme.colorScheme.primary,
                    shape = RoundedCornerShape(999.dp),
                ),
        )
    }
}

HorizontalDivider(
    modifier = Modifier.graphicsLayer {
        translationY = rowDisplacement
    },
    color = Border.copy(alpha = 0.7f),
)

viewModel.moveEntryToInsertionIndex(dragStartIndex, dragInsertionIndex)

val targetIndex = if (boundedInsertionIndex > fromIndex) {
    boundedInsertionIndex - 1
} else {
    boundedInsertionIndex
}

val next = state.entries.toMutableList()
val item = next.removeAt(fromIndex)
next.add(targetIndex.coerceIn(0, next.size), item)