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.AufgabeAnzeige
import de.oaa.xxx.app.data.model.AufgabenGruppenRef
import de.oaa.xxx.app.data.model.AufgabenList
import de.oaa.xxx.app.data.model.Mitspieler
import de.oaa.xxx.app.data.model.Session
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.launch

class SessionViewModel : ViewModel() {

    private val _session = MutableStateFlow<Session?>(null)
    val session: StateFlow<Session?> = _session

    private val _currentAufgabe = MutableStateFlow<AufgabeAnzeige?>(null)
    val currentAufgabe: StateFlow<AufgabeAnzeige?> = _currentAufgabe

    private val _finisherList = MutableStateFlow<List<AufgabeAnzeige>>(emptyList())
    val finisherList: StateFlow<List<AufgabeAnzeige>> = _finisherList

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

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

    fun loadSession(userId: String) {
        viewModelScope.launch {
            _isLoading.value = true
            try {
                val resp = ApiClient.sessionApi.getByUserId(userId)
                _session.value = if (resp.isSuccessful) resp.body() else null
            } catch (e: Exception) {
                _error.value = e.message
            } finally {
                _isLoading.value = false
            }
        }
    }

    fun createSession(
        aufgabenProLevel: Int,
        wahrscheinlichkeitSperre: Int,
        wahrscheinlichkeitStrafe: Int,
        zeitfaktor: Double,
        onSuccess: () -> Unit
    ) {
        viewModelScope.launch {
            _isLoading.value = true
            try {
                val s = Session(
                    aufgabenProLevel = aufgabenProLevel,
                    wahrscheinlichkeitSperre = wahrscheinlichkeitSperre,
                    wahrscheinlichkeitStrafe = wahrscheinlichkeitStrafe,
                    zeitfaktorZeitstrafen = zeitfaktor
                )
                val resp = ApiClient.sessionApi.createSession(s)
                if (resp.isSuccessful) onSuccess()
                else _error.value = "Session konnte nicht erstellt werden"
            } catch (e: Exception) {
                _error.value = e.message
            } finally {
                _isLoading.value = false
            }
        }
    }

    fun setAufgaben(sessionId: String, gruppenRefs: List<AufgabenGruppenRef>, onSuccess: () -> Unit) {
        viewModelScope.launch {
            _isLoading.value = true
            try {
                val resp = ApiClient.sessionApi.setAufgaben(sessionId, AufgabenList(gruppenRefs))
                if (resp.isSuccessful) onSuccess()
                else _error.value = "Aufgaben konnten nicht gesetzt werden"
            } catch (e: Exception) {
                _error.value = e.message
            } finally {
                _isLoading.value = false
            }
        }
    }

    fun getNextAufgabe(sessionId: String) {
        viewModelScope.launch {
            _isLoading.value = true
            try {
                val resp = ApiClient.sessionApi.getNextAufgabe(sessionId)
                _currentAufgabe.value = if (resp.isSuccessful) resp.body() else null
                if (resp.code() == 204) {
                    // Session finished - load finisher
                    loadFinisher(sessionId)
                }
            } catch (e: Exception) {
                _error.value = e.message
            } finally {
                _isLoading.value = false
            }
        }
    }

    fun addMitspieler(sessionId: String, mitspieler: Mitspieler, onSuccess: () -> Unit) {
        viewModelScope.launch {
            _isLoading.value = true
            try {
                val resp = ApiClient.sessionApi.addMitspieler(sessionId, mitspieler)
                if (resp.isSuccessful) onSuccess()
                else _error.value = "Mitspieler konnte nicht hinzugefügt werden"
            } catch (e: Exception) {
                _error.value = e.message
            } finally {
                _isLoading.value = false
            }
        }
    }

    fun loadFinisher(sessionId: String) {
        viewModelScope.launch {
            try {
                val resp = ApiClient.sessionApi.getFinisher(sessionId)
                _finisherList.value = if (resp.isSuccessful) resp.body() ?: emptyList() else emptyList()
            } catch (e: Exception) {
                _error.value = e.message
            }
        }
    }

    fun deleteSession(session: Session, onSuccess: () -> Unit) {
        viewModelScope.launch {
            _isLoading.value = true
            try {
                val resp = ApiClient.sessionApi.deleteSession(session)
                if (resp.isSuccessful) {
                    _session.value = null
                    _currentAufgabe.value = null
                    _finisherList.value = emptyList()
                    onSuccess()
                } else {
                    _error.value = "Session konnte nicht beendet werden"
                }
            } catch (e: Exception) {
                _error.value = e.message
            } finally {
                _isLoading.value = false
            }
        }
    }

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