Android/app/src/main/java/com/eatssu/android/presentation/MainViewModel.kt at 38a80f45014464441a1e8f9f8bb1dc2b7bb5f537 · EAT-SSU/Android · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
package com.eatssu.android.presentation

import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.eatssu.android.R
import com.eatssu.android.domain.repository.UserRepository
import com.eatssu.android.domain.usecase.auth.LogoutUseCase
import com.eatssu.android.domain.usecase.user.GetUserCollegeDepartmentUseCase
import com.eatssu.android.domain.usecase.user.GetUserNickNameUseCase
import com.eatssu.android.domain.usecase.user.SetUserCollegeDepartmentUseCase
import com.eatssu.common.UiEvent
import com.eatssu.common.UiState
import com.eatssu.common.UiText
import com.eatssu.common.enums.ToastType
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.SharedFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch
import timber.log.Timber
import java.time.LocalDate
import javax.inject.Inject

@HiltViewModel
class MainViewModel @Inject constructor(
    private val logoutUseCase: LogoutUseCase,
    private val getUserNickNameUseCase: GetUserNickNameUseCase,
    private val setUserCollegeDepartmentUseCase: SetUserCollegeDepartmentUseCase,
    private val userRepository: UserRepository,
    private val getUserCollegeDepartmentUseCase: GetUserCollegeDepartmentUseCase
) : ViewModel() {

    private val _uiState: MutableStateFlow<UiState<MainState>> = MutableStateFlow(UiState.Init)
    val uiState: StateFlow<UiState<MainState>> = _uiState.asStateFlow()

    private val _uiEvent = MutableSharedFlow<UiEvent>()
    val uiEvent: SharedFlow<UiEvent> = _uiEvent

    init {
        loadStoredUserDepartment()
        getUserDepartment()
        fetchAndCheckNickname()
    }

    fun refreshUserDepartment() {
        viewModelScope.launch {
            val userInfo = getUserCollegeDepartmentUseCase()
            _uiState.value = UiState.Success(
                MainState.DepartmentState(
                    departmentName = userInfo.userDepartment.departmentName
                )
            )
        }
    }

    private fun fetchAndCheckNickname() {
        viewModelScope.launch {
            _uiState.value = UiState.Loading

            val nickname = getUserNickNameUseCase()

            // 1) 닉네임 없음
            if (nickname.isBlank()) {
                _uiState.value = UiState.Success(MainState.NicknameNull)
                _uiEvent.emit(UiEvent.ShowToast(UiText.StringResource(R.string.set_nickname), ToastType.ERROR))
                return@launch
            }

            // 2) 정상 닉네임
            _uiState.value = UiState.Success(MainState.NicknameExists(nickname))
        }
    }

    fun logOut() {
        viewModelScope.launch {
            logoutUseCase()
            _uiState.value = UiState.Success(MainState.LoggedOut)
            _uiEvent.emit(
                UiEvent.ShowToast(
                    UiText.StringResource(R.string.toast_logout_success), ToastType.SUCCESS
                )
            )
        }
    }

    private val data = MutableLiveData<LocalDate>()

    fun setData(dataToSend: LocalDate) {
        data.value = dataToSend

        Timber.d("setdata $dataToSend")
    }

    fun getData(): LiveData<LocalDate> {
        return data
    }

    private fun loadStoredUserDepartment() {
        viewModelScope.launch {
            val userInfo = getUserCollegeDepartmentUseCase()
            _uiState.value = UiState.Success(
                MainState.DepartmentState(
                    departmentName = userInfo.userDepartment.departmentName,
                    showUserDepartmentBottomSheet =
                        (userInfo.userCollege.collegeId == -1 || userInfo.userDepartment.departmentId == -1)
                )
            )
        }
    }

    private fun getUserDepartment() {
        viewModelScope.launch {
            val (college, department) = userRepository.getUserCollegeDepartment() ?: run {
                _uiState.value = UiState.Error
                _uiEvent.emit(
                    UiEvent.ShowToast(
                        UiText.StringResource(R.string.not_found),
                        ToastType.ERROR
                    )
                )
                return@launch
            }

            setUserCollegeDepartmentUseCase(college, department)

            _uiState.value = UiState.Success(
                MainState.DepartmentState(
                    departmentName = department.departmentName,
                    showUserDepartmentBottomSheet =
                        (college.collegeId == -1 || department.departmentId == -1)
                )
            )
        }
    }
}


sealed class MainState {
    object NicknameNull : MainState()
    data class NicknameExists(val nickname: String) : MainState()
    object LoggedOut : MainState()
    data class DepartmentState(
        val departmentName: String? = "",
        val showUserDepartmentBottomSheet: Boolean = false
    ) : MainState()
}