From 1505d3d004d89c3d05848767d0e8b37728e7067d Mon Sep 17 00:00:00 2001
From: "Torsten Schulz (local)" <tsschulz@gmx.net>
Date: Mon, 12 Jan 2026 16:52:18 +0100
Subject: [PATCH] Refactor production initiation logic in DirectorWorker:
 Update the create_single_production method to return the produced quantity,
 enhancing the loop's decision-making process. Improve error handling and
 logging for production failures, ensuring better capacity management and
 preventing race conditions during production checks.

---
 src/worker/director.rs | 33 +++++++++++++++++++++++++++------
 1 file changed, 27 insertions(+), 6 deletions(-)

diff --git a/src/worker/director.rs b/src/worker/director.rs
index 090e6bf..2b03998 100644
--- a/src/worker/director.rs
+++ b/src/worker/director.rs
@@ -432,12 +432,32 @@ impl DirectorWorker {
             base_plan.running_productions_quantity = running_productions_quantity;
 
             // Eine neue Produktion starten (max. 100 Stück)
-            if let Err(err) = self.create_single_production(&mut conn, &base_plan) {
+            let produced_quantity = match self.create_single_production(&mut conn, &base_plan) {
+                Ok(qty) => qty,
+                Err(err) => {
+                    eprintln!(
+                        "[DirectorWorker] Fehler beim Starten einer Produktion: {err}"
+                    );
+                    break;
+                }
+            };
+
+            // WICHTIG: Wenn wir die gesamte verfügbare Kapazität verwendet haben, breche ab.
+            // Sonst könnte die nächste Iteration fälschlicherweise noch Platz sehen, wenn
+            // die gerade gestartete Produktion noch nicht in running_productions_quantity enthalten ist.
+            if produced_quantity >= free_capacity {
                 eprintln!(
-                    "[DirectorWorker] Fehler beim Starten einer Produktion: {err}"
+                    "[DirectorWorker] Produktion mit {} Stück gestartet, was die gesamte freie Kapazität ({}) ausnutzt. Breche ab.",
+                    produced_quantity, free_capacity
                 );
                 break;
             }
+
+            // Wenn wir weniger als 10% der freien Kapazität produziert haben, könnte es sein,
+            // dass wir noch mehr Platz haben. Aber sicherheitshalber brechen wir nach einer
+            // Produktion ab, um Race Conditions zu vermeiden.
+            // Die nächste Iteration (beim nächsten Director-Check) wird dann wieder prüfen.
+            break;
         }
 
         Ok(())
@@ -499,7 +519,7 @@ impl DirectorWorker {
         &mut self,
         conn: &mut DbConnection,
         plan: &ProductionPlan,
-    ) -> Result<(), DbError> {
+    ) -> Result<i32, DbError> {
         // WICHTIG: Kapazität direkt aus dem Plan berechnen (wurde gerade in der Schleife aktualisiert)
         let free_capacity = Self::calc_free_capacity(plan);
         let one_piece_cost = Self::calc_one_piece_cost(plan);
@@ -526,7 +546,7 @@ impl DirectorWorker {
                 plan.running_productions,
                 plan.running_productions_quantity
             );
-            return Ok(());
+            return Ok(0);
         }
 
         // Sicherheitsprüfung: to_produce darf niemals größer sein als free_capacity
@@ -535,7 +555,7 @@ impl DirectorWorker {
                 "[DirectorWorker] FEHLER: to_produce ({}) > free_capacity ({})! Das sollte nicht passieren. Breche Produktion ab.",
                 to_produce, free_capacity
             );
-            return Ok(());
+            return Ok(0);
         }
 
         let production_cost = to_produce as f64 * one_piece_cost;
@@ -576,7 +596,8 @@ impl DirectorWorker {
         );
         self.base.broker.publish(message);
 
-        Ok(())
+        // Rückgabe der produzierten Menge, damit die Schleife entscheiden kann, ob sie weiterläuft
+        Ok(to_produce)
     }
 
     fn calc_free_capacity(plan: &ProductionPlan) -> i32 {