// ExtensionsDataStore.kt
private const val USER_DATA_STORAGE = "user_data.pb"

val Context.userDataStore: DataStore<UserData> by dataStore(
    fileName = USER_DATA_STORAGE,
    serializer = UserDataSerializer
)

//
interface UserData {
    /**
     * Watch info stored insight DataStore
     */
    val watchUserData: Flow<UserData>

    /**
     * Write auth cookie to DataStore
     */
    suspend fun updateAuthCookie(authCookie: String)

    /**
     * Set info Light or Dark theme
     */
    suspend fun updateAppTheme(isDarkTheme: Boolean = false)

    /**
     * Clear DataStore info
     */
    suspend fun clearDataStore()
    suspend fun clearAuthCookie()
    suspend fun clearAppTheme()
}

// UserDataRepository.kt
class UserDataRepository(
    private val userDataPreferences: DataStore<bz.lement.pro.proto.UserData>
) : UserData {

    override val watchUserData: Flow<bz.lement.pro.proto.UserData>
        get() = userDataPreferences
            .data
            .catch { exception ->
                // dataStore.data throws an IOException when an error is encountered when reading data
                if (exception is IOException) emit(bz.lement.pro.proto.UserData.getDefaultInstance())
                else throw exception
            }

    override suspend fun updateAuthCookie(authCookie: String) {
        userDataPreferences.updateData { preferences ->
            preferences.toBuilder().setCookieAuth(authCookie).build()
        }
    }

    override suspend fun updateAppTheme(isDarkTheme: Boolean) {
        userDataPreferences.updateData { preferences ->
            preferences.toBuilder().setAppTheme(isDarkTheme).build()
        }
    }

    override suspend fun clearDataStore() {
        userDataPreferences.updateData { preferences ->
            preferences.toBuilder().clear().build()
        }
    }

    override suspend fun clearAuthCookie() {
        userDataPreferences.updateData { preferences ->
            preferences.toBuilder().clearCookieAuth().build()
        }
    }

    override suspend fun clearAppTheme() {
        userDataPreferences.updateData { preferences ->
            preferences.toBuilder().clearAppTheme().build()
        }
    }
}

// Koin modules
val repositoryModule = module {
    single { provideUserDataStore(context = androidContext()) }
    single<UserData> { UserDataRepository(userDataPreferences = get()) }
}

//
val viewModelModule = module {
    viewModel { SplashVM(dataStore = get()) }
}

// ViewModel
class SplashVM(
    private val dataStore: UserDataRepository
) : ViewModel() {

    val watchAuthCookies: Flow<String>
        get() = _authCookie

    private val _authCookie = MutableSharedFlow<String>()

    init {
        viewModelScope.launch {
            launch {
                dataStore
                    .watchUserData
                    .collect { data ->
                        _authCookie.emit(data.cookieAuth)
                    }
            }
        }
    }
}

// Activity
class SplashActivity : ComponentActivity() {

    private val viewModel by inject<SplashVM>()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            SplashScreenTheme {
                // A surface container using the 'background' color from the theme
                Surface(color = MaterialTheme.colors.background) {
                    SplashCL()
                }
            }
        }

        lifecycleScope.launch {
            delay(SPLASH_TIME_OUT)
            viewModel.watchAuthCookies.collect {

            }
        }
    }
}