tailscale-android/android/src/main/java/com/tailscale/ipn/ui/viewModel/MainViewModel.kt

// Copyright (c) Tailscale Inc & AUTHORS
// SPDX-License-Identifier: BSD-3-Clause


package com.tailscale.ipn.ui.viewModel

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.tailscale.ipn.R
import com.tailscale.ipn.ui.model.Ipn.State
import com.tailscale.ipn.ui.model.StableNodeID
import com.tailscale.ipn.ui.service.IpnActions
import com.tailscale.ipn.ui.service.IpnModel
import com.tailscale.ipn.ui.service.set
import com.tailscale.ipn.ui.util.PeerCategorizer
import com.tailscale.ipn.ui.util.PeerSet
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.launch

class MainViewModel(val model: IpnModel, val actions: IpnActions) : ViewModel() {

    // The user readable state of the system
    val stateRes: StateFlow<Int> = MutableStateFlow(State.NoState.userStringRes())

    // The expected state of the VPN toggle
    val vpnToggleState: StateFlow<Boolean> = MutableStateFlow(false)

    // The list of peers
    val peers: StateFlow<List<PeerSet>> = MutableStateFlow(emptyList<PeerSet>())

    // The current state of the IPN for determining view visibility
    val ipnState = model.state

    // The logged in user
    val loggedInUser = model.loggedInUser

    // The active search term for filtering peers
    val searchTerm: StateFlow<String> = MutableStateFlow("")


    // The current peer ID
    val selfPeerId: StableNodeID
        get() = model.netmap.value?.SelfNode?.StableID ?: ""

    val peerCategorizer = PeerCategorizer(model, viewModelScope)

    init {
        viewModelScope.launch {
            model.state.collect { state ->
                stateRes.set(state.userStringRes())
                vpnToggleState.set((state == State.Running || state == State.Starting))
            }
        }

        viewModelScope.launch {
            model.netmap.collect { netmap ->
                peers.set(peerCategorizer.groupedAndFilteredPeers(searchTerm.value))
            }
        }
    }

    fun searchPeers(searchTerm: String) {
        this.searchTerm.set(searchTerm)
        viewModelScope.launch {
            peers.set(peerCategorizer.groupedAndFilteredPeers(searchTerm))
        }
    }

    val userName: String
        get() {
            return loggedInUser.value?.Name ?: ""
        }

    fun toggleVpn() {
        when (model.state.value) {
            State.Running -> actions.stopVPN()
            else -> actions.startVPN()
        }
    }

    fun login() {
        actions.login()
    }

}

private fun State?.userStringRes(): Int {
    return when (this) {
        State.NoState -> R.string.waiting
        State.InUseOtherUser -> R.string.placeholder
        State.NeedsLogin -> R.string.please_login
        State.NeedsMachineAuth -> R.string.placeholder
        State.Stopped -> R.string.stopped
        State.Starting -> R.string.starting
        State.Running -> R.string.connected
        else -> R.string.placeholder
    }
}