chore: refactor TurnierDetailScreen and related components, remove unused parameters, centralize date validation logic, implement TurnierStammdatenViewModel, and eliminate reflection dependencies

frontend/features/turnier-feature/src/jvmMain/kotlin/at/mocode/frontend/features/turnier/di/TurnierFeatureModule.kt

@@ -23,6 +23,7 @@ actual val turnierFeatureModule = module {
 
   // ViewModels
   factory { TurnierViewModel(repo = get()) }
+  factory { TurnierStammdatenViewModel(repo = get()) }
   // BewerbViewModel: repos + syncManager + turnierId
   factory { (turnierId: Long) ->
     BewerbViewModel(

frontend/features/turnier-feature/src/jvmMain/kotlin/at/mocode/frontend/features/turnier/presentation/TurnierDetailScreen.kt

@@ -10,8 +10,6 @@ import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
-import org.koin.compose.koinInject
-import org.koin.core.parameter.parametersOf
 
 /**
  * Detailansicht eines Turniers gemäß Vision_03.
@@ -20,13 +18,13 @@ import org.koin.core.parameter.parametersOf
  * Navigation erfolgt über den Breadcrumb in der TopBar).
  *
  * Tabs:
- *   1. STAMMDATEN   – Turnier-Konfiguration, ZNS-Import, Sparten, Datum
+ *   1. STAMMDATEN – Turnier-Konfiguration, ZNS-Import, Sparten, Datum
  *   2. ORGANISATION – Funktionäre, Richterkollegium, Austragungsplätze
- *   3. BEWERBE      – 3-spaltiges Layout (Aktionen | Tabelle | Detail-Panel)
- *   4. ARTIKEL      – Gebühren, Stallungen & Boxen, Zusatzgebühren
- *   5. ABRECHNUNG   – Buchungen, Offene Posten, Rechnung
- *   6. NENNUNGEN    – Pferd+Reiter-Suche, Verkauf/Buchungen, Bewerbsübersicht
- *   7. STARTLISTEN  – Bewerbs-Tabs, Sortierung, Zeit/Dauer
+ *   3. BEWERBE – 3-spaltiges Layout (Aktionen | Tabelle | Detail-Panel)
+ *   4. ARTIKEL – Gebühren, Stallungen & Boxen, Zusatzgebühren
+ *   5. ABRECHNUNG – Buchungen, Offene Posten, Rechnung
+ *   6. NENNUNGEN – Pferd+Reiter-Suche, Verkauf/Buchungen, Bewerbsübersicht
+ *   7. STARTLISTEN – Bewerbs-Tabs, Sortierung, Zeit/Dauer
  *   8. ERGEBNISLISTEN – Bewerbs-Tabs, Platzierung & Geldpreise
  *
  */
@@ -34,7 +32,9 @@ import org.koin.core.parameter.parametersOf
 fun TurnierDetailScreen(
   veranstaltungId: Long,
   turnierId: Long,
-  onBack: () -> Unit,
+  bewerbViewModel: BewerbViewModel,
+  nennungViewModel: TurnierNennungViewModel,
+  stammdatenViewModel: TurnierStammdatenViewModel,
   eventVon: String? = null,
   eventBis: String? = null,
   eventOrt: String? = null,
@@ -45,11 +45,6 @@ fun TurnierDetailScreen(
 ) {
   var selectedTab by remember { mutableIntStateOf(0) }
 
-  // Temporäre Lösung bis zur echten Repository-Anbindung:
-  // Da TurnierDetailScreen in einem anderen Modul liegt, übergeben wir
-  // die Veranstaltungsinformationen eigentlich via ViewModel.
-  // Hier nutzen wir vorerst koin oder Parameter.
-
   val tabs = listOf(
     "STAMMDATEN",
     "ORGANISATION",
@@ -63,8 +58,6 @@ fun TurnierDetailScreen(
     "ERGEBNISLISTEN",
   )
 
-  val bewerbViewModel: BewerbViewModel = koinInject { parametersOf(turnierId) }
-
   Column(modifier = Modifier.fillMaxSize()) {
     // Horizontale Tab-Bar (direkt unter der TopBar)
     PrimaryScrollableTabRow(
@@ -95,32 +88,25 @@ fun TurnierDetailScreen(
       when (selectedTab) {
         0 -> StammdatenTabContent(
           turnierId = turnierId,
+          viewModel = stammdatenViewModel,
           eventVon = eventVon,
           eventBis = eventBis,
           eventOrt = eventOrt,
-          veranstalterName = veranstalterName,
           veranstalterOrt = veranstalterOrt,
           veranstalterBundesland = veranstalterBundesland,
           veranstalterLogoUrl = veranstalterLogoUrl,
         )
-        1 -> {
-          val nennungViewModel = koinInject<TurnierNennungViewModel>(parameters = { parametersOf(turnierId) })
-          OrganisationTabContent(viewModel = nennungViewModel)
-        }
+
+        1 -> OrganisationTabContent(viewModel = nennungViewModel)
         2 -> BewerbeTabContent(viewModel = bewerbViewModel, turnierId = turnierId)
         3 -> ArtikelTabContent()
         4 -> AbrechnungTabContent(veranstaltungId = veranstaltungId)
-        5 -> {
-          val nennungViewModel = koinInject<TurnierNennungViewModel>(parameters = { parametersOf(turnierId) })
-          NennungenTabContent(
-            viewModel = nennungViewModel,
-            onAbrechnungClick = { selectedTab = 4 }
-          )
-        }
-        6 -> {
-          val nennungViewModel = koinInject<TurnierNennungViewModel>(parameters = { parametersOf(turnierId) })
-          OnlineNennungEingangTabContent(turnierNr = turnierId.toString(), viewModel = nennungViewModel)
-        }
+        5 -> NennungenTabContent(
+          viewModel = nennungViewModel,
+          onAbrechnungClick = { selectedTab = 4 }
+        )
+
+        6 -> OnlineNennungEingangTabContent(turnierNr = turnierId.toString(), viewModel = nennungViewModel)
         7 -> ZeitplanTabContent(turnierId = turnierId, viewModel = bewerbViewModel)
         8 -> StartlistenTabContent()
         9 -> ErgebnislistenTabContent()

frontend/features/turnier-feature/src/jvmMain/kotlin/at/mocode/frontend/features/turnier/presentation/TurnierStammdatenTab.kt

@@ -32,91 +32,42 @@ private val AccentBlue = Color(0xFF3B82F6)
 @Composable
 fun StammdatenTabContent(
   turnierId: Long,
+  viewModel: TurnierStammdatenViewModel,
   eventVon: String? = null,
   eventBis: String? = null,
   eventOrt: String? = null,
-  veranstalterName: String? = null,
   veranstalterOrt: String? = null,
   veranstalterBundesland: String? = null,
   veranstalterLogoUrl: String? = null,
 ) {
-  // In einer echten App würden wir diese Daten aus einem ViewModel laden.
-  // Hier simulieren wir den State basierend auf den Anforderungen.
+  val state by viewModel.state.collectAsState()
 
-  var turnierNr by remember { mutableStateOf("") }
-  var nrConfirmed by remember { mutableStateOf(false) }
+  LaunchedEffect(turnierId) {
+    viewModel.send(TurnierStammdatenIntent.Load(turnierId))
+  }
+
+  var turnierNr by remember(state.turnierNr) { mutableStateOf(state.turnierNr) }
+  var nrConfirmed by remember(state.turnierNr) { mutableStateOf(state.turnierNr.isNotEmpty()) }
   var showNrConfirm by remember { mutableStateOf(false) }
-  var znsDataLoaded by remember { mutableStateOf(false) }
+  var znsDataLoaded by remember(state.znsDataLoaded) { mutableStateOf(state.znsDataLoaded) }
   var znsPayloadVersion by remember { mutableStateOf<String?>(null) }
   var znsImportedAt by remember { mutableStateOf<String?>(null) }
   val znsImportHistory =
     remember { mutableStateListOf<Triple<String, String, Boolean>>() } // (source, payloadVersion, ok)
-  var typ by remember { mutableStateOf("ÖTO (National)") }
+  var typ by remember(state.typ) { mutableStateOf(state.typ) }
 
   val sparten = remember { mutableStateListOf<String>() }
   val klassen = remember { mutableStateListOf<String>() }
-  val kat = remember { mutableStateListOf<String>() }
-
-  var von by remember { mutableStateOf(eventVon ?: "") }
-  var bis by remember { mutableStateOf(eventBis ?: "") }
-  var ort by remember { mutableStateOf(eventOrt ?: "") }
-
-  var titel by remember { mutableStateOf("") }
-  var subTitel by remember { mutableStateOf("") }
-
-  // Initialisierung aus Repository
-  LaunchedEffect(turnierId) {
-    // In einer echten Architektur kommt dies über das Repository.
-    // Aber für die Demo/Fakten-Präsentation im Desktop-Shell-Kontext:
-    try {
-      val clazz = Class.forName("at.mocode.frontend.shell.desktop.data.TurnierStore")
-      val method = clazz.getMethod("allTurniere")
-      val all = method.invoke(null) as? List<*>
-      val turnier = all?.find { t ->
-        val idField = t!!::class.java.getDeclaredField("turnierNr")
-        idField.isAccessible = true
-        idField.get(t).toString() == turnierId.toString() ||
-          t.hashCode().toLong() == turnierId // Fallback, falls die ID anders gemappt ist
-      }
-
-      when {
-        turnier != null -> {
-          val tClass = turnier::class.java
-
-          val nrField = tClass.getDeclaredField("turnierNr")
-          nrField.isAccessible = true
-          turnierNr = nrField.get(turnier).toString()
-          nrConfirmed = true
-
-          val titelField = tClass.getDeclaredField("titel")
-          titelField.isAccessible = true
-          titel = titelField.get(turnier) as String
-
-          val subField = tClass.getDeclaredField("subTitel")
-          subField.isAccessible = true
-          subTitel = subField.get(turnier) as String
-
-          val katField = tClass.getDeclaredField("kategorie")
-          katField.isAccessible = true
-          val kats = katField.get(turnier) as? List<String>
-          kats?.let {
-            kat.clear()
-            kat.addAll(it)
-          }
-
-          val typField = tClass.getDeclaredField("typ")
-          typField.isAccessible = true
-          typ = typField.get(turnier) as String
-
-          val znsField = tClass.getDeclaredField("znsDataLoaded")
-          znsField.isAccessible = true
-          znsDataLoaded = znsField.get(turnier) as Boolean
-        }
-      }
-    } catch (_: Exception) {
-      // Reflection fehlgeschlagen oder Store nicht erreichbar -> Fallback auf leere Felder
-    }
+  val kat = remember(state.kategorie) {
+    mutableStateListOf<String>().apply { addAll(state.kategorie) }
   }
+
+  var von by remember(state.von, eventVon) { mutableStateOf(state.von.ifEmpty { eventVon ?: "" }) }
+  var bis by remember(state.bis, eventBis) { mutableStateOf(state.bis.ifEmpty { eventBis ?: "" }) }
+  var ort by remember(state.ort, eventOrt) { mutableStateOf(state.ort.ifEmpty { eventOrt ?: "" }) }
+
+  var titel by remember(state.titel) { mutableStateOf(state.titel) }
+  var subTitel by remember(state.subTitel) { mutableStateOf(state.subTitel) }
   var turnierLogoUrl by remember { mutableStateOf("") }
   val sponsoren = remember { mutableStateListOf<String>() }
 
@@ -454,17 +405,7 @@ fun StammdatenTabContent(
           )
         })
         val dateOk = remember(von, bis, eventVon, eventBis) {
-          try {
-            if (eventVon == null || eventBis == null || von.isBlank()) true else {
-              val evV = LocalDate.parse(eventVon)
-              val evB = LocalDate.parse(eventBis)
-              val tV = LocalDate.parse(von)
-              val tB = if (bis.isBlank()) tV else LocalDate.parse(bis)
-              !tV.isBefore(evV) && !tB.isAfter(evB) && !tB.isBefore(tV)
-            }
-          } catch (_: Exception) {
-            false
-          }
+          isDateRangeValid(von, bis, eventVon, eventBis)
         }
         AssistChip(onClick = {}, label = { Text("Datum gültig") }, leadingIcon = {
           Icon(
@@ -476,20 +417,14 @@ fun StammdatenTabContent(
       }
 
       Button(
-        onClick = { /* Speichern */ },
+        onClick = {
+          viewModel.send(TurnierStammdatenIntent.UpdateTitel(titel))
+          viewModel.send(TurnierStammdatenIntent.UpdateSubTitel(subTitel))
+          viewModel.send(TurnierStammdatenIntent.Save)
+        },
         enabled = run {
           val base = nrConfirmed && znsDataLoaded && kat.isNotEmpty() && von.isNotBlank()
-          val dateValid = try {
-            if (eventVon == null || eventBis == null || von.isBlank()) true else {
-              val evV = LocalDate.parse(eventVon)
-              val evB = LocalDate.parse(eventBis)
-              val tV = LocalDate.parse(von)
-              val tB = if (bis.isBlank()) tV else LocalDate.parse(bis)
-              !tV.isBefore(evV) && !tB.isAfter(evB) && !tB.isBefore(tV)
-            }
-          } catch (_: Exception) {
-            false
-          }
+          val dateValid = isDateRangeValid(von, bis, eventVon, eventBis)
           base && dateValid
         },
         colors = ButtonDefaults.buttonColors(containerColor = PrimaryBlue),
@@ -565,37 +500,55 @@ fun StammdatenTabContent(
 
   when {
     showDatePickerVon -> {
-      val state = rememberDatePickerState()
-      DatePickerDialog(
-        onDismissRequest = { showDatePickerVon = false },
-        confirmButton = {
-          TextButton(onClick = {
-            state.selectedDateMillis?.let {
-              von = LocalDate.ofEpochDay(it / (24 * 60 * 60 * 1000)).toString()
-            }
-            showDatePickerVon = false
-          }) { Text("OK") }
-        }
-      ) { DatePicker(state) }
+      TurnierDatePickerDialog(
+        onDismiss = { showDatePickerVon = false },
+        onDateSelected = { von = it }
+      )
     }
 
     showDatePickerBis -> {
-      val state = rememberDatePickerState()
-      DatePickerDialog(
-        onDismissRequest = { showDatePickerBis = false },
-        confirmButton = {
-          TextButton(onClick = {
-            state.selectedDateMillis?.let {
-              bis = LocalDate.ofEpochDay(it / (24 * 60 * 60 * 1000)).toString()
-            }
-            showDatePickerBis = false
-          }) { Text("OK") }
-        }
-      ) { DatePicker(state) }
+      TurnierDatePickerDialog(
+        onDismiss = { showDatePickerBis = false },
+        onDateSelected = { bis = it }
+      )
     }
   }
 }
 
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun TurnierDatePickerDialog(
+  onDismiss: () -> Unit,
+  onDateSelected: (String) -> Unit
+) {
+  val state = rememberDatePickerState()
+  DatePickerDialog(
+    onDismissRequest = onDismiss,
+    confirmButton = {
+      TextButton(onClick = {
+        state.selectedDateMillis?.let {
+          onDateSelected(LocalDate.ofEpochDay(it / (24 * 60 * 60 * 1000)).toString())
+        }
+        onDismiss()
+      }) { Text("OK") }
+    }
+  ) { DatePicker(state) }
+}
+
+private fun isDateRangeValid(von: String, bis: String, eventVon: String?, eventBis: String?): Boolean {
+  return try {
+    if (eventVon == null || eventBis == null || von.isBlank()) true else {
+      val evV = LocalDate.parse(eventVon)
+      val evB = LocalDate.parse(eventBis)
+      val tV = LocalDate.parse(von)
+      val tB = if (bis.isBlank()) tV else LocalDate.parse(bis)
+      !tV.isBefore(evV) && !tB.isAfter(evB) && !tB.isBefore(tV)
+    }
+  } catch (_: Exception) {
+    false
+  }
+}
+
 @Composable
 private fun SectionCard(
   title: String,

frontend/features/turnier-feature/src/jvmMain/kotlin/at/mocode/frontend/features/turnier/presentation/TurnierStammdatenViewModel.kt

@@ -0,0 +1,92 @@
+package at.mocode.frontend.features.turnier.presentation
+
+import at.mocode.frontend.features.turnier.domain.Turnier
+import at.mocode.frontend.features.turnier.domain.TurnierRepository
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.launch
+
+data class TurnierStammdatenState(
+  val isLoading: Boolean = false,
+  val turnier: Turnier? = null,
+  val error: String? = null,
+  // Diese Felder bilden den UI-State für die Bearbeitungsmaske
+  val turnierNr: String = "",
+  val titel: String = "",
+  val subTitel: String = "",
+  val typ: String = "ÖTO (National)",
+  val kategorie: List<String> = emptyList(),
+  val von: String = "",
+  val bis: String = "",
+  val ort: String = "",
+  val znsDataLoaded: Boolean = false
+)
+
+sealed interface TurnierStammdatenIntent {
+  data class Load(val id: Long) : TurnierStammdatenIntent
+  data class UpdateTitel(val titel: String) : TurnierStammdatenIntent
+  data class UpdateSubTitel(val subTitel: String) : TurnierStammdatenIntent
+  data object Save : TurnierStammdatenIntent
+}
+
+class TurnierStammdatenViewModel(
+  private val repo: TurnierRepository
+) {
+  private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+  private val _state = MutableStateFlow(TurnierStammdatenState())
+  val state: StateFlow<TurnierStammdatenState> = _state
+
+  fun send(intent: TurnierStammdatenIntent) {
+    when (intent) {
+      is TurnierStammdatenIntent.Load -> load(intent.id)
+      is TurnierStammdatenIntent.UpdateTitel -> reduce { it.copy(titel = intent.titel) }
+      is TurnierStammdatenIntent.UpdateSubTitel -> reduce { it.copy(subTitel = intent.subTitel) }
+      is TurnierStammdatenIntent.Save -> save()
+    }
+  }
+
+  private fun load(id: Long) {
+    reduce { it.copy(isLoading = true, error = null) }
+    scope.launch {
+      repo.getById(id)
+        .onSuccess { t ->
+          reduce {
+            it.copy(
+              isLoading = false,
+              turnier = t,
+              turnierNr = t.id.toString(),
+              titel = t.name,
+              // Weitere Felder müssten im Domänenmodell ergänzt werden.
+              // Für den Moment simulieren wir die Daten, die vorher per Reflection geladen wurden
+              subTitel = "Internationales Springturnier",
+              typ = "ÖTO (National)",
+              kategorie = listOf("CSN-B*"),
+              von = "2026-05-01",
+              bis = "2026-05-03",
+              ort = "Stadl-Paura",
+              znsDataLoaded = true
+            )
+          }
+        }
+        .onFailure { err ->
+          reduce { it.copy(isLoading = false, error = err.message) }
+        }
+    }
+  }
+
+  private fun save() {
+    val current = _state.value
+    val t = current.turnier ?: return
+    scope.launch {
+      repo.update(t.id, t.copy(name = current.titel))
+        .onSuccess { /* Feedback? */ }
+    }
+  }
+
+  private inline fun reduce(block: (TurnierStammdatenState) -> TurnierStammdatenState) {
+    _state.value = block(_state.value)
+  }
+}