// ViewModel 부분
class SendViewModel(/* private val apiRepository: ApiRepository */) : ViewModel() {
    private val _sideEffect = Channel<SendSideEffect>(Channel.BUFFERED)
    val sideEffect: Flow<SendSideEffect> = _sideEffect.receiveAsFlow()

    // --- 보내기 버튼 클릭 시 ---
    fun onSendClicked() {
        // 메시지가 비어있는 경우, 확인 단계에서 처리하도록 여기서는 바로 다이얼로그 요청
        sendSideEffect(SendSideEffect.ShowConfirmationDialog)
    }

    // --- 확인 다이얼로그에서 '예'를 눌렀을 때 ---
    fun onConfirmationAccepted() {
        val message = _uiState.value.messageToSend
        // 메시지 비어있는지 확인 (여기서 하거나 API 호출 전에 할 수 있음)
        if (message.isBlank()) {
            sendSideEffect(SendSideEffect.ShowSendMessageError("메시지는 비워둘 수 없습니다"))
            return
        }

        viewModelScope.launch {
            _uiState.update { it.copy(isLoading = true) } // 로딩 상태 시작
            kotlinx.coroutines.delay(1500) // 네트워크 통신 시뮬레이션
            val success = false // API 호출 결과 시뮬레이션 (실패 케이스)
            _uiState.update { it.copy(isLoading = false) } // 로딩 상태 종료

            if (success) {
                sendSideEffect(SendSideEffect.ShowSendMessageSuccess("메시지를 성공적으로 보냈습니다!"))
                _uiState.update { it.copy(messageToSend = "") } // 성공 시 메시지 초기화
            } else {
                // 실패 시나리오
                sendSideEffect(SendSideEffect.ShowSendMessageError("메시지 전송 실패"))
            }
        }
    }

    // --- 확인 다이얼로그에서 '아니요' 또는 외부 클릭으로 취소했을 때 ---
    fun onConfirmationCancelled() {
        println("사용자가 메시지 전송을 취소했습니다.")
    }

    // --- SideEffect를 채널로 보내는 내부 함수 ---
    private fun sendSideEffect(effect: SendSideEffect) {
        viewModelScope.launch {
            _sideEffect.send(effect)
        }
    }
}

// SideEffect 정의
sealed interface SendSideEffect {
    data object ShowConfirmationDialog : SendSideEffect // 확인 다이얼로그 표시 요청
    data class ShowSendMessageSuccess(val successMessage: String) : SendSideEffect // 성공 메시지 표시 요청
    data class ShowSendMessageError(val errorMessage: String) : SendSideEffect   // 에러 메시지 표시 요청
}

// SideEffect 처리 Composable
@Composable
fun HandleSideEffects(
    sideEffectFlow: Flow<SendSideEffect>, // ViewModel로부터 SideEffect Flow 받기
    snackbarHostState: SnackbarHostState, // Snackbar를 표시하기 위한 상태 객체
    onShowConfirmationDialog: () -> Unit  // 확인 다이얼로그를 표시하는 람다 함수
) {
    // LaunchedEffect는 Composable의 생명주기 내에서 안전하게 코루틴을 실행한다.
    // key1 = true는 Composable이 처음 생성될 때 한 번만 실행되도록 보장한다.
    LaunchedEffect(true) {
        // collectLatest: 새로운 SideEffect가 도착하면 이전 처리 로직이 끝나지 않았더라도 취소하고 새 로직을 시작한다.
        sideEffectFlow.collectLatest { effect ->
            when (effect) {
                // 확인 다이얼로그 표시 요청 처리
                is SendSideEffect.ShowConfirmationDialog -> {
                    onShowConfirmationDialog() // 전달받은 람다 실행하여 다이얼로그 표시 상태 변경
                }
                // 성공 메시지 표시 요청 처리
                is SendSideEffect.ShowSendMessageSuccess -> {
                    snackbarHostState.showSnackbar(
                        message = effect.successMessage, // ViewModel에서 전달된 성공 메시지
                        duration = SnackbarDuration.Short // 짧게 표시
                    )
                }
                // 에러 메시지 표시 요청 처리
                is SendSideEffect.ShowSendMessageError -> {
                     snackbarHostState.showSnackbar(
                        message = effect.errorMessage, // ViewModel에서 전달된 에러 메시지
                        duration = SnackbarDuration.Long // 길게 표시
                    )
                }
            }
        }
    }
}

// 메인 화면 Composable
@Composable
fun SendScreen(
    modifier: Modifier = Modifier,
    viewModel: SendViewModel = viewModel() // ViewModel 인스턴스 가져오기
) {
    // 확인 다이얼로그의 표시 여부를 관리하는 상태 변수
    var showDialog by remember { mutableStateOf(false) }

    // Snackbar 메시지를 표시하기 위한 상태 객체
    val snackbarHostState = remember { SnackbarHostState() }

    // SideEffect 처리 로직 실행 (별도 Composable 사용)
    HandleSideEffects(
        sideEffectFlow = viewModel.sideEffect,
        snackbarHostState = snackbarHostState,
        onShowConfirmationDialog = { showDialog = true } // SideEffect 발생 시 showDialog 상태를 true로 변경
    )

    // Scaffold: 기본적인 머티리얼 디자인 레이아웃 구조 제공
    Scaffold(
        modifier = modifier,
        snackbarHost = { SnackbarHost(snackbarHostState) } // Snackbar가 표시될 위치 지정
    ) { paddingValues -> // Scaffold 내부 컨텐츠 영역의 패딩 값
        // UI 생략
    }

    // showDialog 상태가 true일 때만 확인 다이얼로그 표시
    if (showDialog) {
        AlertDialog(
            onDismissRequest = {
                showDialog = false // 다이얼로그 닫기
                viewModel.onConfirmationCancelled() // ViewModel에 취소 알림
            },
            title = { Text("전송 확인") },
            text = { Text("이 메시지를 전송하시겠습니까?") },
            confirmButton = {
                Button(
                    onClick = {
                        showDialog = false // 다이얼로그 닫기
                        viewModel.onConfirmationAccepted() // ViewModel에 확인 알림
                    }
                ) { Text("예") }
            },
            dismissButton = {
                Button(
                    onClick = {
                        showDialog = false // 다이얼로그 닫기
                        viewModel.onConfirmationCancelled() // ViewModel에 취소 알림
                    }
                ) { Text("아니요") }
            }
        )
    }
}

// Alert/Snackbar 처리를 위한 공통 Composable
@Composable
fun CaAlertScreen(
    snackbarHostState: SnackbarHostState, // Snackbar 상태 관리
    // Dialog UI를 커스텀하고 싶을 때 제공하는 람다
    onDialogScreen: (@Composable (caAlertUiStateDialogUiState: CaAlertUiStateDialogUiState, onAction: (nextAction: CaAction) -> Unit) -> Unit)? = null,
) {
    // 내부 구현 호출
    InternalCaAlertScreen(
        snackbarHostState = snackbarHostState,
        onDialogScreen = onDialogScreen,
    )
}

// 예시: 커스텀 Dialog Composable
@Composable
internal fun CustomDialogScreen(
    caAlertUiStateDialogUiState: CaAlertUiStateDialogUiState, // Dialog 상태 정보
    onAction: (nextAction: CaAction) -> Unit, // Dialog 내 버튼 클릭 시 실행할 Action 전달 함수
) {
    AlertDialog(
        icon = { /* 아이콘 로직 */ },
        title = { /* 타이틀 로직 */ },
        onDismissRequest = {
            // 바깥 영역 클릭 또는 뒤로가기 시 실행될 Action 전달
            onAction(caAlertUiStateDialogUiState.onDismissRequest)
        },
        confirmButton = { /* 확인 버튼 로직, 클릭 시 onAction(confirmAction) 호출 */ },
        dismissButton = { /* 취소 버튼 로직, 클릭 시 onAction(dismissAction) 호출 */ }
        // 생략
    )
}

// Alert/Snackbar 처리를 전담하는 ViewModel
@HiltViewModel
class CaAlertViewModel @Inject constructor(
    private val flowCaActionStream: FlowCaActionStream, // Action 스트림 주입
) : CaViewModel<CaAlertAction>( // CaAlertAction 타입의 Action만 수신
    flowCaActionStream = flowCaActionStream,
    actionClass = CaAlertAction::class,
) {

    // Dialog의 내용을 담는 UiState
    private val _alertUiStateDialogUiState = MutableStateFlow(CaAlertUiStateDialogUiState.Default)
    val alertUiStateDialogUiState = _alertUiStateDialogUiState.asStateFlow()

    // Dialog/Snackbar 표시/숨김 명령을 위한 SideEffect 채널
    private val _sideEffect = Channel<CaAlertSideEffect>(Channel.BUFFERED)
    internal val sideEffect = _sideEffect.receiveAsFlow()

    // CaAlertAction을 받았을 때 처리하는 로직 (Reducer)
    override suspend fun reducer(action: CaAlertAction) {
        when (action) {
            is CaAlertAction.ShowDialog -> {
                // Action의 정보로 Dialog UiState 생성
                val dialogItem = CaAlertUiStateDialogUiState( /* ... action의 데이터 사용 ... */ )
                _alertUiStateDialogUiState.value = dialogItem
                // Dialog를 표시하라는 SideEffect 전송
                _sideEffect.send(CaAlertSideEffect.ShowDialog)
            }
            is CaAlertAction.HideDialog -> {
                // 기본 상태로 되돌리고 Dialog 숨김 SideEffect 전송
                _alertUiStateDialogUiState.value = CaAlertUiStateDialogUiState.Default
                _sideEffect.send(CaAlertSideEffect.HideDialog)
            }
            is CaAlertAction.ShowSnack -> {
                // Action 정보로 Snackbar SideEffect 생성 및 전송
                val snackItem = CaAlertSideEffect.ShowSnack( /* ... action의 데이터 사용 ... */ )
                _sideEffect.send(snackItem)
            }
            is CaAlertAction.None -> { /* 무시 */ }
        }
    }

    // 내부 Duration 타입을 Material의 SnackbarDuration으로 변환하는 함수
    private fun CaAlertAction.ShowSnack.Duration.convert(): SnackbarDuration = /* ... 변환 로직 ... */
}

// CaAlertViewModel에서 사용하는 SideEffect 정의
internal sealed interface CaAlertSideEffect {
    data object ShowDialog : CaAlertSideEffect
    data object HideDialog : CaAlertSideEffect
    data class ShowSnack(
        val message: String,
        val actionLabel: String,
        val onAction: CaAction,
        val onDismiss: CaAction,
        val duration: SnackbarDuration,
    ) : CaAlertSideEffect
}

// CaAlertViewModel의 UiState 정의
internal data class CaAlertUiStateDialogUiState( /* ... Dialog 속성들 ... */ ) {
    companion object {
        val Default = CaAlertUiStateDialogUiState( /* ... 기본값 ... */ )
    }
}

// CaAlertViewModel이 수신하는 Action 정의
sealed interface CaAlertAction : CaAction {
    // Dialog 표시 Action
    data class ShowDialog( /* ... Dialog 속성 및 클릭 시 발생시킬 Action 정의 ... */ ) : CaAlertAction
    // Dialog 숨김 Action
    data object HideDialog : CaAlertAction
    // Snackbar 표시 Action
    data class ShowSnack( /* ... Snackbar 속성 및 클릭/닫기 시 발생시킬 Action 정의 ... */ ) : CaAlertAction
    // 빈 Action
    data object None : CaAlertAction
}

// CaAlertScreen의 내부 구현 Composable
@Composable
private fun InternalCaAlertScreen(
    snackbarHostState: SnackbarHostState,
    onDialogScreen: (@Composable (caAlertUiStateDialogUiState: CaAlertUiStateDialogUiState, onAction: (nextAction: CaAction) -> Unit) -> Unit)? = null,
    caAlertViewModel: CaAlertViewModel = viewModel(), // CaAlertViewModel 인스턴스
) {
    // Dialog 표시 여부 상태
    var showDialog by remember { mutableStateOf(false) }
    // Action 전송을 위한 객체 (CompositionLocal 활용)
    val actionSender = LocalCaActionOwner.current

    // CaAlertViewModel의 SideEffect를 구독하고 처리
    caAlertViewModel.sideEffect.collectLifecycleEvent { event -> // collectLifecycleEvent는 Lifecycle 고려한 확장 함수로 가정
        when (event) {
            is CaAlertSideEffect.ShowDialog -> showDialog = true // Dialog 표시 상태 변경
            is CaAlertSideEffect.HideDialog -> showDialog = false // Dialog 숨김 상태 변경
            is CaAlertSideEffect.ShowSnack -> {
                // Snackbar 표시 로직
                val result = snackbarHostState.showSnackbar( /* ... event 데이터 사용 ... */ )
                // Snackbar 결과에 따라 후속 Action 전송
                when (result) {
                    SnackbarResult.ActionPerformed -> actionSender.send(event.onAction) // 'Action' 버튼 클릭 시
                    SnackbarResult.Dismissed -> actionSender.send(event.onDismiss)    // 닫혔을 때
                }
            }
        }
    }

    // CaAlertViewModel의 Dialog UiState 구독
    val caAlertUiStateDialogUiState by caAlertViewModel.alertUiStateDialogUiState.collectAsStateWithLifecycle()

    // showDialog 상태가 true이면 Dialog 표시
    if (showDialog) {
        // Dialog 내 버튼 클릭 시 실행될 공통 로직 (Dialog 숨기고, 지정된 다음 Action 전송)
        val onAction: (nextAction: CaAction) -> Unit = { nextAction ->
            actionSender.send(CaAlertAction.HideDialog) // 먼저 Dialog 숨김 Action 전송
            actionSender.send(nextAction) // 그 다음, 버튼에 지정된 Action 전송
        }
        // 커스텀 Dialog 람다가 제공되면 그것을 사용, 아니면 기본 CaDialogScreen 사용
        onDialogScreen?.invoke(caAlertUiStateDialogUiState, onAction)
            ?: CaDialogScreen(caAlertUiStateDialogUiState = caAlertUiStateDialogUiState, onAction = onAction)
    }

    // CaAlertViewModel의 생명주기 관리를 위한 Composable (내부 구현은 생략)
    LaunchedLifecycleViewModel(viewModel = caAlertViewModel)
}

// Composable에서 Action 전송 예시
val actionSender = LocalCaActionOwner.current
actionSender.send(
    CaAlertAction.ShowDialog(
        title = "전송 확인",
        message = "메시지를 보내시겠습니까?",
        confirmButtonText = "예",
        // '예' 버튼 클릭 시 실행될 Action 정의 (여기서는 Snackbar 표시 Action)
        onConfirmButtonAction = CaAlertAction.ShowSnack(message = "확인됨"),
        dismissButtonText = "아니요",
        // '아니요' 버튼 클릭 시 실행될 Action 정의
        onDismissButtonAction = CaAlertAction.ShowSnack(message = "취소됨"),
        // 바깥 영역 클릭 시 실행될 Action
        onDismissRequest = CaAlertAction.None // 아무것도 안함
    )
)

// ViewModel에서 Action 전송 예시 (nextAction 함수 사용 가정)
nextAction( // BaseViewModel 등에 구현된 Action 전송 함수
    CaAlertAction.ShowDialog( /* ... 위와 동일 ... */ )
)