fix: evoting IRV logic

Author: coodos

platforms/eVoting/src/app/(app)/[id]/page.tsx

@@ -477,12 +477,16 @@ export default function Vote({ params }: { params: Promise<{ id: string }> }) {
                                                     isWinner = result.totalPoints === Math.max(...resultsData.results.map(r => r.totalPoints));
                                                     percentage = resultsData.totalVotes > 0 ? (result.totalPoints / resultsData.results.reduce((sum, r) => sum + r.totalPoints, 0)) * 100 : 0;
                                                 } else if (resultsData.mode === "rank") {
-                                                    // Rank-based voting: show percentage only
-                                                    displayValue = `${result.totalScore} points`;
-                                                    isWinner = result.totalScore === Math.max(...resultsData.results.map(r => r.totalScore));
-                                                    percentage = resultsData.totalVotes > 0 ? (result.totalScore / resultsData.results.reduce((sum, r) => sum + r.totalScore, 0)) * 100 : 0;
-                                                    // For rank voting, just show the percentage in the display
-                                                    displayValue = `${percentage.toFixed(1)}%`;
+                                                    // Rank-based voting: show winner status instead of misleading vote counts
+                                                    displayValue = result.isWinner ? "🏆 Winner" : "Eliminated";
+                                                    isWinner = result.isWinner || false; // Use the isWinner flag from backend
+                                                    percentage = result.percentage || 0; // Use the percentage from backend
+                                                    
+                                                    // Check if there might have been a tie situation
+                                                    if (resultsData.irvDetails && resultsData.irvDetails.rounds.length > 1) {
+                                                        // If multiple rounds, there might have been ties
+                                                        console.log(`[IRV Debug] Poll had ${resultsData.irvDetails.rounds.length} rounds, check console for tie warnings`);
+                                                    }
                                                 } else {
                                                     // Normal voting: show votes and percentage
                                                     displayValue = `${result.votes} votes`;
@@ -511,7 +515,7 @@ export default function Vote({ params }: { params: Promise<{ id: string }> }) {
                                                                 )}
                                                             </div>
                                                             <span className="text-sm text-gray-600">
-                                                                {displayValue} ({percentage.toFixed(1)}%)
+                                                                {resultsData.mode === "rank" ? displayValue : `${displayValue} (${percentage.toFixed(1)}%)`}
                                                             </span>
                                                         </div>
                                                         <div className="w-full bg-gray-200 rounded-full h-2">

platforms/eVoting/src/lib/pollApi.ts

@@ -63,11 +63,25 @@ export interface PollResults {
   totalVotes: number;
   totalEligibleVoters?: number;
   turnout?: number;
+  mode?: "normal" | "point" | "rank";
   results: {
     option: string;
     votes: number;
     percentage: number;
+    // Additional fields for different voting modes
+    totalPoints?: number;
+    averagePoints?: number;
+    isWinner?: boolean;
+    finalRound?: number;
   }[];
+  // Detailed IRV info for rank mode
+  irvDetails?: {
+    winnerIndex: number | null;
+    winnerOption?: string;
+    rounds: any[];
+    rejectedBallots: number;
+    rejectedReasons: any[];
+  };
 }
 
 export interface SigningSession {

platforms/evoting-api/src/services/VoteService.ts

@@ -296,13 +296,56 @@ export class VoteService {
       // Calculate rank-based voting results using Instant Runoff Voting (IRV)
       const irvResult = this.tallyIRV(votes, poll.options);
 
+      // Convert IRV results to the same format as other voting modes for consistent frontend rendering
+      let results;
+      if (irvResult.winnerIndex !== null) {
+        // Create results array with winner first, then others in order
+        results = poll.options.map((option, index) => {
+          if (index === irvResult.winnerIndex) {
+            return {
+              option,
+              votes: votes.length, // All votes contributed to the winner
+              percentage: 100, // Winner gets 100% in final round
+              isWinner: true,
+              finalRound: irvResult.rounds.length
+            };
+          } else {
+            return {
+              option,
+              votes: 0, // Eliminated candidates get 0 votes in final round
+              percentage: 0,
+              isWinner: false,
+              finalRound: irvResult.rounds.length
+            };
+          }
+        });
+        
+        // Sort: winner first, then by original option order
+        results.sort((a, b) => {
+          if (a.isWinner && !b.isWinner) return -1;
+          if (!a.isWinner && b.isWinner) return 1;
+          return poll.options.indexOf(a.option) - poll.options.indexOf(b.option);
+        });
+      } else {
+        // No winner determined, show all options with 0 votes
+        results = poll.options.map((option, index) => ({
+          option,
+          votes: 0,
+          percentage: 0,
+          isWinner: false,
+          finalRound: irvResult.rounds.length
+        }));
+      }
+      
       return {
         pollId,
         totalVotes: votes.length,
         totalEligibleVoters,
         turnout: totalEligibleVoters > 0 ? (votes.length / totalEligibleVoters) * 100 : 0,
         mode: "rank",
-        irvResult
+        results,
+        // Keep the detailed IRV info for advanced users who need it
+        irvDetails: irvResult
       };
     }
 
@@ -725,6 +768,22 @@ export class VoteService {
         rejectedReasons
       };
     }
+    
+    // Check for initial tie (all candidates have same first-choice votes)
+    const firstRoundCounts: Record<number, number> = {};
+    validBallots.forEach(ballot => {
+      const firstChoice = ballot.ranking[0];
+      if (firstChoice !== undefined) {
+        firstRoundCounts[firstChoice] = (firstRoundCounts[firstChoice] || 0) + 1;
+      }
+    });
+    
+    const firstChoiceValues = Object.values(firstRoundCounts);
+    const allSame = firstChoiceValues.length > 0 && firstChoiceValues.every(v => v === firstChoiceValues[0]);
+    
+    if (allSame && firstChoiceValues.length > 1) {
+      console.warn(`⚠️ IRV Initial Tie: All candidates have the same number of first-choice votes (${firstChoiceValues[0]}). This will result in arbitrary elimination.`);
+    }
 
     // Initialize IRV process
     let activeCandidates = Array.from({ length: numCandidates }, (_, i) => i);
@@ -745,6 +804,11 @@ export class VoteService {
           exhausted++;
         }
       }
+      
+      // Log round details for debugging
+      console.log(`[IRV Round ${round}] Vote counts:`, counts);
+      console.log(`[IRV Round ${round}] Active candidates:`, activeCandidates.map(i => `${i}:${options[i]}`));
+      console.log(`[IRV Round ${round}] Exhausted ballots:`, exhausted);
 
       const activeVotes = validBallots.length - exhausted;
       const majorityThreshold = Math.floor(activeVotes / 2) + 1;
@@ -803,6 +867,8 @@ export class VoteService {
       // Find candidate to eliminate
       const candidateToEliminate = this.findCandidateToEliminate(counts, activeCandidates, rounds);
 
+      console.log(`[IRV Round ${round}] Eliminating candidate ${candidateToEliminate} (${options[candidateToEliminate]})`);
+      
       // Update active candidates
       activeCandidates = activeCandidates.filter(c => c !== candidateToEliminate);
 
@@ -913,7 +979,9 @@ export class VoteService {
       return candidatesWithMinFirstChoice[0];
     }
 
-    // Tie-breaker 2: Lowest index
+    // Tie-breaker 2: Lowest index (arbitrary but deterministic)
+    // TODO: Consider implementing coin flip or other fair tie-breaking for production
+    console.warn(`⚠️ IRV Tie detected: Multiple candidates tied for elimination. Using arbitrary index-based tie-breaker.`);
     return Math.min(...candidatesWithMinFirstChoice);
   }