package de.oaa.xxx.app.ui.viewmodel

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import de.oaa.xxx.app.data.api.ApiClient
import de.oaa.xxx.app.data.model.AufgabenGruppe
import de.oaa.xxx.app.data.model.AufgabenGruppeDisplay
import de.oaa.xxx.app.data.model.Toy
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.launch

class AufgabenViewModel : ViewModel() {

    private val _userGruppen = MutableStateFlow<List<AufgabenGruppeDisplay>>(emptyList())
    val userGruppen: StateFlow<List<AufgabenGruppeDisplay>> = _userGruppen

    private val _systemGruppen = MutableStateFlow<List<AufgabenGruppeDisplay>>(emptyList())
    val systemGruppen: StateFlow<List<AufgabenGruppeDisplay>> = _systemGruppen

    private val _subscriptions = MutableStateFlow<List<AufgabenGruppeDisplay>>(emptyList())
    val subscriptions: StateFlow<List<AufgabenGruppeDisplay>> = _subscriptions

    private val _selectedGruppe = MutableStateFlow<AufgabenGruppe?>(null)
    val selectedGruppe: StateFlow<AufgabenGruppe?> = _selectedGruppe

    private val _userToys = MutableStateFlow<List<Toy>>(emptyList())
    val userToys: StateFlow<List<Toy>> = _userToys

    private val _systemToys = MutableStateFlow<List<Toy>>(emptyList())
    val systemToys: StateFlow<List<Toy>> = _systemToys

    private val _isLoading = MutableStateFlow(false)
    val isLoading: StateFlow<Boolean> = _isLoading

    private val _error = MutableStateFlow<String?>(null)
    val error: StateFlow<String?> = _error

    fun loadUserGruppen() {
        viewModelScope.launch {
            _isLoading.value = true
            try {
                val resp = ApiClient.aufgabenApi.getUserGruppen()
                if (resp.isSuccessful) _userGruppen.value = resp.body() ?: emptyList()
                else _error.value = "Fehler beim Laden"
            } catch (e: Exception) {
                _error.value = e.message
            } finally {
                _isLoading.value = false
            }
        }
    }

    fun loadSystemGruppen() {
        viewModelScope.launch {
            _isLoading.value = true
            try {
                val resp = ApiClient.aufgabenApi.getSystemGruppen()
                if (resp.isSuccessful) _systemGruppen.value = resp.body() ?: emptyList()
                else _error.value = "Fehler beim Laden"
            } catch (e: Exception) {
                _error.value = e.message
            } finally {
                _isLoading.value = false
            }
        }
    }

    fun loadSubscriptions() {
        viewModelScope.launch {
            try {
                val resp = ApiClient.aufgabenApi.getAbonnements()
                if (resp.isSuccessful) _subscriptions.value = resp.body() ?: emptyList()
            } catch (e: Exception) {
                _error.value = e.message
            }
        }
    }

    fun loadGruppe(gruppenId: String) {
        viewModelScope.launch {
            _isLoading.value = true
            try {
                val resp = ApiClient.aufgabenApi.getGruppe(gruppenId)
                if (resp.isSuccessful) _selectedGruppe.value = resp.body()
                else _error.value = "Gruppe nicht gefunden"
            } catch (e: Exception) {
                _error.value = e.message
            } finally {
                _isLoading.value = false
            }
        }
    }

    fun loadToys() {
        viewModelScope.launch {
            try {
                val user = ApiClient.aufgabenApi.getUserToys()
                val system = ApiClient.aufgabenApi.getSystemToys()
                if (user.isSuccessful) _userToys.value = user.body() ?: emptyList()
                if (system.isSuccessful) _systemToys.value = system.body() ?: emptyList()
            } catch (e: Exception) {
                _error.value = e.message
            }
        }
    }

    fun copyGruppe(gruppenId: String, onSuccess: () -> Unit) {
        viewModelScope.launch {
            try {
                val resp = ApiClient.aufgabenApi.copyGruppe(gruppenId)
                if (resp.isSuccessful) {
                    loadUserGruppen()
                    onSuccess()
                }
            } catch (e: Exception) {
                _error.value = e.message
            }
        }
    }

    fun subscribe(gruppenId: String) {
        viewModelScope.launch {
            try {
                val resp = ApiClient.aufgabenApi.subscribe(gruppenId)
                if (resp.isSuccessful) loadSubscriptions()
            } catch (e: Exception) {
                _error.value = e.message
            }
        }
    }

    fun unsubscribe(gruppenId: String) {
        viewModelScope.launch {
            try {
                val resp = ApiClient.aufgabenApi.unsubscribe(gruppenId)
                if (resp.isSuccessful) loadSubscriptions()
            } catch (e: Exception) {
                _error.value = e.message
            }
        }
    }

    fun clearError() { _error.value = null }
}
