// Talkback: "Click me!, Button, double tap to activate"
Button(onClick = { /* TODO */ }) { Text("Click me!") }
// Talkback: "Click me!, double tap to activate"
Box(Modifier.clickable { /* TODO */ }) { Text("Click me!") }

@Composable
private fun LogPointerEvents(filter: PointerEventType? = null) {
   var log by remember { mutableStateOf("") }
   Column {
      Text(log)
      Box(
         Modifier
            .size(100.dp)
            .background(Color.Red)
            .pointerInput(filter) {
               awaitPointerEventScope {
                  while (true) {
                     val event = awaitPointerEvent()
                     // handle pointer event
                     if (filter == null || event.type == filter) {
                        log = "${event.type}, ${event.changes.first().position}"
                     }
                  }
               }
            }
      )
   }
}

var log by remember { mutableStateOf("") }
Column {
   Text(log)
   Box(
      Modifier
         .size(100.dp)
         .background(Color.Red)
         .pointerInput(Unit) {
            detectTapGestures { log = "Tap!" }
            // 연결되지 않음
            detectDragGestures { _, _ -> log = "Dragging" }
         }
   )
}

var log by remember { mutableStateOf("") }
Column {
   Text(log)
   Box(
      Modifier
         .size(100.dp)
         .background(Color.Red)
         .pointerInput(Unit) {
            detectTapGestures { log = "Tap!" }
         }
         .pointerInput(Unit) {
            // 드래그 이벤트가 올바르게 트리거 됨
            detectDragGestures { _, _ -> log = "Dragging" }
         }
   )
}

@Composable
private fun SimpleClickable(onClick: () -> Unit) {
   Box(
      Modifier
         .size(100.dp)
         .pointerInput(onClick) {
            awaitEachGesture {
               awaitFirstDown().also { it.consume() }
               val up = waitForUpOrCancellation()
               if (up != null) {
                  up.consume()
                  onClick()
               }
            }
         }
   )
}

Modifier.pointerInput(Unit) {
   awaitEachGesture {
      while (true) {
         val event = awaitPointerEvent()
         if (event.changes.any { it.isConsumed }) {
            // 포인터가 다른 제스처 핸들러에 의해 소비
         } else {
            // 소비되지 않은 이벤트 처리
         }
      }
   }
}

composeTestRule.onNodeWithTag("MyList").performTouchInput {
   swipeUp()
   swipeDown()
   click()
}

@Composable
private fun ImageGrid(photos: List<Photo>) {
   var activePhotoId by rememberSaveable { mutableStateOf<Int?>(null) }
   LazyVerticalGrid(columns = GridCells.Adaptive(minSize = 128.dp)) {
      items(photos, { it.id }) { photo ->
         ImageItem(
            photo,
            Modifier.clickable { activePhotoId = photo.id }
         )
      }
   }
   if (activePhotoId != null) {
      FullScreenImage(
         photo = photos.first { it.id == activePhotoId },
         onDismiss = { activePhotoId = null }
      )
   }
}

var contextMenuPhotoId by rememberSaveable { mutableStateOf<Int?>(null) }
val haptics = LocalHapticFeedback.current
LazyVerticalGrid(columns = GridCells.Adaptive(minSize = 128.dp)) {
   items(photos, { it.id }) { photo ->
      ImageItem(
         photo,
         Modifier
            .combinedClickable(
               onClick = { activePhotoId = photo.id },
               onLongClick = {
                  haptics.performHapticFeedback(HapticFeedbackType.LongPress)
                  contextMenuPhotoId = photo.id
               },
               onLongClickLabel = stringResource(R.string.open_context_menu)
            )
      )
   }
}
if (contextMenuPhotoId != null) {
   PhotoActionsSheet(
      photo = photos.first { it.id == contextMenuPhotoId },
      onDismissSheet = { contextMenuPhotoId = null }
   )
}

@OptIn(ExperimentalComposeUiApi::class)
@Composable
private fun Scrim(onClose: () -> Unit, modifier: Modifier = Modifier) {
   val strClose = stringResource(R.string.close)
   Box(
      modifier
         // 포인터 입력 처리
         .pointerInput(onClose) { detectTapGestures { onClose() } }
         // 접근성 서비스 처리
         .semantics(mergeDescendants = true) {
            contentDescription = strClose
            onClick {
               onClose()
               true
            }
         }
         // 물리적 키보드 입력
         .onKeyEvent {
            if (it.key == Key.Escape) {
               onClose()
               true
            } else {
               false
            }
         }
         // scrim 그리기
         .background(Color.DarkGray.copy(alpha = 0.75f))
   )
}

var zoomed by remember { mutableStateOf(false) }
var zoomOffset by remember { mutableStateOf(Offset.Zero) }
Image(
   painter = rememberAsyncImagePainter(model = photo.highResUrl),
   contentDescription = null,
   modifier = modifier
      .pointerInput(Unit) {
         detectTapGestures(
            onDoubleTap = { tapOffset ->
               zoomOffset = if (zoomed) Offset.Zero else
                  calculateOffset(tapOffset, size)
               zoomed = !zoomed
            }
         )
      }
      .graphicsLayer {
         scaleX = if (zoomed) 2f else 1f
         scaleY = if (zoomed) 2f else 1f
         translationX = zoomOffset.x
         translationY = zoomOffset.y
      }
)

@Composable
private fun ScrollBoxes() {
   Column(
      modifier = Modifier
         .background(Color.LightGray)
         .size(100.dp)
         .verticalScroll(rememberScrollState())
   ) {
      repeat(10) {
         Text("Item $it", modifier = Modifier.padding(2.dp))
      }
   }
}

@Composable
private fun ScrollBoxesSmooth() {
   // 첫 번째 composition에서 100px 부드럽게 스크롤
   val state = rememberScrollState()
   LaunchedEffect(Unit) { state.animateScrollTo(100) }

   Column(
      modifier = Modifier
         .background(Color.LightGray)
         .size(100.dp)
         .padding(horizontal = 8.dp)
         .verticalScroll(state)
   ) {
      repeat(10) {
         Text("Item $it", modifier = Modifier.padding(2.dp))
      }
   }
}

@Composable
private fun ScrollableSample() {
   // 실제 composable 상태
   var offset by remember { mutableStateOf(0f) }
   Box(
      Modifier
         .size(150.dp)
         .scrollable(
            orientation = Orientation.Vertical,
            // Scrollable state : 스크롤 delta를 사용하고 오프셋을 업데이트하는 방법을 설명
            state = rememberScrollableState { delta ->
               offset += delta
               delta
            }
         )
         .background(Color.LightGray),
         contentAlignment = Alignment.Center
   ) {
      Text(offset.toString())
   }
}

@Composable
private fun AutomaticNestedScroll() {
   val gradient = Brush.verticalGradient(0f to Color.Gray, 1000f to Color.White)
   Box(
      modifier = Modifier
         .background(Color.LightGray)
         .verticalScroll(rememberScrollState())
         .padding(32.dp)
   ) {
      Column {
         repeat(6) {
            Box(
               modifier = Modifier
                  .height(128.dp)
                  .verticalScroll(rememberScrollState())
            ) {
               Text(
                  "Scroll here",
                  modifier = Modifier
                     .border(12.dp, Color.DarkGray)
                     .background(brush = gradient)
                     .padding(24.dp)
                     .height(150.dp)
               )
            }
         }
      }
   }
}

val disabledNestedScrollConnection = remember {
   object : NestedScrollConnection {
      override fun onPostScroll(
         consumed: Offset,
         available: Offset,
         source: NestedScrollSource
      ): Offset {
         return if (source == NestedScrollSource.SideEffect) {
            available
         } else {
            Offset.Zero
         }
      }
   }
}

@Composable
private fun DraggableText() {
   var offsetX by remember { mutableStateOf(0f) }
   Text(
      modifier = Modifier
         .offset { IntOffset(offsetX.roundToInt(), 0) }
         .draggable(
            orientation = Orientation.Horizontal,
            state = rememberDraggableState { delta ->
               offsetX += delta
            }
         ),
      text = "Drag me!"
   )
}

@Composable
private fun DraggableTextLowLevel() {
   Box(modifier = Modifier.fillMaxSize()) {
      var offsetX by remember { mutableStateOf(0f) }
      var offsetY by remember { mutableStateOf(0f) }

      Box(
         Modifier
            .offset { IntOffset(offsetX.roundToInt(), offsetY.roundToInt()) }
            .background(Color.Blue)
            .size(50.dp)
            .pointerInput(Unit) {
               detectDragGestures { change, dragAmount ->
                  change.consume()
                  offsetX += dragAmount.x
                  offsetY += dragAmount.y
               }
            }
      )
   }
}

@OptIn(ExperimentalMaterialApi::class)
@Composable
private fun SwipeableSample() {
   val width = 96.dp
   val squareSize = 48.dp

   val swipeableState = rememberSwipeableState(0)
   val sizePx = with(LocalDensity.current) { squareSize.toPx() }
   val anchors = mapOf(0f to 0, sizePx to 1) // Maps anchor points (in px) to states

   Box(
      modifier = Modifier
         .width(width)
         .swipeable(
            state = swipeableState,
            anchors = anchors,
            thresholds = { _, _ -> FractionalThreshold(0.3f) },
            orientation = Orientation.Horizontal
         )
         .background(Color.LightGray)
   ) {
      Box(
         Modifier
            .offset { IntOffset(swipeableState.offset.value.roundToInt(), 0) }
            .size(squareSize)
            .background(Color.DarkGray)
      )
   }
}

@Composable
private fun TransformableSample() {
   // 모든 변환 상태 설정
   var scale by remember { mutableStateOf(1f) }
   var rotation by remember { mutableStateOf(0f) }
   var offset by remember { mutableStateOf(Offset.Zero) }
   val state = rememberTransformableState { zoomChange, offsetChange, rotationChange ->
      scale *= zoomChange
      rotation += rotationChange
      offset += offsetChange
   }
   Box(
      Modifier
         // 회전과 같은 다른 변환을 적용하고, 피자 조각 이모티콘을 확대/축소
         .graphicsLayer(
            scaleX = scale,
            scaleY = scale,
            rotationZ = rotation,
            translationX = offset.x,
            translationY = offset.y
         )
         // offset 후 멀티터치 변환 이벤트를 수신하려면 transformable 항목을 추가
         .transformable(state = state)
         .background(Color.Blue)
         .fillMaxSize()
   )
}

Column {
   Row {
      TextButton({ }) { Text("First field") }
      TextButton({ }) { Text("Second field") }
   }
   Row {
      TextButton({ }) { Text("Third field") }
      TextButton({ }) { Text("Fourth field") }
   }
}

val (first, second, third, fourth) = remember { FocusRequester.createRefs() }

Column {
   Row {
      TextButton(
         {},
         Modifier
            .focusRequester(first)
            .focusProperties { next = second }
      ) {
         Text("First field")
      }
      TextButton(
         {},
         Modifier
            .focusRequester(third)
            .focusProperties { next = fourth }
      ) {
         Text("Third field")
      }
   }

   Row {
      TextButton(
         {},
         Modifier
            .focusRequester(second)
            .focusProperties { next = third }
      ) {
         Text("Second field")
      }
      TextButton(
         {},
         Modifier
            .focusRequester(fourth)
            .focusProperties { next = first }
      ) {
         Text("Fourth field")
      }
   }
}

TextButton(
   onClick = {},
   modifier = Modifier
      .focusRequester(fourth)
      .focusProperties {
         down = third
         right = second
      }
) {}

LazyVerticalGrid(columns = GridCells.Fixed(4)) {
   item(span = { GridItemSpan(maxLineSpan) }) {
      Row(modifier = Modifier.focusGroup()) {
         FilterChipA()
         FilterChipB()
         FilterChipC()
      }
   }
   items(chocolates) {
      SweetsCard(sweets = it)
   }
}

var color by remember { mutableStateOf(Green) }
Box(
   Modifier
      .background(color)
      .onFocusChanged { color = if (it.isFocused) Blue else Green }
      .focusable()
) {
   Text("Focusable 1")
}

var checked by remember { mutableStateOf(false) }

Switch(
    checked = checked,
    onCheckedChange = { checked = it },
    // 포커스를 맞출 수 없게 하지만, 터치/클릭 이벤트에 응답하는 것을 막지 않는다.
    modifier = Modifier
        .focusProperties { canFocus = false }
)

val focusRequester = remember { FocusRequester() }
var text by remember { mutableStateOf("") }

TextField(
   value = text,
   onValueChange = { text = it },
   modifier = Modifier.focusRequester(focusRequester)
)

Button(onClick = { focusRequester.requestFocus() }) {
   Text("Request focus on TextField")
}

val textField = FocusRequester()

TextField(
   value = text,
   onValueChange = {
      text = it

      if (it.length > 3) {
         textField.captureFocus()
      } else {
         textField.freeFocus()
      }
   },
   modifier = Modifier.focusRequester(textField)
)

Modifier
   .focusProperties { right = item1 }
   .focusProperties { right = item2 } // <-- 동작하지않음
   .focusable()

val otherComposable = remember { FocusRequester() }

Modifier.focusProperties {
   exit = { focusDirection ->
      when (focusDirection) {
         Right -> Cancel
         Down -> otherComposable
         else -> Default
      }
   }
}

val focusManager = LocalFocusManager.current
var text by remember { mutableStateOf("") }

TextField(
   value = text,
   onValueChange = { text = it },
   modifier = Modifier.onPreviewKeyEvent {
      when {
         // tab 키 누름이 감지되면 포커스가 포커스 목록의 다음 컴포넌트로 이동
         KeyEventType.KeyUp == it.type && Key.Tab == it.key -> {
            focusManager.moveFocus(FocusDirection.Next)
            true
         }

         else -> false
      }
   }
)

var color by remember { mutableStateOf(Color.White) }
Card(
   modifier = Modifier
      .onFocusChanged {
         color = if (it.isFocused) Red else White
      }
      .border(5.dp, color)
) {}

private class MyHighlightIndicationInstance(isEnabledState: State<Boolean>) :
   IndicationInstance {
   private val isEnabled by isEnabledState
   override fun ContentDrawScope.drawIndication() {
      drawContent()
      if (isEnabled) {
         drawRect(size = size, color = Color.White, alpha = 0.2f)
      }
   }
}

class MyHighlightIndication : Indication {
   @Composable
   override fun rememberUpdatedInstance(interactionSource: InteractionSource):
      IndicationInstance {
      val isFocusedState = interactionSource.collectIsFocusedAsState()
      return remember(interactionSource) {
         MyHighlightIndicationInstance(isEnabledState = isFocusedState)
      }
   }
}

val highlightIndication = remember { MyHighlightIndication() }
var interactionSource = remember { MutableInteractionSource() }

Card(
   modifier = Modifier
      .clickable(
         interactionSource = interactionSource,
         indication = highlightIndication,
         enabled = true,
         onClick = { }
      )
) {}

Modifier.onFocusChanged {
   val isFocused = it.isFocused
   val hasFocus = it.hasFocus
   val isCaptured= it.isCaptured
}

val interactionSource = remember { MutableInteractionSource() }
val isPressed by interactionSource.collectIsPressedAsState()

Button(
   onClick = { /* do something */ },
   interactionSource = interactionSource
) {
   Text(if (isPressed) "Pressed!" else "Not pressed")
}

// 소비자 Modifier
fun Modifier.focusBorder(interactionSource: InteractionSource): Modifier {
   // ...
}

// 생산자 Modifier
fun Modifier.hover(interactionSource: MutableInteractionSource, enabled: Boolean): Modifier {
   // ...
}

// This InteractionSource will emit hover and focus interactions
val interactionSource = remember { MutableInteractionSource() }

Box(
   Modifier
      .size(100.dp)
      .hoverable(interactionSource = interactionSource)
      .focusable(interactionSource = interactionSource),
   contentAlignment = Alignment.Center
) {
   Text("Hello!")
}

// InteractionSource는 hover, focus, press 인터랙션을 방출
val interactionSource = remember { MutableInteractionSource() }
Box(
   Modifier
      .size(100.dp)
      .clickable(
         onClick = {},
         interactionSource = interactionSource,

         // ripple 효과 표시
         indication = ripple()
      ),
   contentAlignment = Alignment.Center
) {
   Text("Hello!")
}

val interactionSource = remember { MutableInteractionSource() }
val interactions = remember { mutableStateListOf<Interaction>() }

LaunchedEffect(interactionSource) {
   interactionSource.interactions.collect { interaction ->
      when (interaction) {
         is PressInteraction.Press -> {
            interactions.add(interaction)
         }
         is PressInteraction.Release -> {
            interactions.remove(interaction.press)
         }
         is PressInteraction.Cancel -> {
            interactions.remove(interaction.press)
         }
         is DragInteraction.Start -> {
            interactions.add(interaction)
         }
         is DragInteraction.Stop -> {
            interactions.remove(interaction.start)
         }
         is DragInteraction.Cancel -> {
            interactions.remove(interaction.start)
         }
      }
   }
}

val isPressedOrDragged = interactions.isNotEmpty()

val lastInteraction = when (interactions.lastOrNull()) {
   is DragInteraction.Start -> "Dragged"
   is PressInteraction.Press -> "Pressed"
   else -> "No state"
}

val interactionSource = remember { MutableInteractionSource() }
val isPressed by interactionSource.collectIsPressedAsState()

Button(onClick = { /* do something */ }, interactionSource = interactionSource) {
   Text(if (isPressed) "Pressed!" else "Not pressed")
}

Modifier.dragAndDropSource {
   detectTapGestures(onLongPress = {
      // 데이터를 전송
      startTransfer(
         DragAndDropTransferData(
            ClipData.newPlainText(
               "image Url", url
            )
         )
      )
   })
}

val callback = remember {
   object : DragAndDropTarget {
      override fun onDrop(event: DragAndDropEvent): Boolean {
         // 이벤트가 소비되면 true를 반환
         return true
      }
   }
}

Modifier.dragAndDropTarget(
   shouldStartDragAndDrop = { event ->
      // 필터 역할을 하며 Modifier가 허용할 수 있는 데이터 종류를 지정
      event.mimeTypes().contains(ClipDescription.MIMETYPE_TEXT_PLAIN)
   }, target = callback
)

object : DragAndDropTarget {
   override fun onStarted(event: DragAndDropEvent) {
      // When the drag event starts
   }

   override fun onEntered(event: DragAndDropEvent) {
      // When the dragged object enters the target surface
   }

   override fun onEnded(event: DragAndDropEvent) {
      // When the drag event stops
   }

   override fun onExited(event: DragAndDropEvent) {
      // When the dragged object exits the target surface
   }

   override fun onDrop(event: DragAndDropEvent): Boolean = true
}