From 650a3bb0500787c3a022096ae4a0cce8b10dd860 Mon Sep 17 00:00:00 2001
From: oxidiert <daniel.ocks@gmx.de>
Date: Mon, 8 Sep 2025 10:27:23 +0200
Subject: [PATCH] fixed wrong loading bug, fixed editing bug

---
 .../java/com/dano/test1/EditButtonHandler.kt  | 45 ++++++++++++--
 .../com/dano/test1/HandlerClientCoachCode.kt  | 47 +++++---------
 .../com/dano/test1/HandlerOpeningScreen.kt    | 16 +++--
 .../java/com/dano/test1/LoadButtonHandler.kt  | 62 ++++++++-----------
 4 files changed, 93 insertions(+), 77 deletions(-)

diff --git a/app/src/main/java/com/dano/test1/EditButtonHandler.kt b/app/src/main/java/com/dano/test1/EditButtonHandler.kt
index 6d84f15..afcf7cf 100644
--- a/app/src/main/java/com/dano/test1/EditButtonHandler.kt
+++ b/app/src/main/java/com/dano/test1/EditButtonHandler.kt
@@ -14,7 +14,9 @@ class EditButtonHandler(
     private val questionnaireFiles: Map<Button, String>,
     private val buttonPoints: MutableMap<String, Int>,
     private val updateButtonTexts: () -> Unit,
-    private val setButtonsEnabled: (List<Button>) -> Unit
+    private val setButtonsEnabled: (List<Button>) -> Unit,
+    // vor "Bearbeiten" ggf. Laden anstoßen
+    private val triggerLoad: () -> Unit
 ) {
 
     fun setup() {
@@ -23,18 +25,38 @@ class EditButtonHandler(
     }
 
     private fun handleEditButtonClick() {
-        val clientCode = editText.text.toString().trim()
-        if (clientCode.isBlank()) {
+        val typed = editText.text.toString().trim()
+        val desiredCode = when {
+            typed.isNotBlank() -> typed
+            !GlobalValues.LOADED_CLIENT_CODE.isNullOrBlank() -> GlobalValues.LOADED_CLIENT_CODE!!
+            else -> ""
+        }
+
+        if (desiredCode.isBlank()) {
             val message = LanguageManager.getText(languageIDProvider(), "please_client_code")
             Toast.makeText(activity, message, Toast.LENGTH_SHORT).show()
             return
         }
 
-        GlobalValues.LAST_CLIENT_CODE = clientCode
+        // Nutzerwunsch merken (info)
+        GlobalValues.LAST_CLIENT_CODE = desiredCode
+
+        // Nur laden, wenn noch nicht/anders geladen
+        val needLoad = GlobalValues.LOADED_CLIENT_CODE?.equals(desiredCode) != true
+        if (needLoad) triggerLoad()
 
         CoroutineScope(Dispatchers.IO).launch {
+            val loadedOk = waitUntilClientLoaded(desiredCode, timeoutMs = 2500, stepMs = 50)
+            if (!loadedOk) {
+                withContext(Dispatchers.Main) {
+                    Toast.makeText(activity, "Bitte den Klienten über \"Laden\" öffnen.", Toast.LENGTH_LONG).show()
+                }
+                return@launch
+            }
+
+            // Ab hier: geladen → Bearbeiten-Logik
             val completedEntries: List<CompletedQuestionnaire> =
-                MyApp.database.completedQuestionnaireDao().getAllForClient(clientCode)
+                MyApp.database.completedQuestionnaireDao().getAllForClient(desiredCode)
 
             val completedFiles = completedEntries
                 .filter { it.isDone }
@@ -58,4 +80,17 @@ class EditButtonHandler(
             }
         }
     }
+
+    private suspend fun waitUntilClientLoaded(expectedCode: String, timeoutMs: Long, stepMs: Long): Boolean {
+        // sofort ok, wenn bereits korrekt geladen
+        if (GlobalValues.LOADED_CLIENT_CODE?.equals(expectedCode) == true) return true
+
+        var waited = 0L
+        while (waited < timeoutMs) {
+            delay(stepMs)
+            waited += stepMs
+            if (GlobalValues.LOADED_CLIENT_CODE?.equals(expectedCode) == true) return true
+        }
+        return GlobalValues.LOADED_CLIENT_CODE?.equals(expectedCode) == true
+    }
 }
diff --git a/app/src/main/java/com/dano/test1/HandlerClientCoachCode.kt b/app/src/main/java/com/dano/test1/HandlerClientCoachCode.kt
index 7577182..c1a49ad 100644
--- a/app/src/main/java/com/dano/test1/HandlerClientCoachCode.kt
+++ b/app/src/main/java/com/dano/test1/HandlerClientCoachCode.kt
@@ -26,50 +26,39 @@ class HandlerClientCoachCode(
         this.layout = layout
         this.question = question
 
-        // Bind UI components
         val clientCodeField = layout.findViewById<EditText>(R.id.client_code)
         val coachCodeField = layout.findViewById<EditText>(R.id.coach_code)
         val questionTextView = layout.findViewById<TextView>(R.id.question)
         val titleTextView = layout.findViewById<TextView>(R.id.textView)
 
-        // Fill question text using language manager
-        questionTextView.text = question.question?.let {
-            LanguageManager.getText(languageID, it)
-        } ?: ""
+        questionTextView.text = question.question?.let { LanguageManager.getText(languageID, it) } ?: ""
 
-        // --- Schriftgrößen prozentual zur Bildschirmhöhe setzen ---
-        // Passe die Prozente bei Bedarf an:
-        setTextSizePercentOfScreenHeight(titleTextView,   0.03f) // 5.5% der Bildschirmhöhe
-        setTextSizePercentOfScreenHeight(questionTextView,0.03f) // 5.0% der Bildschirmhöhe
-        setTextSizePercentOfScreenHeight(clientCodeField, 0.025f) // 3.5% der Bildschirmhöhe
-        setTextSizePercentOfScreenHeight(coachCodeField,  0.025f) // anpassen nach Geschmack
-        // ----------------------------------------------------------
+        setTextSizePercentOfScreenHeight(titleTextView,   0.03f)
+        setTextSizePercentOfScreenHeight(questionTextView,0.03f)
+        setTextSizePercentOfScreenHeight(clientCodeField, 0.025f)
+        setTextSizePercentOfScreenHeight(coachCodeField,  0.025f)
 
-        // Load last used client code if available
-        val lastClientCode = GlobalValues.LAST_CLIENT_CODE
-        if (!lastClientCode.isNullOrBlank()) {
-            clientCodeField.setText(lastClientCode)
+        // *** WICHTIG: Nur den ERFOLGREICH GELADENEN Code verwenden ***
+        val loadedClientCode = GlobalValues.LOADED_CLIENT_CODE
+        if (!loadedClientCode.isNullOrBlank()) {
+            clientCodeField.setText(loadedClientCode)
             clientCodeField.isEnabled = false
         } else {
-            clientCodeField.setText(answers["client_code"] as? String ?: "")
+            // Nichts ist geladen → Feld bleibt leer und editierbar
+            clientCodeField.setText("")
             clientCodeField.isEnabled = true
         }
 
-        // Load saved coach code
         coachCodeField.setText(answers["coach_code"] as? String ?: "")
 
-        // Set click listener for Next button
         layout.findViewById<Button>(R.id.Qnext).setOnClickListener {
             onNextClicked(clientCodeField, coachCodeField)
         }
-
-        // Set click listener for Previous button
         layout.findViewById<Button>(R.id.Qprev).setOnClickListener {
             onPreviousClicked(clientCodeField, coachCodeField)
         }
     }
 
-    // Deaktiviert AutoSize und setzt textSize in sp prozentual zur Bildschirmhöhe
     private fun setTextSizePercentOfScreenHeight(view: TextView, percentOfHeight: Float) {
         val dm = layout.resources.displayMetrics
         val sp = (dm.heightPixels * percentOfHeight) / dm.scaledDensity
@@ -77,8 +66,10 @@ class HandlerClientCoachCode(
         view.setTextSize(TypedValue.COMPLEX_UNIT_SP, sp)
     }
 
-    // Handle Next button click
     private fun onNextClicked(clientCodeField: EditText, coachCodeField: EditText) {
+        // 1) Ohne vorher geladenen Client NICHT weiter
+        val loadedClientCode = GlobalValues.LOADED_CLIENT_CODE
+
         if (!validate()) {
             val message = LanguageManager.getText(languageID, "fill_both_fields")
             showToast(message)
@@ -92,21 +83,18 @@ class HandlerClientCoachCode(
         val dbPath = layout.context.getDatabasePath("questionnaire_database")
         val dbExistedBefore = dbPath.exists()
 
-        // Check if client code already exists asynchronously
         CoroutineScope(Dispatchers.IO).launch {
             val existingClient = MyApp.database.clientDao().getClientByCode(clientCode)
 
             withContext(Dispatchers.Main) {
+                // Wenn Feld editierbar war und Code bereits existiert → Hinweis
                 if (existingClient != null && clientCodeField.isEnabled) {
-                    // Client code already exists and field was editable
                     val message = LanguageManager.getText(languageID, "client_code_exists")
                     showToast(message)
                 } else {
-                    // Either no existing client or re-using previous code
                     saveAnswers(clientCode, coachCode)
                     goToNextQuestion()
 
-                    // Lösche DB-Dateien nur, wenn sie vorher nicht existierten
                     if (!dbExistedBefore) {
                         MyApp.database.close()
                         dbPath.delete()
@@ -118,7 +106,6 @@ class HandlerClientCoachCode(
         }
     }
 
-    // Handle Previous button click
     private fun onPreviousClicked(clientCodeField: EditText, coachCodeField: EditText) {
         val clientCode = clientCodeField.text.toString()
         val coachCode = coachCodeField.text.toString()
@@ -126,21 +113,19 @@ class HandlerClientCoachCode(
         goToPreviousQuestion()
     }
 
-    // Validate that both fields are filled
     override fun validate(): Boolean {
         val clientCode = layout.findViewById<EditText>(R.id.client_code).text
         val coachCode = layout.findViewById<EditText>(R.id.coach_code).text
         return clientCode.isNotBlank() && coachCode.isNotBlank()
     }
 
-    // Save answers to shared state and global value
     private fun saveAnswers(clientCode: String, coachCode: String) {
+        // Optional: LAST_CLIENT_CODE kann gesetzt bleiben; maßgeblich ist LOADED_CLIENT_CODE
         GlobalValues.LAST_CLIENT_CODE = clientCode
         answers["client_code"] = clientCode
         answers["coach_code"] = coachCode
     }
 
-    // Required override but not used here
     override fun saveAnswer() {
         // Not used
     }
diff --git a/app/src/main/java/com/dano/test1/HandlerOpeningScreen.kt b/app/src/main/java/com/dano/test1/HandlerOpeningScreen.kt
index f55b74b..3f3ae41 100644
--- a/app/src/main/java/com/dano/test1/HandlerOpeningScreen.kt
+++ b/app/src/main/java/com/dano/test1/HandlerOpeningScreen.kt
@@ -48,7 +48,7 @@ class HandlerOpeningScreen(private val activity: MainActivity) {
         val pathExists = File(dbPath).exists()
         updateMainButtonsState(pathExists)
 
-        if (!editText.text.isNullOrBlank()) {
+        if (pathExists && !editText.text.isNullOrBlank()) {
             buttonLoad.performClick()
         }
     }
@@ -154,21 +154,26 @@ class HandlerOpeningScreen(private val activity: MainActivity) {
             questionnaireFiles[button] = entry.file
         }
         updateButtonTexts()
+
         val alwaysButtons = questionnaireEntries.mapIndexedNotNull { idx, entry ->
             val btn = dynamicButtons.getOrNull(idx)
             if (entry.condition is QuestionItem.Condition.AlwaysAvailable) btn else null
         }
         setButtonsEnabled(alwaysButtons)
+
         dynamicButtons.forEach { button ->
             button.setOnClickListener {
-                val clientCode = editText.text.toString().trim()
-                GlobalValues.LAST_CLIENT_CODE = clientCode
+
+                // Optional: LAST_CLIENT_CODE synchronisieren (rein informativ)
+                GlobalValues.LAST_CLIENT_CODE = GlobalValues.LOADED_CLIENT_CODE
+
                 startQuestionnaireForButton(button)
                 setButtonsEnabled(dynamicButtons.filter { it == button })
             }
         }
     }
 
+
     private fun restorePreviousClientCode() {
         GlobalValues.LAST_CLIENT_CODE?.let { editText.setText(it) }
     }
@@ -276,10 +281,13 @@ class HandlerOpeningScreen(private val activity: MainActivity) {
             questionnaireFiles = questionnaireFiles,
             buttonPoints = buttonPoints,
             updateButtonTexts = { updateButtonTexts() },
-            setButtonsEnabled = { setButtonsEnabled(it) }
+            setButtonsEnabled = { setButtonsEnabled(it) },
+            // Vor "Bearbeiten" ggf. den Load-Button ausführen
+            triggerLoad = { buttonLoad.performClick() }
         ).setup()
     }
 
+
     private fun setupUploadButton() {
         uploadButton.text = "Upload"
         uploadButton.setOnClickListener {
diff --git a/app/src/main/java/com/dano/test1/LoadButtonHandler.kt b/app/src/main/java/com/dano/test1/LoadButtonHandler.kt
index 1cdec9c..bbf589d 100644
--- a/app/src/main/java/com/dano/test1/LoadButtonHandler.kt
+++ b/app/src/main/java/com/dano/test1/LoadButtonHandler.kt
@@ -42,10 +42,11 @@ class LoadButtonHandler(
         CoroutineScope(Dispatchers.IO).launch {
             val client = MyApp.database.clientDao().getClientByCode(clientCode)
             if (client == null) {
+                // Kein Profil → als NICHT geladen markieren
+                GlobalValues.LOADED_CLIENT_CODE = null
                 withContext(Dispatchers.Main) {
                     val message = LanguageManager.getText(languageIDProvider(), "no_profile")
                     Toast.makeText(activity, message, Toast.LENGTH_LONG).show()
-                    // enable only alwaysAvailable ones if no client found
                     val questionnaireEntries = questionnaireEntriesProvider()
                     val alwaysButtons = questionnaireEntries.mapIndexedNotNull { idx, entry ->
                         val btn = dynamicButtonsProvider().getOrNull(idx)
@@ -56,27 +57,28 @@ class LoadButtonHandler(
                 return@launch
             }
 
+            // Profil gefunden → als geladen markieren
+            GlobalValues.LOADED_CLIENT_CODE = clientCode
+
             withContext(Dispatchers.Main) {
-                updateMainButtonsState(true) // Datenbank vorhanden -> Buttons aktivieren
+                updateMainButtonsState(true)
             }
 
             handleNormalLoad(clientCode)
         }
     }
 
-    // Evaluierung der Bedingung: suspend, weil DB-Abfragen stattfinden.
     private suspend fun evaluateCondition(
         condition: QuestionItem.Condition?,
         clientCode: String,
         completedEntries: List<CompletedQuestionnaire>
     ): Boolean {
         if (condition == null) return false
-
-        when (condition) {
-            is QuestionItem.Condition.AlwaysAvailable -> return true
+        return when (condition) {
+            is QuestionItem.Condition.AlwaysAvailable -> true
             is QuestionItem.Condition.RequiresCompleted -> {
                 val normalizedCompleted = completedEntries.map { normalizeQuestionnaireId(it.questionnaireId) }
-                return condition.required.all { req ->
+                condition.required.all { req ->
                     val nReq = normalizeQuestionnaireId(req)
                     normalizedCompleted.any { it.contains(nReq) || nReq.contains(it) }
                 }
@@ -85,48 +87,37 @@ class LoadButtonHandler(
                 val answers = MyApp.database.answerDao().getAnswersForClientAndQuestionnaire(clientCode, condition.questionnaire)
                 val relevant = answers.find { it.questionId.endsWith(condition.questionId, ignoreCase = true) }
                 val answerValue = relevant?.answerValue ?: ""
-                return when (condition.operator) {
+                when (condition.operator) {
                     "==" -> answerValue == condition.value
                     "!=" -> answerValue != condition.value
                     else -> false
                 }
             }
             is QuestionItem.Condition.Combined -> {
-                val reqOk = if (condition.requiresCompleted.isNullOrEmpty()) true
-                else {
-                    val normalizedCompleted = completedEntries.map { normalizeQuestionnaireId(it.questionnaireId) }
-                    condition.requiresCompleted.all { req ->
-                        val nReq = normalizeQuestionnaireId(req)
-                        normalizedCompleted.any { it.contains(nReq) || nReq.contains(it) }
-                    }
+                val normalizedCompleted = completedEntries.map { normalizeQuestionnaireId(it.questionnaireId) }
+                val reqOk = condition.requiresCompleted.isNullOrEmpty() || condition.requiresCompleted.all { req ->
+                    val nReq = normalizeQuestionnaireId(req)
+                    normalizedCompleted.any { it.contains(nReq) || nReq.contains(it) }
                 }
                 if (!reqOk) return false
-                val q = condition.questionCheck
-                if (q != null) {
-                    val answers = MyApp.database.answerDao().getAnswersForClientAndQuestionnaire(clientCode, q.questionnaire)
-                    val relevant = answers.find { it.questionId.endsWith(q.questionId, ignoreCase = true) }
-                    val answerValue = relevant?.answerValue ?: ""
-                    return when (q.operator) {
-                        "==" -> answerValue == q.value
-                        "!=" -> answerValue != q.value
-                        else -> false
-                    }
+                val q = condition.questionCheck ?: return true
+                val answers = MyApp.database.answerDao().getAnswersForClientAndQuestionnaire(clientCode, q.questionnaire)
+                val relevant = answers.find { it.questionId.endsWith(q.questionId, ignoreCase = true) }
+                val answerValue = relevant?.answerValue ?: ""
+                when (q.operator) {
+                    "==" -> answerValue == q.value
+                    "!=" -> answerValue != q.value
+                    else -> false
                 }
-                return reqOk
             }
             is QuestionItem.Condition.AnyOf -> {
-                for (sub in condition.conditions) {
-                    val subRes = evaluateCondition(sub, clientCode, completedEntries)
-                    if (subRes) return true
-                }
-                return false
+                condition.conditions.any { evaluateCondition(it, clientCode, completedEntries) }
             }
         }
     }
 
-    private fun normalizeQuestionnaireId(name: String): String {
-        return name.lowercase().removeSuffix(".json")
-    }
+    private fun normalizeQuestionnaireId(name: String): String =
+        name.lowercase().removeSuffix(".json")
 
     private suspend fun handleNormalLoad(clientCode: String) {
         val completedEntries = withContext(Dispatchers.IO) {
@@ -147,7 +138,6 @@ class LoadButtonHandler(
             updateButtonTexts()
         }
 
-        // für jeden Fragebogen prüfen, ob er aktiv sein darf
         val enabledButtons = mutableListOf<Button>()
         val questionnaireEntries = questionnaireEntriesProvider()
         val dynamicButtons = dynamicButtonsProvider()
@@ -155,7 +145,6 @@ class LoadButtonHandler(
         for ((idx, entry) in questionnaireEntries.withIndex()) {
             val button = dynamicButtons.getOrNull(idx) ?: continue
 
-            // falls bereits erledigt: nicht anklickbar
             val isCompleted = completedEntries.any { completed ->
                 normalizeQuestionnaireId(completed.questionnaireId).let { completedNorm ->
                     val targetNorm = normalizeQuestionnaireId(entry.file)
@@ -164,7 +153,6 @@ class LoadButtonHandler(
             }
             if (isCompleted) continue
 
-            // auswerten der Bedingung (suspend)
             val condMet = evaluateCondition(entry.condition, clientCode, completedEntries)
             if (condMet) enabledButtons.add(button)
         }