// 데이터 클래스 정의
data class User(
    val id: Int,
    val name: String,
    val email: String,
    val profileImageUrl: String
)

// Repository 인터페이스
interface UserRepository {
    suspend fun getUser(userId: Int): Result<User>
    suspend fun updateUser(user: User): Result<Unit>
    fun observeUser(userId: Int): Flow<User>
}

// Repository 구현체
class UserRepositoryImpl(
    private val apiService: ApiService,
    private val userDao: UserDao
) : UserRepository {
    
    override suspend fun getUser(userId: Int): Result<User> {
        return try {
            // 먼저 로컬 DB에서 확인
            val localUser = userDao.getUserById(userId)
            if (localUser != null) {
                Result.success(localUser)
            } else {
                // 없으면 API에서 가져오기
                val response = apiService.getUser(userId)
                if (response.isSuccessful) {
                    response.body()?.let { user ->
                        userDao.insertUser(user)
                        Result.success(user)
                    } ?: Result.failure(Exception("Empty response"))
                } else {
                    Result.failure(Exception("API Error: ${response.code()}"))
                }
            }
        } catch (e: Exception) {
            Result.failure(e)
        }
    }
    
    override fun observeUser(userId: Int): Flow<User> {
        return userDao.observeUser(userId)
    }
}

class UserProfileFragment : Fragment() {
    
    // ViewBinding 사용
    private var _binding: FragmentUserProfileBinding? = null
    private val binding get() = _binding!!
    
    // ViewModel 초기화
    private val viewModel: UserProfileViewModel by viewModels()
    
    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        _binding = FragmentUserProfileBinding.inflate(inflater, container, false)
        return binding.root
    }
    
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        
        setupObservers()
        setupListeners()
    }
    
    private fun setupObservers() {
        // ViewModel의 데이터 관찰
        viewLifecycleOwner.lifecycleScope.launch {
            viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
                // 사용자 정보 관찰
                launch {
                    viewModel.userState.collect { state ->
                        when (state) {
                            is UiState.Loading -> showLoading()
                            is UiState.Success -> showUserProfile(state.data)
                            is UiState.Error -> showError(state.message)
                        }
                    }
                }
                
                // 이벤트 관찰
                launch {
                    viewModel.events.collect { event ->
                        when (event) {
                            is UserProfileEvent.ShowToast -> {
                                Toast.makeText(context, event.message, Toast.LENGTH_SHORT).show()
                            }
                            is UserProfileEvent.NavigateToEdit -> {
                                // 편집 화면으로 이동
                                findNavController().navigate(
                                    R.id.action_profile_to_edit
                                )
                            }
                        }
                    }
                }
            }
        }
    }
    
    private fun setupListeners() {
        binding.editButton.setOnClickListener {
            viewModel.onEditClicked()
        }
        
        binding.refreshButton.setOnClickListener {
            viewModel.refreshUser()
        }
    }
    
    private fun showUserProfile(user: User) {
        binding.apply {
            nameTextView.text = user.name
            emailTextView.text = user.email
            Glide.with(this@UserProfileFragment)
                .load(user.profileImageUrl)
                .into(profileImageView)
        }
    }
    
    private fun showLoading() {
        binding.progressBar.visibility = View.VISIBLE
        binding.contentLayout.visibility = View.GONE
    }
    
    private fun showError(message: String) {
        binding.progressBar.visibility = View.GONE
        binding.errorTextView.text = message
        binding.errorTextView.visibility = View.VISIBLE
    }
    
    override fun onDestroyView() {
        super.onDestroyView()
        _binding = null
    }
}

class UserProfileViewModel(
    private val userRepository: UserRepository,
    private val savedStateHandle: SavedStateHandle
) : ViewModel() {
    
    // UI 상태를 나타내는 StateFlow
    private val _userState = MutableStateFlow<UiState<User>>(UiState.Loading)
    val userState: StateFlow<UiState<User>> = _userState.asStateFlow()
    
    // 일회성 이벤트를 위한 SharedFlow
    private val _events = MutableSharedFlow<UserProfileEvent>()
    val events: SharedFlow<UserProfileEvent> = _events.asSharedFlow()
    
    // 사용자 ID (SavedStateHandle로 저장되어 프로세스 종료 후에도 복원)
    private val userId: Int = savedStateHandle.get<Int>("userId") ?: 0
    
    init {
        loadUser()
    }
    
    private fun loadUser() {
        viewModelScope.launch {
            _userState.value = UiState.Loading
            
            userRepository.getUser(userId)
                .onSuccess { user ->
                    _userState.value = UiState.Success(user)
                }
                .onFailure { exception ->
                    _userState.value = UiState.Error(
                        exception.message ?: "알 수 없는 오류가 발생했습니다"
                    )
                    _events.emit(
                        UserProfileEvent.ShowToast("사용자 정보를 불러올 수 없습니다")
                    )
                }
        }
    }
    
    fun refreshUser() {
        viewModelScope.launch {
            _userState.value = UiState.Loading
            
            // 강제로 새로고침 (캐시 무시)
            userRepository.getUser(userId)
                .onSuccess { user ->
                    _userState.value = UiState.Success(user)
                    _events.emit(
                        UserProfileEvent.ShowToast("새로고침 완료!")
                    )
                }
                .onFailure { exception ->
                    _userState.value = UiState.Error(
                        exception.message ?: "새로고침 실패"
                    )
                }
        }
    }
    
    fun onEditClicked() {
        viewModelScope.launch {
            _events.emit(UserProfileEvent.NavigateToEdit)
        }
    }
    
    fun updateUserName(newName: String) {
        viewModelScope.launch {
            val currentState = _userState.value
            if (currentState is UiState.Success) {
                val updatedUser = currentState.data.copy(name = newName)
                
                userRepository.updateUser(updatedUser)
                    .onSuccess {
                        _userState.value = UiState.Success(updatedUser)
                        _events.emit(
                            UserProfileEvent.ShowToast("이름이 변경되었습니다")
                        )
                    }
                    .onFailure {
                        _events.emit(
                            UserProfileEvent.ShowToast("이름 변경에 실패했습니다")
                        )
                    }
            }
        }
    }
}

// UI 상태를 나타내는 sealed class
sealed class UiState<out T> {
    object Loading : UiState<Nothing>()
    data class Success<T>(val data: T) : UiState<T>()
    data class Error(val message: String) : UiState<Nothing>()
}

// 일회성 이벤트를 나타내는 sealed class
sealed class UserProfileEvent {
    data class ShowToast(val message: String) : UserProfileEvent()
    object NavigateToEdit : UserProfileEvent()
}

class UserViewModel : ViewModel() {
    
    private val _userName = MutableLiveData<String>()
    val userName: LiveData<String> = _userName
    
    private val _isLoading = MutableLiveData<Boolean>()
    val isLoading: LiveData<Boolean> = _isLoading
    
    // Transformations를 사용한 데이터 변환
    val userNameLength: LiveData<Int> = Transformations.map(userName) {
        it.length
    }
    
    // 여러 LiveData를 결합
    val userInfo: LiveData<String> = MediatorLiveData<String>().apply {
        addSource(userName) { name ->
            value = "사용자: $name"
        }
    }
    
    fun updateUserName(name: String) {
        _userName.value = name
    }
}

// Fragment에서 관찰
class MyFragment : Fragment() {
    private val viewModel: UserViewModel by viewModels()
    
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        
        viewModel.userName.observe(viewLifecycleOwner) { name ->
            binding.nameTextView.text = name
        }
        
        viewModel.isLoading.observe(viewLifecycleOwner) { isLoading ->
            binding.progressBar.isVisible = isLoading
        }
    }
}

class ModernViewModel : ViewModel() {
    
    // StateFlow - 상태 관리
    private val _userName = MutableStateFlow("")
    val userName: StateFlow<String> = _userName.asStateFlow()
    
    private val _isLoading = MutableStateFlow(false)
    val isLoading: StateFlow<Boolean> = _isLoading.asStateFlow()
    
    // SharedFlow - 이벤트 처리
    private val _events = MutableSharedFlow<UiEvent>()
    val events: SharedFlow<UiEvent> = _events.asSharedFlow()
    
    // Flow 변환 및 결합
    val userNameLength: StateFlow<Int> = userName
        .map { it.length }
        .stateIn(
            scope = viewModelScope,
            started = SharingStarted.WhileSubscribed(5000),
            initialValue = 0
        )
    
    // 여러 Flow 결합
    val combinedState: StateFlow<CombinedState> = combine(
        userName,
        isLoading
    ) { name, loading ->
        CombinedState(name, loading)
    }.stateIn(
        scope = viewModelScope,
        started = SharingStarted.WhileSubscribed(5000),
        initialValue = CombinedState("", false)
    )
    
    fun updateUserName(name: String) {
        _userName.value = name
    }
    
    fun sendEvent() {
        viewModelScope.launch {
            _events.emit(UiEvent.ShowMessage("이벤트 발생!"))
        }
    }
}

// Fragment에서 수집
class ModernFragment : Fragment() {
    private val viewModel: ModernViewModel by viewModels()
    
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        
        viewLifecycleOwner.lifecycleScope.launch {
            viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
                // StateFlow 수집
                launch {
                    viewModel.userName.collect { name ->
                        binding.nameTextView.text = name
                    }
                }
                
                // SharedFlow 수집
                launch {
                    viewModel.events.collect { event ->
                        when (event) {
                            is UiEvent.ShowMessage -> {
                                Toast.makeText(context, event.message, Toast.LENGTH_SHORT).show()
                            }
                        }
                    }
                }
            }
        }
    }
}

sealed class UiEvent {
    data class ShowMessage(val message: String) : UiEvent()
}

<!-- layout/fragment_user.xml -->
<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <variable
            name="viewModel"
            type="com.example.UserViewModel" />
    </data>
    
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical">
        
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@{viewModel.userName}" />
        
        <ProgressBar
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:visibility="@{viewModel.isLoading ? View.VISIBLE : View.GONE}" />
        
        <Button
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="새로고침"
            android:onClick="@{() -> viewModel.refresh()}" />
    </LinearLayout>
</layout>

// Fragment
class UserFragment : Fragment() {
    private lateinit var binding: FragmentUserBinding
    private val viewModel: UserViewModel by viewModels()
    
    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        binding = DataBindingUtil.inflate(
            inflater,
            R.layout.fragment_user,
            container,
            false
        )
        binding.lifecycleOwner = viewLifecycleOwner
        binding.viewModel = viewModel
        return binding.root
    }
}

// build.gradle.kts (Module)
plugins {
    id("com.android.application")
    id("org.jetbrains.kotlin.android")
    id("kotlin-kapt")
    id("com.google.dagger.hilt.android")
}

android {
    // ... 기본 설정
    
    buildFeatures {
        viewBinding = true
    }
}

dependencies {
    // Core
    implementation("androidx.core:core-ktx:1.12.0")
    implementation("androidx.appcompat:appcompat:1.6.1")
    implementation("com.google.android.material:material:1.11.0")
    
    // ViewModel & LiveData
    implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.7.0")
    implementation("androidx.lifecycle:lifecycle-livedata-ktx:2.7.0")
    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.7.0")
    
    // Fragment
    implementation("androidx.fragment:fragment-ktx:1.6.2")
    
    // Coroutines
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3")
    
    // Room Database
    implementation("androidx.room:room-runtime:2.6.1")
    implementation("androidx.room:room-ktx:2.6.1")
    kapt("androidx.room:room-compiler:2.6.1")
    
    // Hilt (Dependency Injection)
    implementation("com.google.dagger:hilt-android:2.50")
    kapt("com.google.dagger:hilt-compiler:2.50")
    
    // Testing
    testImplementation("junit:junit:4.13.2")
    testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.7.3")
    testImplementation("androidx.arch.core:core-testing:2.2.0")
}

// 데이터 클래스
@Entity(tableName = "todos")
data class Todo(
    @PrimaryKey(autoGenerate = true)
    val id: Long = 0,
    val title: String,
    val description: String,
    val isCompleted: Boolean = false,
    val createdAt: Long = System.currentTimeMillis(),
    val priority: Priority = Priority.MEDIUM
)

enum class Priority {
    LOW, MEDIUM, HIGH
}

// DAO (Data Access Object)
@Dao
interface TodoDao {
    @Query("SELECT * FROM todos ORDER BY priority DESC, createdAt DESC")
    fun getAllTodos(): Flow<List<Todo>>
    
    @Query("SELECT * FROM todos WHERE id = :id")
    suspend fun getTodoById(id: Long): Todo?
    
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun insertTodo(todo: Todo): Long
    
    @Update
    suspend fun updateTodo(todo: Todo)
    
    @Delete
    suspend fun deleteTodo(todo: Todo)
    
    @Query("SELECT * FROM todos WHERE isCompleted = :isCompleted")
    fun getTodosByStatus(isCompleted: Boolean): Flow<List<Todo>>
}

// Database
@Database(entities = [Todo::class], version = 1)
abstract class TodoDatabase : RoomDatabase() {
    abstract fun todoDao(): TodoDao
}

// Repository
interface TodoRepository {
    fun getAllTodos(): Flow<List<Todo>>
    suspend fun getTodoById(id: Long): Todo?
    suspend fun insertTodo(todo: Todo): Long
    suspend fun updateTodo(todo: Todo)
    suspend fun deleteTodo(todo: Todo)
    fun getActiveTodos(): Flow<List<Todo>>
    fun getCompletedTodos(): Flow<List<Todo>>
}

class TodoRepositoryImpl @Inject constructor(
    private val todoDao: TodoDao
) : TodoRepository {
    
    override fun getAllTodos(): Flow<List<Todo>> = todoDao.getAllTodos()
    
    override suspend fun getTodoById(id: Long): Todo? = todoDao.getTodoById(id)
    
    override suspend fun insertTodo(todo: Todo): Long = todoDao.insertTodo(todo)
    
    override suspend fun updateTodo(todo: Todo) = todoDao.updateTodo(todo)
    
    override suspend fun deleteTodo(todo: Todo) = todoDao.deleteTodo(todo)
    
    override fun getActiveTodos(): Flow<List<Todo>> = 
        todoDao.getTodosByStatus(false)
    
    override fun getCompletedTodos(): Flow<List<Todo>> = 
        todoDao.getTodosByStatus(true)
}

@HiltViewModel
class TodoListViewModel @Inject constructor(
    private val todoRepository: TodoRepository
) : ViewModel() {
    
    // UI 상태
    private val _uiState = MutableStateFlow<TodoListUiState>(TodoListUiState.Loading)
    val uiState: StateFlow<TodoListUiState> = _uiState.asStateFlow()
    
    // 필터 상태
    private val _filterType = MutableStateFlow(FilterType.ALL)
    val filterType: StateFlow<FilterType> = _filterType.asStateFlow()
    
    // 이벤트
    private val _events = MutableSharedFlow<TodoListEvent>()
    val events: SharedFlow<TodoListEvent> = _events.asSharedFlow()
    
    init {
        loadTodos()
    }
    
    private fun loadTodos() {
        viewModelScope.launch {
            combine(
                todoRepository.getAllTodos(),
                _filterType
            ) { todos, filter ->
                when (filter) {
                    FilterType.ALL -> todos
                    FilterType.ACTIVE -> todos.filter { !it.isCompleted }
                    FilterType.COMPLETED -> todos.filter { it.isCompleted }
                }
            }.catch { exception ->
                _uiState.value = TodoListUiState.Error(
                    exception.message ?: "할 일을 불러올 수 없습니다"
                )
            }.collect { filteredTodos ->
                _uiState.value = if (filteredTodos.isEmpty()) {
                    TodoListUiState.Empty
                } else {
                    TodoListUiState.Success(filteredTodos)
                }
            }
        }
    }
    
    fun addTodo(title: String, description: String, priority: Priority) {
        if (title.isBlank()) {
            viewModelScope.launch {
                _events.emit(TodoListEvent.ShowError("제목을 입력해주세요"))
            }
            return
        }
        
        viewModelScope.launch {
            try {
                val todo = Todo(
                    title = title,
                    description = description,
                    priority = priority
                )
                todoRepository.insertTodo(todo)
                _events.emit(TodoListEvent.ShowSuccess("할 일이 추가되었습니다"))
            } catch (e: Exception) {
                _events.emit(TodoListEvent.ShowError("할 일 추가에 실패했습니다"))
            }
        }
    }
    
    fun toggleTodoComplete(todo: Todo) {
        viewModelScope.launch {
            try {
                val updatedTodo = todo.copy(isCompleted = !todo.isCompleted)
                todoRepository.updateTodo(updatedTodo)
            } catch (e: Exception) {
                _events.emit(TodoListEvent.ShowError("상태 변경에 실패했습니다"))
            }
        }
    }
    
    fun deleteTodo(todo: Todo) {
        viewModelScope.launch {
            try {
                todoRepository.deleteTodo(todo)
                _events.emit(TodoListEvent.ShowSuccess("할 일이 삭제되었습니다"))
            } catch (e: Exception) {
                _events.emit(TodoListEvent.ShowError("삭제에 실패했습니다"))
            }
        }
    }
    
    fun setFilter(filter: FilterType) {
        _filterType.value = filter
    }
    
    fun getStatistics(): TodoStatistics {
        val currentState = _uiState.value
        if (currentState is TodoListUiState.Success) {
            val todos = currentState.todos
            return TodoStatistics(
                total = todos.size,
                completed = todos.count { it.isCompleted },
                active = todos.count { !it.isCompleted }
            )
        }
        return TodoStatistics(0, 0, 0)
    }
}

// UI 상태 정의
sealed class TodoListUiState {
    object Loading : TodoListUiState()
    object Empty : TodoListUiState()
    data class Success(val todos: List<Todo>) : TodoListUiState()
    data class Error(val message: String) : TodoListUiState()
}

// 이벤트 정의
sealed class TodoListEvent {
    data class ShowSuccess(val message: String) : TodoListEvent()
    data class ShowError(val message: String) : TodoListEvent()
    data class NavigateToDetail(val todoId: Long) : TodoListEvent()
}

// 필터 타입
enum class FilterType {
    ALL, ACTIVE, COMPLETED
}

// 통계 데이터
data class TodoStatistics(
    val total: Int,
    val completed: Int,
    val active: Int
)

@AndroidEntryPoint
class TodoListFragment : Fragment() {
    
    private var _binding: FragmentTodoListBinding? = null
    private val binding get() = _binding!!
    
    private val viewModel: TodoListViewModel by viewModels()
    private lateinit var todoAdapter: TodoAdapter
    
    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        _binding = FragmentTodoListBinding.inflate(inflater, container, false)
        return binding.root
    }
    
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        
        setupRecyclerView()
        setupListeners()
        observeViewModel()
    }
    
    private fun setupRecyclerView() {
        todoAdapter = TodoAdapter(
            onItemClick = { todo ->
                // 상세 화면으로 이동
            },
            onCheckClick = { todo ->
                viewModel.toggleTodoComplete(todo)
            },
            onDeleteClick = { todo ->
                showDeleteConfirmDialog(todo)
            }
        )
        
        binding.recyclerView.apply {
            adapter = todoAdapter
            layoutManager = LinearLayoutManager(context)
            addItemDecoration(
                DividerItemDecoration(context, DividerItemDecoration.VERTICAL)
            )
        }
    }
    
    private fun setupListeners() {
        binding.fabAdd.setOnClickListener {
            showAddTodoDialog()
        }
        
        binding.chipAll.setOnClickListener {
            viewModel.setFilter(FilterType.ALL)
        }
        
        binding.chipActive.setOnClickListener {
            viewModel.setFilter(FilterType.ACTIVE)
        }
        
        binding.chipCompleted.setOnClickListener {
            viewModel.setFilter(FilterType.COMPLETED)
        }
    }
    
    private fun observeViewModel() {
        viewLifecycleOwner.lifecycleScope.launch {
            viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
                // UI 상태 관찰
                launch {
                    viewModel.uiState.collect { state ->
                        when (state) {
                            is TodoListUiState.Loading -> showLoading()
                            is TodoListUiState.Empty -> showEmpty()
                            is TodoListUiState.Success -> showTodos(state.todos)
                            is TodoListUiState.Error -> showError(state.message)
                        }
                    }
                }
                
                // 필터 상태 관찰
                launch {
                    viewModel.filterType.collect { filter ->
                        updateFilterChips(filter)
                    }
                }
                
                // 이벤트 관찰
                launch {
                    viewModel.events.collect { event ->
                        when (event) {
                            is TodoListEvent.ShowSuccess -> {
                                showSnackbar(event.message, isError = false)
                            }
                            is TodoListEvent.ShowError -> {
                                showSnackbar(event.message, isError = true)
                            }
                            is TodoListEvent.NavigateToDetail -> {
                                // 상세 화면으로 이동
                            }
                        }
                    }
                }
            }
        }
    }
    
    private fun showLoading() {
        binding.apply {
            progressBar.isVisible = true
            recyclerView.isVisible = false
            emptyView.isVisible = false
        }
    }
    
    private fun showEmpty() {
        binding.apply {
            progressBar.isVisible = false
            recyclerView.isVisible = false
            emptyView.isVisible = true
        }
    }
    
    private fun showTodos(todos: List<Todo>) {
        binding.apply {
            progressBar.isVisible = false
            recyclerView.isVisible = true
            emptyView.isVisible = false
        }
        todoAdapter.submitList(todos)
        updateStatistics()
    }
    
    private fun showError(message: String) {
        binding.apply {
            progressBar.isVisible = false
            recyclerView.isVisible = false
            emptyView.isVisible = true
            emptyTextView.text = message
        }
    }
    
    private fun updateFilterChips(filter: FilterType) {
        binding.apply {
            chipAll.isChecked = filter == FilterType.ALL
            chipActive.isChecked = filter == FilterType.ACTIVE
            chipCompleted.isChecked = filter == FilterType.COMPLETED
        }
    }
    
    private fun updateStatistics() {
        val stats = viewModel.getStatistics()
        binding.statisticsTextView.text = 
            "전체: ${stats.total} | 완료: ${stats.completed} | 진행중: ${stats.active}"
    }
    
    private fun showAddTodoDialog() {
        val dialogView = layoutInflater.inflate(R.layout.dialog_add_todo, null)
        val titleEdit = dialogView.findViewById<EditText>(R.id.titleEditText)
        val descEdit = dialogView.findViewById<EditText>(R.id.descriptionEditText)
        val prioritySpinner = dialogView.findViewById<Spinner>(R.id.prioritySpinner)
        
        MaterialAlertDialogBuilder(requireContext())
            .setTitle("새 할 일 추가")
            .setView(dialogView)
            .setPositiveButton("추가") { _, _ ->
                val title = titleEdit.text.toString()
                val description = descEdit.text.toString()
                val priority = Priority.values()[prioritySpinner.selectedItemPosition]
                viewModel.addTodo(title, description, priority)
            }
            .setNegativeButton("취소", null)
            .show()
    }
    
    private fun showDeleteConfirmDialog(todo: Todo) {
        MaterialAlertDialogBuilder(requireContext())
            .setTitle("할 일 삭제")
            .setMessage("'${todo.title}'을(를) 삭제하시겠습니까?")
            .setPositiveButton("삭제") { _, _ ->
                viewModel.deleteTodo(todo)
            }
            .setNegativeButton("취소", null)
            .show()
    }
    
    private fun showSnackbar(message: String, isError: Boolean) {
        Snackbar.make(binding.root, message, Snackbar.LENGTH_SHORT)
            .setBackgroundTint(
                if (isError) 
                    ContextCompat.getColor(requireContext(), R.color.error)
                else 
                    ContextCompat.getColor(requireContext(), R.color.success)
            )
            .show()
    }
    
    override fun onDestroyView() {
        super.onDestroyView()
        _binding = null
    }
}

// RecyclerView Adapter
class TodoAdapter(
    private val onItemClick: (Todo) -> Unit,
    private val onCheckClick: (Todo) -> Unit,
    private val onDeleteClick: (Todo) -> Unit
) : ListAdapter<Todo, TodoAdapter.TodoViewHolder>(TodoDiffCallback()) {
    
    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): TodoViewHolder {
        val binding = ItemTodoBinding.inflate(
            LayoutInflater.from(parent.context),
            parent,
            false
        )
        return TodoViewHolder(binding)
    }
    
    override fun onBindViewHolder(holder: TodoViewHolder, position: Int) {
        holder.bind(getItem(position))
    }
    
    inner class TodoViewHolder(
        private val binding: ItemTodoBinding
    ) : RecyclerView.ViewHolder(binding.root) {
        
        fun bind(todo: Todo) {
            binding.apply {
                titleTextView.text = todo.title
                descriptionTextView.text = todo.description
                checkBox.isChecked = todo.isCompleted
                
                // 완료된 항목은 취소선
                titleTextView.paintFlags = if (todo.isCompleted) {
                    titleTextView.paintFlags or Paint.STRIKE_THRU_TEXT_FLAG
                } else {
                    titleTextView.paintFlags and Paint.STRIKE_THRU_TEXT_FLAG.inv()
                }
                
                // 우선순위 표시
                priorityIndicator.setBackgroundColor(
                    when (todo.priority) {
                        Priority.HIGH -> Color.RED
                        Priority.MEDIUM -> Color.YELLOW
                        Priority.LOW -> Color.GREEN
                    }
                )
                
                root.setOnClickListener { onItemClick(todo) }
                checkBox.setOnClickListener { onCheckClick(todo) }
                deleteButton.setOnClickListener { onDeleteClick(todo) }
            }
        }
    }
    
    class TodoDiffCallback : DiffUtil.ItemCallback<Todo>() {
        override fun areItemsTheSame(oldItem: Todo, newItem: Todo): Boolean {
            return oldItem.id == newItem.id
        }
        
        override fun areContentsTheSame(oldItem: Todo, newItem: Todo): Boolean {
            return oldItem == newItem
        }
    }
}

class TodoListViewModelTest {
    
    // 테스트용 코루틴 디스패처
    @get:Rule
    val mainDispatcherRule = MainDispatcherRule()
    
    // 테스트용 Repository (Fake 구현)
    private lateinit var fakeRepository: FakeTodoRepository
    private lateinit var viewModel: TodoListViewModel
    
    @Before
    fun setup() {
        fakeRepository = FakeTodoRepository()
        viewModel = TodoListViewModel(fakeRepository)
    }
    
    @Test
    fun `초기 상태는 Loading이어야 한다`() = runTest {
        // Given: ViewModel이 생성됨
        
        // When: 초기 상태 확인
        val initialState = viewModel.uiState.value
        
        // Then: Loading 상태여야 함
        assertTrue(initialState is TodoListUiState.Loading)
    }
    
    @Test
    fun `할 일이 없으면 Empty 상태를 보여준다`() = runTest {
        // Given: 빈 Repository
        fakeRepository.clearTodos()
        
        // When: ViewModel 생성
        val viewModel = TodoListViewModel(fakeRepository)
        advanceUntilIdle()
        
        // Then: Empty 상태
        assertTrue(viewModel.uiState.value is TodoListUiState.Empty)
    }
    
    @Test
    fun `할 일 추가가 성공하면 Success 이벤트를 발생시킨다`() = runTest {
        // Given: 유효한 할 일 정보
        val title = "테스트 할 일"
        val description = "테스트 설명"
        
        // When: 할 일 추가
        val events = mutableListOf<TodoListEvent>()
        val job = launch {
            viewModel.events.collect { events.add(it) }
        }
        
        viewModel.addTodo(title, description, Priority.MEDIUM)
        advanceUntilIdle()
        
        // Then: Success 이벤트 발생
        assertTrue(events.any { it is TodoListEvent.ShowSuccess })
        job.cancel()
    }
    
    @Test
    fun `제목이 비어있으면 Error 이벤트를 발생시킨다`() = runTest {
        // Given: 빈 제목
        val title = ""
        val description = "설명"
        
        // When: 할 일 추가 시도
        val events = mutableListOf<TodoListEvent>()
        val job = launch {
            viewModel.events.collect { events.add(it) }
        }
        
        viewModel.addTodo(title, description, Priority.MEDIUM)
        advanceUntilIdle()
        
        // Then: Error 이벤트 발생
        assertTrue(events.any { it is TodoListEvent.ShowError })
        job.cancel()
    }
    
    @Test
    fun `할 일 완료 토글이 정상 동작한다`() = runTest {
        // Given: 미완료 할 일
        val todo = Todo(
            id = 1,
            title = "테스트",
            description = "설명",
            isCompleted = false
        )
        fakeRepository.addTodo(todo)
        
        // When: 완료 토글
        viewModel.toggleTodoComplete(todo)
        advanceUntilIdle()
        
        // Then: 상태가 변경됨
        val updatedTodo = fakeRepository.getTodoById(1)
        assertTrue(updatedTodo?.isCompleted == true)
    }
    
    @Test
    fun `필터링이 정상 동작한다`() = runTest {
        // Given: 완료/미완료 할 일들
        fakeRepository.addTodo(Todo(1, "할 일 1", "", false))
        fakeRepository.addTodo(Todo(2, "할 일 2", "", true))
        fakeRepository.addTodo(Todo(3, "할 일 3", "", false))
        
        val viewModel = TodoListViewModel(fakeRepository)
        advanceUntilIdle()
        
        // When: ACTIVE 필터 적용
        viewModel.setFilter(FilterType.ACTIVE)
        advanceUntilIdle()
        
        // Then: 미완료 항목만 표시
        val state = viewModel.uiState.value
        assertTrue(state is TodoListUiState.Success)
        assertEquals(2, (state as TodoListUiState.Success).todos.size)
        assertTrue(state.todos.all { !it.isCompleted })
    }
    
    @Test
    fun `통계가 정확하게 계산된다`() = runTest {
        // Given: 여러 할 일들
        fakeRepository.addTodo(Todo(1, "할 일 1", "", false))
        fakeRepository.addTodo(Todo(2, "할 일 2", "", true))
        fakeRepository.addTodo(Todo(3, "할 일 3", "", true))
        
        val viewModel = TodoListViewModel(fakeRepository)
        advanceUntilIdle()
        
        // When: 통계 조회
        val stats = viewModel.getStatistics()
        
        // Then: 정확한 통계
        assertEquals(3, stats.total)
        assertEquals(2, stats.completed)
        assertEquals(1, stats.active)
    }
}

// Fake Repository 구현
class FakeTodoRepository : TodoRepository {
    private val todos = mutableListOf<Todo>()
    private val todosFlow = MutableStateFlow<List<Todo>>(emptyList())
    
    override fun getAllTodos(): Flow<List<Todo>> = todosFlow
    
    override suspend fun getTodoById(id: Long): Todo? {
        return todos.find { it.id == id }
    }
    
    override suspend fun insertTodo(todo: Todo): Long {
        val newTodo = todo.copy(id = todos.size.toLong() + 1)
        todos.add(newTodo)
        todosFlow.value = todos.toList()
        return newTodo.id
    }
    
    override suspend fun updateTodo(todo: Todo) {
        val index = todos.indexOfFirst { it.id == todo.id }
        if (index != -1) {
            todos[index] = todo
            todosFlow.value = todos.toList()
        }
    }
    
    override suspend fun deleteTodo(todo: Todo) {
        todos.removeIf { it.id == todo.id }
        todosFlow.value = todos.toList()
    }
    
    override fun getActiveTodos(): Flow<List<Todo>> {
        return todosFlow.map { it.filter { todo -> !todo.isCompleted } }
    }
    
    override fun getCompletedTodos(): Flow<List<Todo>> {
        return todosFlow.map { it.filter { todo -> todo.isCompleted } }
    }
    
    fun addTodo(todo: Todo) {
        todos.add(todo)
        todosFlow.value = todos.toList()
    }
    
    fun clearTodos() {
        todos.clear()
        todosFlow.value = emptyList()
    }
}

// 테스트용 Coroutine Rule
class MainDispatcherRule(
    private val dispatcher: TestDispatcher = StandardTestDispatcher()
) : TestWatcher() {
    
    override fun starting(description: Description) {
        Dispatchers.setMain(dispatcher)
    }
    
    override fun finished(description: Description) {
        Dispatchers.resetMain()
    }
}

class OptimizedViewModel : ViewModel() {
    
    // ❌ 나쁜 예: 불필요한 재구성
    private val _state = MutableStateFlow(UiState())
    val state = _state.asStateFlow()
    
    // ✅ 좋은 예: distinctUntilChanged로 중복 제거
    val optimizedState = _state
        .distinctUntilChanged()
        .stateIn(
            scope = viewModelScope,
            started = SharingStarted.WhileSubscribed(5000),
            initialValue = UiState()
        )
    
    // ✅ 좋은 예: 여러 Flow를 효율적으로 결합
    val combinedState = combine(
        userFlow,
        settingsFlow,
        notificationsFlow
    ) { user, settings, notifications ->
        CombinedState(user, settings, notifications)
    }.stateIn(
        scope = viewModelScope,
        started = SharingStarted.WhileSubscribed(5000),
        initialValue = CombinedState.Empty
    )
}

class SafeFragment : Fragment() {
    
    // ✅ ViewBinding 안전하게 사용
    private var _binding: FragmentSafeBinding? = null
    private val binding get() = _binding!!
    
    // ✅ ViewModel은 by viewModels()로 안전하게 생성
    private val viewModel: SafeViewModel by viewModels()
    
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        
        // ✅ viewLifecycleOwner 사용 (Fragment의 생명주기와 연동)
        viewLifecycleOwner.lifecycleScope.launch {
            // ✅ repeatOnLifecycle로 생명주기 인식
            viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
                viewModel.state.collect { state ->
                    updateUI(state)
                }
            }
        }
        
        // ❌ 나쁜 예: lifecycleScope 직접 사용
        // lifecycleScope.launch {
        //     viewModel.state.collect { state ->
        //         updateUI(state)
        //     }
        // }
    }
    
    override fun onDestroyView() {
        super.onDestroyView()
        // ✅ ViewBinding 해제로 메모리 누수 방지
        _binding = null
    }
}

class SafeViewModel : ViewModel() {
    
    // ✅ viewModelScope 사용 (자동 취소)
    fun loadData() {
        viewModelScope.launch {
            // ViewModel이 소멸되면 자동으로 취소됨
            repository.getData().collect { data ->
                _state.value = data
            }
        }
    }
    
    // ❌ 나쁜 예: GlobalScope 사용
    // fun loadDataBad() {
    //     GlobalScope.launch {
    //         // 절대 취소되지 않음!
    //     }
    // }
}

class EventViewModel : ViewModel() {
    
    // ❌ 나쁜 예: StateFlow로 이벤트 처리
    private val _navigationEvent = MutableStateFlow<NavigationEvent?>(null)
    val navigationEvent = _navigationEvent.asStateFlow()
    // 문제: 화면 회전 시 이벤트가 다시 발생함
    
    // ✅ 좋은 예: SharedFlow로 이벤트 처리
    private val _events = MutableSharedFlow<UiEvent>()
    val events = _events.asSharedFlow()
    
    fun navigateToDetail() {
        viewModelScope.launch {
            _events.emit(UiEvent.NavigateToDetail)
        }
    }
    
    // ✅ 더 좋은 예: Channel 사용 (버퍼링 제어 가능)
    private val _eventChannel = Channel<UiEvent>(Channel.BUFFERED)
    val eventFlow = _eventChannel.receiveAsFlow()
    
    fun showMessage(message: String) {
        viewModelScope.launch {
            _eventChannel.send(UiEvent.ShowMessage(message))
        }
    }
}

// Fragment에서 이벤트 수집
class EventFragment : Fragment() {
    
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        
        viewLifecycleOwner.lifecycleScope.launch {
            viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
                viewModel.events.collect { event ->
                    when (event) {
                        is UiEvent.ShowMessage -> {
                            Toast.makeText(context, event.message, Toast.LENGTH_SHORT).show()
                        }
                        is UiEvent.NavigateToDetail -> {
                            findNavController().navigate(R.id.detailFragment)
                        }
                    }
                }
            }
        }
    }
}

class SavedStateViewModel(
    private val savedStateHandle: SavedStateHandle
) : ViewModel() {
    
    // ✅ SavedStateHandle로 상태 저장
    var searchQuery: String
        get() = savedStateHandle.get<String>("search_query") ?: ""
        set(value) {
            savedStateHandle["search_query"] = value
        }
    
    // ✅ StateFlow와 연동
    val searchQueryFlow: StateFlow<String> = savedStateHandle
        .getStateFlow("search_query", "")
    
    // ✅ 복잡한 객체도 저장 가능 (Parcelable)
    var userProfile: UserProfile?
        get() = savedStateHandle.get<UserProfile>("user_profile")
        set(value) {
            savedStateHandle["user_profile"] = value
        }
    
    fun updateSearchQuery(query: String) {
        searchQuery = query
        // 자동으로 SavedStateHandle에 저장됨
        performSearch(query)
    }
    
    private fun performSearch(query: String) {
        viewModelScope.launch {
            // 검색 로직
        }
    }
}

class OptimizedRepository(
    private val apiService: ApiService,
    private val database: AppDatabase,
    private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO
) {
    
    // ✅ Single Source of Truth 패턴
    fun getUsers(): Flow<List<User>> = flow {
        // 1. 먼저 로컬 DB에서 데이터 emit
        val localUsers = database.userDao().getAllUsers()
        emit(localUsers)
        
        // 2. 네트워크에서 최신 데이터 가져오기
        try {
            val remoteUsers = apiService.getUsers()
            // 3. DB 업데이트
            database.userDao().insertAll(remoteUsers)
            // 4. 업데이트된 데이터 emit
            emit(remoteUsers)
        } catch (e: Exception) {
            // 네트워크 오류 시 로컬 데이터 유지
        }
    }.flowOn(ioDispatcher)
    
    // ✅ 캐싱 전략
    private val userCache = mutableMapOf<Int, User>()
    private val cacheTimeout = 5.minutes
    
    suspend fun getUserById(userId: Int): User {
        // 캐시 확인
        userCache[userId]?.let { cachedUser ->
            if (System.currentTimeMillis() - cachedUser.cachedAt < cacheTimeout.inWholeMilliseconds) {
                return cachedUser
            }
        }
        
        // 캐시 미스 - DB 확인
        database.userDao().getUserById(userId)?.let { return it }
        
        // DB 미스 - API 호출
        return apiService.getUser(userId).also { user ->
            userCache[userId] = user
            database.userDao().insert(user)
        }
    }
    
    // ✅ 에러 핸들링
    suspend fun updateUser(user: User): Result<Unit> = withContext(ioDispatcher) {
        try {
            // 낙관적 업데이트
            database.userDao().update(user)
            
            // 서버 동기화
            val response = apiService.updateUser(user)
            if (response.isSuccessful) {
                Result.success(Unit)
            } else {
                // 실패 시 롤백
                database.userDao().update(user.copy(/* 이전 상태 */))
                Result.failure(Exception("Update failed"))
            }
        } catch (e: Exception) {
            Result.failure(e)
        }
    }
}

// Intent: 사용자의 의도를 나타냄
sealed class TodoIntent {
    object LoadTodos : TodoIntent()
    data class AddTodo(val title: String, val description: String) : TodoIntent()
    data class ToggleTodo(val id: Long) : TodoIntent()
    data class DeleteTodo(val id: Long) : TodoIntent()
    data class FilterTodos(val filter: FilterType) : TodoIntent()
}

// State: UI의 전체 상태
data class TodoViewState(
    val todos: List<Todo> = emptyList(),
    val isLoading: Boolean = false,
    val error: String? = null,
    val filter: FilterType = FilterType.ALL
) {
    val filteredTodos: List<Todo>
        get() = when (filter) {
            FilterType.ALL -> todos
            FilterType.ACTIVE -> todos.filter { !it.isCompleted }
            FilterType.COMPLETED -> todos.filter { it.isCompleted }
        }
}

// ViewModel with MVI
class MviTodoViewModel(
    private val repository: TodoRepository
) : ViewModel() {
    
    private val _state = MutableStateFlow(TodoViewState())
    val state: StateFlow<TodoViewState> = _state.asStateFlow()
    
    // Intent를 처리하는 단일 진입점
    fun processIntent(intent: TodoIntent) {
        when (intent) {
            is TodoIntent.LoadTodos -> loadTodos()
            is TodoIntent.AddTodo -> addTodo(intent.title, intent.description)
            is TodoIntent.ToggleTodo -> toggleTodo(intent.id)
            is TodoIntent.DeleteTodo -> deleteTodo(intent.id)
            is TodoIntent.FilterTodos -> filterTodos(intent.filter)
        }
    }
    
    private fun loadTodos() {
        viewModelScope.launch {
            _state.update { it.copy(isLoading = true, error = null) }
            
            repository.getAllTodos()
                .catch { exception ->
                    _state.update { 
                        it.copy(
                            isLoading = false,
                            error = exception.message
                        )
                    }
                }
                .collect { todos ->
                    _state.update { 
                        it.copy(
                            todos = todos,
                            isLoading = false,
                            error = null
                        )
                    }
                }
        }
    }
    
    private fun addTodo(title: String, description: String) {
        viewModelScope.launch {
            try {
                val todo = Todo(title = title, description = description)
                repository.insertTodo(todo)
            } catch (e: Exception) {
                _state.update { it.copy(error = e.message) }
            }
        }
    }
    
    private fun toggleTodo(id: Long) {
        viewModelScope.launch {
            val todo = _state.value.todos.find { it.id == id } ?: return@launch
            repository.updateTodo(todo.copy(isCompleted = !todo.isCompleted))
        }
    }
    
    private fun deleteTodo(id: Long) {
        viewModelScope.launch {
            val todo = _state.value.todos.find { it.id == id } ?: return@launch
            repository.deleteTodo(todo)
        }
    }
    
    private fun filterTodos(filter: FilterType) {
        _state.update { it.copy(filter = filter) }
    }
}

// Fragment에서 사용
class MviTodoFragment : Fragment() {
    private val viewModel: MviTodoViewModel by viewModels()
    
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        
        // Intent 전송
        binding.addButton.setOnClickListener {
            val title = binding.titleEdit.text.toString()
            val description = binding.descEdit.text.toString()
            viewModel.processIntent(
                TodoIntent.AddTodo(title, description)
            )
        }
        
        binding.filterAllChip.setOnClickListener {
            viewModel.processIntent(TodoIntent.FilterTodos(FilterType.ALL))
        }
        
        // State 관찰
        viewLifecycleOwner.lifecycleScope.launch {
            viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
                viewModel.state.collect { state ->
                    render(state)
                }
            }
        }
        
        // 초기 로드
        viewModel.processIntent(TodoIntent.LoadTodos)
    }
    
    private fun render(state: TodoViewState) {
        binding.progressBar.isVisible = state.isLoading
        binding.errorText.text = state.error
        binding.errorText.isVisible = state.error != null
        todoAdapter.submitList(state.filteredTodos)
    }
}

// UseCase 인터페이스
interface UseCase<in P, out R> {
    suspend operator fun invoke(params: P): Result<R>
}

// 구체적인 UseCase 구현
class GetUserProfileUseCase(
    private val userRepository: UserRepository,
    private val settingsRepository: SettingsRepository,
    private val analyticsRepository: AnalyticsRepository
) : UseCase<GetUserProfileUseCase.Params, UserProfile> {
    
    data class Params(val userId: Int)
    
    override suspend fun invoke(params: Params): Result<UserProfile> {
        return try {
            // 1. 사용자 정보 가져오기
            val user = userRepository.getUser(params.userId)
                .getOrElse { return Result.failure(it) }
            
            // 2. 설정 정보 가져오기
            val settings = settingsRepository.getUserSettings(params.userId)
                .getOrElse { return Result.failure(it) }
            
            // 3. 분석 데이터 기록
            analyticsRepository.logProfileView(params.userId)
            
            // 4. 프로필 조합
            val profile = UserProfile(
                user = user,
                settings = settings,
                lastViewedAt = System.currentTimeMillis()
            )
            
            Result.success(profile)
        } catch (e: Exception) {
            Result.failure(e)
        }
    }
}

// Flow를 반환하는 UseCase
abstract class FlowUseCase<in P, out R> {
    operator fun invoke(params: P): Flow<R> = execute(params)
        .catch { e -> emit(handleError(e)) }
    
    protected abstract fun execute(params: P): Flow<R>
    
    protected open fun handleError(throwable: Throwable): R {
        throw throwable
    }
}

class ObserveUserTodosUseCase(
    private val todoRepository: TodoRepository
) : FlowUseCase<ObserveUserTodosUseCase.Params, List<Todo>>() {
    
    data class Params(val userId: Int, val filter: FilterType)
    
    override fun execute(params: Params): Flow<List<Todo>> {
        return todoRepository.getUserTodos(params.userId)
            .map { todos ->
                when (params.filter) {
                    FilterType.ALL -> todos
                    FilterType.ACTIVE -> todos.filter { !it.isCompleted }
                    FilterType.COMPLETED -> todos.filter { it.isCompleted }
                }
            }
    }
}

// ViewModel에서 UseCase 사용
class CleanArchitectureViewModel(
    private val getUserProfileUseCase: GetUserProfileUseCase,
    private val observeUserTodosUseCase: ObserveUserTodosUseCase,
    private val updateTodoUseCase: UpdateTodoUseCase
) : ViewModel() {
    
    private val _profileState = MutableStateFlow<UiState<UserProfile>>(UiState.Loading)
    val profileState = _profileState.asStateFlow()
    
    fun loadUserProfile(userId: Int) {
        viewModelScope.launch {
            _profileState.value = UiState.Loading
            
            getUserProfileUseCase(GetUserProfileUseCase.Params(userId))
                .onSuccess { profile ->
                    _profileState.value = UiState.Success(profile)
                }
                .onFailure { error ->
                    _profileState.value = UiState.Error(error.message ?: "Unknown error")
                }
        }
    }
    
    val todos: StateFlow<List<Todo>> = observeUserTodosUseCase(
        ObserveUserTodosUseCase.Params(
            userId = 1,
            filter = FilterType.ALL
        )
    ).stateIn(
        scope = viewModelScope,
        started = SharingStarted.WhileSubscribed(5000),
        initialValue = emptyList()
    )
}

// Application 클래스
@HiltAndroidApp
class TodoApplication : Application()

// Module 정의
@Module
@InstallIn(SingletonComponent::class)
object DatabaseModule {
    
    @Provides
    @Singleton
    fun provideDatabase(@ApplicationContext context: Context): TodoDatabase {
        return Room.databaseBuilder(
            context,
            TodoDatabase::class.java,
            "todo_database"
        ).build()
    }
    
    @Provides
    fun provideTodoDao(database: TodoDatabase): TodoDao {
        return database.todoDao()
    }
}

@Module
@InstallIn(SingletonComponent::class)
object RepositoryModule {
    
    @Provides
    @Singleton
    fun provideTodoRepository(
        todoDao: TodoDao,
        apiService: ApiService
    ): TodoRepository {
        return TodoRepositoryImpl(todoDao, apiService)
    }
}

@Module
@InstallIn(ViewModelComponent::class)
object UseCaseModule {
    
    @Provides
    fun provideGetUserProfileUseCase(
        userRepository: UserRepository,
        settingsRepository: SettingsRepository,
        analyticsRepository: AnalyticsRepository
    ): GetUserProfileUseCase {
        return GetUserProfileUseCase(
            userRepository,
            settingsRepository,
            analyticsRepository
        )
    }
}

// ViewModel에 주입
@HiltViewModel
class HiltTodoViewModel @Inject constructor(
    private val todoRepository: TodoRepository,
    private val getUserProfileUseCase: GetUserProfileUseCase,
    @IoDispatcher private val ioDispatcher: CoroutineDispatcher
) : ViewModel() {
    // ViewModel 구현
}

// Fragment에서 사용
@AndroidEntryPoint
class HiltTodoFragment : Fragment() {
    
    private val viewModel: HiltTodoViewModel by viewModels()
    
    // 추가 의존성도 주입 가능
    @Inject
    lateinit var analytics: Analytics
    
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        // ViewModel 사용
    }
}

// 1단계: Repository 계층 추가
// 기존 코드를 건드리지 않고 Repository만 먼저 만들기
class UserRepository {
    fun getUser(): User {
        // 기존 코드를 여기로 옮김
        return ApiClient.getUser()
    }
}

// 2단계: ViewModel 추가
// Activity/Fragment의 로직을 ViewModel로 이동
class UserViewModel(
    private val repository: UserRepository
) : ViewModel() {
    private val _user = MutableLiveData<User>()
    val user: LiveData<User> = _user
    
    fun loadUser() {
        viewModelScope.launch {
            _user.value = repository.getUser()
        }
    }
}

// 3단계: Activity/Fragment 리팩토링
// 기존 Activity를 점진적으로 수정
class UserActivity : AppCompatActivity() {
    
    // 기존 코드는 유지하면서 ViewModel 추가
    private val viewModel: UserViewModel by viewModels()
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        // 새로운 방식으로 데이터 로드
        viewModel.user.observe(this) { user ->
            updateUI(user)
        }
        viewModel.loadUser()
        
        // 기존 코드는 주석 처리하고 나중에 제거
        // loadUserOldWay()
    }
}

// 4단계: 테스트 추가
// 새로 만든 ViewModel과 Repository에 테스트 작성

// 5단계: 기존 코드 제거
// 모든 게 잘 동작하면 기존 코드 삭제

// 공식 문서
• Android Developers - Guide to app architecture
  https://developer.android.com/topic/architecture

• Kotlin Coroutines Guide
  https://kotlinlang.org/docs/coroutines-guide.html

• Android Architecture Components
  https://developer.android.com/topic/libraries/architecture

// 오픈소스 프로젝트
• Google의 Architecture Samples
  https://github.com/android/architecture-samples

• Now in Android (Google 공식 샘플 앱)
  https://github.com/android/nowinandroid

// 유용한 라이브러리
• Hilt: https://dagger.dev/hilt/
• Room: https://developer.android.com/training/data-storage/room
• Retrofit: https://square.github.io/retrofit/
• Coil: https://coil-kt.github.io/coil/ (이미지 로딩)