humanize diagonstics further

Author: popmonkey

src/analysis/solver_diagnostics.cpp

@@ -1,9 +1,13 @@
 #include "solver_diagnostics.hpp"
+#include "capacity_analyzer.hpp"
 #include "../utils/date_utils.hpp"
 #include <sstream>
 #include <iomanip>
 #include <set>
 #include <chrono>
+#include <algorithm>
+#include <cmath>
+#include <tuple>
 
 namespace jres::analysis {
 
@@ -135,4 +139,174 @@ std::string explain_assignment_failure(
     return ss.str();
 }
 
-} // namespace jres::analysis
+/**
+ * @brief Helper to format a list of stint indices into a human-readable string using IDs.
+ */
+std::string formatStintList(const std::vector<int>& indices, const jres::internal::SolverInput& input) {
+    if (indices.empty()) return "";
+    
+    std::vector<int> sorted = indices;
+    std::sort(sorted.begin(), sorted.end());
+    
+    std::ostringstream ss;
+    for (size_t i = 0; i < sorted.size(); ++i) {
+        int startIdx = sorted[i];
+        int endIdx = startIdx;
+        while (i + 1 < sorted.size() && sorted[i + 1] == endIdx + 1) {
+            endIdx = sorted[++i];
+        }
+        
+        if (ss.tellp() > 0) ss << ", ";
+        if (startIdx == endIdx) ss << input.stints[startIdx].id;
+        else ss << input.stints[startIdx].id << "-" << input.stints[endIdx].id;
+    }
+    return ss.str();
+}
+
+std::vector<std::string> formatHumanDiagnostic(
+    const std::map<int, jres::internal::SlackInfo>& slackInfo,
+    const std::set<int>& unavailableVars,
+    const std::map<std::pair<std::string, int>, int>& driverWorkVars,
+    const std::map<std::pair<std::string, int>, int>& spotterWorkVars,
+    const std::vector<double>& colValues,
+    const jres::internal::SolverInput& input,
+    const std::vector<jres::internal::TeamMember>& driverPool,
+    const std::vector<jres::internal::TeamMember>& spotterPool)
+{
+    using namespace jres::internal;
+    std::vector<std::string> report;
+
+    // --- Roster Health Check (Drivers) ---
+    if (!driverPool.empty()) {
+        auto cap = CapacityAnalyzer::calculate_max_potential_capacity(driverPool, input);
+        if (cap.totalCapacity < (int)input.stints.size()) {
+            std::ostringstream ss;
+            ss << "Driver Roster Understaffed: You have " << cap.totalCapacity 
+               << " stints of coverage for a " << input.stints.size() << " stint race.";
+            report.push_back(ss.str());
+        }
+    }
+
+    // --- Collect Violations per Stint ---
+    struct ViolationKey {
+        int priority;
+        std::string reason;
+        std::string member;
+        
+        bool operator<(const ViolationKey& other) const {
+            return std::tie(priority, reason, member) < std::tie(other.priority, other.reason, other.member);
+        }
+    };
+
+    std::map<ViolationKey, std::vector<int>> groupedViolations;
+    std::vector<std::string> globalViolations;
+
+    // Build reverse map for variable index -> (Member, Stint, Role)
+    std::map<int, std::tuple<std::string, int, std::string>> varToInfo;
+    
+    for(const auto& [key, varIdx] : driverWorkVars) {
+        varToInfo[varIdx] = std::make_tuple(key.first, key.second, "Driver");
+    }
+    for(const auto& [key, varIdx] : spotterWorkVars) {
+        varToInfo[varIdx] = std::make_tuple(key.first, key.second, "Spotter");
+    }
+
+    // Check Unavailable (Priority 0)
+    for (int varIdx : unavailableVars) {
+        if (varIdx < (int)colValues.size() && colValues[varIdx] > 0.5) {
+            if (varToInfo.count(varIdx)) {
+                auto [member, stintIdx, role] = varToInfo[varIdx];
+                std::string reason = std::string("No one could ") + (role == "Spotter" ? "spot" : "drive") + 
+                                     " without being Unavailable (" + member + ")";
+                groupedViolations[{0, reason, member}].push_back(stintIdx);
+            }
+        }
+    }
+
+    // Check Slack (Rest, Busy, etc)
+    for (const auto& [varIdx, info] : slackInfo) {
+        if (varIdx < (int)colValues.size() && colValues[varIdx] > 0.001) {
+            int priority = 3;
+            if (info.type.find("Busy") != std::string::npos) priority = 1;
+            else if (info.type.find("Rest") != std::string::npos) priority = 2;
+            else if (info.type.find("Fair Share") != std::string::npos) priority = 2;
+
+            if (info.stintIndex >= 0) {
+                 std::string reason;
+                 if (priority == 1) reason = "Max Busy Time exceeded (" + info.memberName + ")";
+                 else if (priority == 2) {
+                     if (info.type.find("Fair Share") != std::string::npos) reason = "Fair Share Rules violated (" + info.memberName + ")";
+                     else reason = "Rest Rules violated (" + info.memberName + ")";
+                 }
+                 else reason = info.type + " (" + info.memberName + ")";
+
+                 groupedViolations[{priority, reason, info.memberName}].push_back(info.stintIndex);
+            } else {
+                // Try to attribute global violation to stints
+                bool assignedAny = false;
+                for(const auto& [vIdx, tupleInfo] : varToInfo) {
+                    auto [memName, stintIdx, role] = tupleInfo;
+                    if (memName == info.memberName && colValues[vIdx] > 0.5) {
+                        std::string reason;
+                        if (priority == 1) reason = "Max Busy Time exceeded (" + memName + ")";
+                        else if (priority == 2) {
+                            if (info.type.find("Fair Share") != std::string::npos) reason = "Fair Share Rules violated (" + memName + ")";
+                            else reason = "Rest Rules violated (" + memName + ")";
+                        }
+                        else reason = info.type + " (" + memName + ")";
+
+                        groupedViolations[{priority, reason, memName}].push_back(stintIdx);
+                        assignedAny = true;
+                    }
+                }
+                
+                if (!assignedAny) {
+                    std::string reason = info.type;
+                    if (priority == 2) {
+                         if (info.type.find("Fair Share") != std::string::npos) 
+                             reason = "Fair Share Rules violated";
+                         else 
+                             reason = "Rest Rules violated";
+                    }
+                    globalViolations.push_back(reason + " (" + info.memberName + ")");
+                }
+            }
+        }
+    }
+
+    // --- Sort & Format Grouped Violations ---
+    std::vector<ViolationKey> sortedKeys;
+    for(const auto& [key, _] : groupedViolations) sortedKeys.push_back(key);
+    std::sort(sortedKeys.begin(), sortedKeys.end());
+
+    for (const auto& key : sortedKeys) {
+        const auto& stints = groupedViolations[key];
+        std::string stintStr = formatStintList(stints, input);
+        
+        std::ostringstream ss;
+        if (stints.size() == 1) ss << "Stint " << stintStr << ": " << key.reason;
+        else ss << "Stints " << stintStr << ": " << key.reason;
+        report.push_back(ss.str());
+
+        // Actionable Advice
+        if (key.priority == 0) { 
+             report.push_back("   -> Advice: Mark " + key.member + " as Available during this window.");
+        } else if (key.priority == 1) { 
+             report.push_back("   -> Advice: Increase 'Maximum Busy Hours' (currently " + std::to_string(input.maximumBusyHours) + "h) or add more participants.");
+        } else if (key.priority == 2) { 
+             if (key.reason.find("Fair Share") != std::string::npos)
+                 report.push_back("   -> Advice: Ensure " + key.member + " is Available for more stints to meet the minimum driving time.");
+             else
+                 report.push_back("   -> Advice: Reduce 'Minimum Rest Hours' (currently " + std::to_string(input.minimumRestHours) + "h) or increase availability of other participants to cover the gap.");
+        }
+    }
+
+    // Append Global Violations (Unattributed)
+    for (const auto& g : globalViolations) {
+        report.push_back("Global Violation: " + g);
+    }
+
+    return report;
+}
+
+} // namespace jres::analysis

src/analysis/solver_diagnostics.hpp

@@ -4,6 +4,7 @@
 #include <vector>
 #include <map>
 #include <string>
+#include <set>
 
 namespace jres::analysis {
 
@@ -28,4 +29,18 @@ std::string explain_assignment_failure(
     const std::vector<double>& colValues
 );
 
+/**
+ * @brief Formats raw solver slack and violation information into a human-readable report.
+ */
+std::vector<std::string> formatHumanDiagnostic(
+    const std::map<int, jres::internal::SlackInfo>& slackInfo,
+    const std::set<int>& unavailableVars,
+    const std::map<std::pair<std::string, int>, int>& driverWorkVars,
+    const std::map<std::pair<std::string, int>, int>& spotterWorkVars,
+    const std::vector<double>& colValues,
+    const jres::internal::SolverInput& input,
+    const std::vector<jres::internal::TeamMember>& driverPool,
+    const std::vector<jres::internal::TeamMember>& spotterPool
+);
+
 } // namespace jres::analysis

src/jres_standard_solver.cpp

@@ -388,25 +388,18 @@ jres::internal::SolverOutput JresStandardSolver::solve()
     const auto& solution = m_highs->getSolution();
     const std::vector<double>& colValues = solution.col_value;
 
-    // Check Slacks (Covers both Drivers and Spotters in Integrated mode)
-    for (const auto& [varIdx, info] : m_slackInfo) {
-        if (varIdx < colValues.size() && colValues[varIdx] > 0.001) {
-            std::ostringstream ss;
-            ss << "Violation: " << info.type << " for " << info.memberName;
-            if (info.stintIndex >= 0) {
-               ss << " at Stint " << info.stintIndex;
-            }
-            ss << " (Value: " << colValues[varIdx] << ")";
-            output.diagnosis.push_back(ss.str());
-        }
-    }
-    
-    // Check Unavailable Assignments
-    for (int varIdx : m_unavailableVars) {
-         if (varIdx < colValues.size() && colValues[varIdx] > 0.5) {
-             // We can defer detailed message generation to the loop below
-         }
-    }
+    // Use human-readable diagnostic formatter
+    auto formattedDiags = jres::analysis::formatHumanDiagnostic(
+        m_slackInfo,
+        m_unavailableVars,
+        m_driverWorkVars,
+        m_spotterWorkVars,
+        colValues,
+        m_input,
+        m_driverPool,
+        m_spotterPool
+    );
+    output.diagnosis.insert(output.diagnosis.end(), formattedDiags.begin(), formattedDiags.end());
 
     for (size_t s = 0; s < m_input.stints.size(); ++s) {
         jres::internal::ScheduleEntry entry;
@@ -422,10 +415,6 @@ jres::internal::SolverOutput JresStandardSolver::solve()
                 int idx = m_driverWorkVars.at({p.name, (int)s});
                 if (colValues[idx] > 0.5) {
                     entry.driver = p.name;
-                    if (m_unavailableVars.count(idx)) {
-                        output.diagnosis.push_back("Violation: Unavailable Driver " + p.name + " assigned to Stint " + std::to_string(s));
-                        output.diagnosis.push_back(jres::analysis::explain_assignment_failure((int)s, p.name, m_input, m_driverPool, m_driverWorkVars, colValues));
-                    }
                     break;
                 }
             }
@@ -438,9 +427,6 @@ jres::internal::SolverOutput JresStandardSolver::solve()
                     int idx = m_spotterWorkVars.at({p.name, (int)s});
                     if (colValues[idx] > 0.5) {
                         entry.spotter = p.name;
-                        if (m_unavailableVars.count(idx)) {
-                            output.diagnosis.push_back("Violation: Unavailable Spotter " + p.name + " assigned to Stint " + std::to_string(s));
-                        }
                         break;
                     }
                 }

test/test_availability_boundaries.cpp

@@ -30,7 +30,7 @@ TEST(AvailabilityBoundaryTest, StintEndsExactlyAtUnavailableStart) {
     JresSolverOutput* output = solve_race_schedule(input, &options);
     bool hasViolation = false;
     for (int i = 0; i < output->diagnosis_len; ++i) {
-        if (std::string(output->diagnosis[i]).find("Violation: Unavailable Driver") != std::string::npos) hasViolation = true;
+        if (std::string(output->diagnosis[i]).find("No one could drive without being Unavailable") != std::string::npos) hasViolation = true;
     }
 
     EXPECT_FALSE(hasViolation);
@@ -57,7 +57,7 @@ TEST(AvailabilityBoundaryTest, StintOverlapsUnavailableByOneMinute) {
     JresSolverOutput* output = solve_race_schedule(input, &options);
     bool hasViolation = false;
     for (int i = 0; i < output->diagnosis_len; ++i) {
-        if (std::string(output->diagnosis[i]).find("Violation: Unavailable Driver") != std::string::npos) hasViolation = true;
+        if (std::string(output->diagnosis[i]).find("No one could drive without being Unavailable") != std::string::npos) hasViolation = true;
     }
 
     EXPECT_TRUE(hasViolation);

test/test_diagnosis.cpp

@@ -63,12 +63,12 @@ namespace {
         bool found = false;
         for (int i = 0; i < output->diagnosis_len; ++i) {
             std::string msg(output->diagnosis[i]);
-            if (msg.find("Violation: Unavailable Spotter") != std::string::npos) {
+            if (msg.find("No one could spot without being Unavailable") != std::string::npos) {
                 found = true;
                 break;
             }
         }
-        EXPECT_TRUE(found) << "Expected diagnosis to contain 'Violation: Unavailable Spotter'";
+        EXPECT_TRUE(found) << "Expected diagnosis to contain 'No one could spot without being Unavailable'";
         free_jres_solver_input(input);
         free_jres_solver_output(output);
     }