// 1. Action 정의
sealed interface SearchAction {
    data object OnViewCreated : SearchAction
    data class OnSearch(val text: String) : SearchAction
    data class OnClickItem(val id: String) : SearchAction
}

// 2. State 정의
data class State(
    val imageList: List<ImageItem> = emptyList(),
    val isLoading: Boolean = false,
    val searchText: String = ""
)

// 3. Mutate 정의
sealed interface SearchMutate {
    sealed interface Reduce : SearchMutate {
        data class UpdateImageList(val list: List<ImageItem>) : Reduce
        data class UpdateLoading(val isLoading: Boolean) : Reduce
    }
    sealed interface SideEffect : SearchMutate {
        data class NaviToDetail(val id: String) : SideEffect
        data class ShowSnackBar(val message: String) : SideEffect
    }
}

// 4. MutateHandler
class SearchMutateHandler @Inject constructor(
    private val getSearchPhotoUseCase: GetSearchPhotoUseCase
) {
    fun mutate(action: SearchAction, state: State): Flow<SearchMutate> = flow {
        when (action) {
            is SearchAction.OnSearch -> {
                getSearchPhotoUseCase(action.text, 1)
                    .onStart { emit(Reduce.UpdateLoading(true)) }
                    .onCompletion { emit(Reduce.UpdateLoading(false)) }
                    .collect { result ->
                        result.onSuccess { data ->
                            emit(Reduce.UpdateImageList(data.results))
                        }.onFailure { error ->
                            emit(SideEffect.ShowSnackBar(error.message ?: "Error"))
                        }
                    }
            }
            is SearchAction.OnClickItem -> {
                emit(SideEffect.NaviToDetail(action.id))
            }
        }
    }
}

// 5. ViewModel
@HiltViewModel
class SearchViewModel @Inject constructor(
    private val mutateHandler: SearchMutateHandler
) : ViewModel() {
    private val _state = MutableStateFlow(State())
    val state = _state.asStateFlow()

    private val _sideEffect = MutableSharedFlow<SearchMutate.SideEffect>()
    val sideEffect = _sideEffect.asSharedFlow()

    fun onAction(action: SearchAction) {
        viewModelScope.launch {
            mutateHandler.mutate(action, _state.value).collect { mutate ->
                when (mutate) {
                    is SearchMutate.Reduce -> reduce(mutate)
                    is SearchMutate.SideEffect -> _sideEffect.emit(mutate)
                }
            }
        }
    }

    private fun reduce(reduce: SearchMutate.Reduce) {
        _state.update { state ->
            when (reduce) {
                is SearchMutate.Reduce.UpdateImageList -> 
                    state.copy(imageList = reduce.list)
                is SearchMutate.Reduce.UpdateLoading -> 
                    state.copy(isLoading = reduce.isLoading)
            }
        }
    }
}

// 6. Composable
@Composable
fun SearchRoute(
    viewModel: SearchViewModel = hiltViewModel()
) {
    val state by viewModel.state.collectAsStateWithLifecycle()

    LaunchedEffect(Unit) {
        viewModel.onAction(SearchAction.OnViewCreated)
    }

    LaunchedEffect(Unit) {
        viewModel.sideEffect.collect { sideEffect ->
            when (sideEffect) {
                is SearchMutate.SideEffect.ShowSnackBar -> {
                    // 스낵바 표시
                }
                is SearchMutate.SideEffect.NaviToDetail -> {
                    // 상세 화면으로 이동
                }
            }
        }
    }

    SearchScreen(state = state, onAction = viewModel::onAction)
}

class SearchMutateHandlerTest : BehaviorSpec() {
    init {
        val mockUseCase: GetSearchPhotoUseCase = mockk()
        val handler = SearchMutateHandler(mockUseCase)

        Given("검색 화면에") {
            val state = SearchMutate.State()

            When("검색을 수행하면") {
                val action = SearchAction.OnSearch("test")

                coEvery { mockUseCase.invoke(any(), any()) } returns flow {
                    emit(Result.success(mockData))
                }

                handler.mutate(action, state).test {
                    Then("로딩 상태를 시작한다") {
                        awaitItem() shouldBe UpdateLoading(true)
                    }

                    Then("데이터를 업데이트한다") {
                        val item = awaitItem()
                        item.shouldBeInstanceOf<UpdateImageList>()
                    }

                    Then("로딩 상태를 종료한다") {
                        awaitItem() shouldBe UpdateLoading(false)
                    }

                    awaitComplete()
                }
            }
        }
    }
}

// feature/myfeature/build.gradle.kts
plugins {
    id("custom.feature.library")
    id("custom.android.hilt")
    id("custom.android.library.compose")
}

android {
    namespace = "com.jooys.template.feature.myfeature"
}