Results Calculation

// From src/services/VotingService.ts:157-166
calculateResults(electionID: string): VoteResult[] {
    const election = this.electionRepository.findById(electionID);
    if (!election) {
        throw new Error("Election not found");
    }

    // Election must be closed to view results
    if (election.status !== ElectionStatus.CLOSED) {
        throw new Error("Results only available for closed elections");
    }
    // ...
}

// From src/services/strategies/IVotingStrategy.ts:4-11
export interface VoteResult {
    candidateID: string;
    candidateName: string;
    votes: number;
    percentage: number;
    isWinner: boolean;
    isTied?: boolean; // True when multiple candidates have the same top votes
}

// From src/services/VotingService.ts:26-41
private strategyMap: Map<ElectionType, IVotingStrategy>;

constructor(...) {
    this.anonymousAdapter = new AnonymousBallotAdapter();
    this.strategyMap = new Map();
    this.strategyMap.set(ElectionType.FPTP, new FPTPStrategy());
    this.strategyMap.set(ElectionType.STV, new STVStrategy());
    this.strategyMap.set(ElectionType.AV, new AVStrategy());
    this.strategyMap.set(ElectionType.PREFERENTIAL, new STVStrategy());
}

// From src/services/strategies/FPTPStrategy.ts:6-16
calculateResults(ballots: Ballot[], candidates: Candidate[]): VoteResult[] {
    // Count votes for each candidate
    const voteCounts = new Map<string, number>();
    candidates.forEach((c) => voteCounts.set(c.candidateID, 0));

    ballots.forEach((ballot) => {
        // For FPTP, preferences array has single item
        const candidateID = ballot.preferences[0];
        const currentCount = voteCounts.get(candidateID) || 0;
        voteCounts.set(candidateID, currentCount + 1);
    });
    // ...
}

// From src/services/strategies/FPTPStrategy.ts:36-50
if (results.length > 0 && results[0].votes > 0) {
    const topVotes = results[0].votes;
    const tiedCandidates = results.filter((r) => r.votes === topVotes);

    if (tiedCandidates.length > 1) {
        // Tie detected - flag for admin resolution, no automatic winner
        tiedCandidates.forEach((r) => {
            r.isTied = true;
            r.isWinner = false;
        });
    } else {
        // Clear winner
        results[0].isWinner = true;
    }
}

// From src/services/strategies/STVStrategy.ts:10-11
const totalVotes = ballots.length;
const quota = Math.floor(totalVotes / 2) + 1; // Droop quota for single winner

// From src/services/strategies/AVStrategy.ts:7-8
const totalVotes = ballots.length;
const majority = Math.floor(totalVotes / 2) + 1;

// From src/services/strategies/AVStrategy.ts:19-67
while (activeCandidates.size > 1) {
    // Count votes at current preference level
    const roundCounts = new Map<string, number>();
    activeCandidates.forEach((c) => roundCounts.set(c, 0));

    ballotStates.forEach((bs) => {
        // Find current active preference
        while (bs.currentPreference < bs.ballot.preferences.length) {
            const choice = bs.ballot.preferences[bs.currentPreference];
            if (activeCandidates.has(choice)) {
                roundCounts.set(choice, (roundCounts.get(choice) || 0) + 1);
                break;
            }
            bs.currentPreference++;
        }
    });

    // Check for majority winner
    let winner: string | null = null;
    for (const [candidateID, votes] of roundCounts.entries()) {
        if (votes >= majority) {
            winner = candidateID;
            finalCounts = roundCounts;
            break;
        }
    }

    if (winner) break;

    // Eliminate candidate with fewest votes
    const sorted = Array.from(roundCounts.entries()).sort((a, b) => a[1] - b[1]);
    const toEliminate = sorted[0][0];
    activeCandidates.delete(toEliminate);
    finalCounts = roundCounts;
}

// From src/services/strategies/AVStrategy.ts:70-75
if (activeCandidates.size === 1) {
    const lastCandidate = Array.from(activeCandidates)[0];
    if (!finalCounts.has(lastCandidate)) {
        finalCounts.set(lastCandidate, 0);
    }
}

// From src/services/VotingService.ts:169-177
// Get ballots and candidates
const ballots = this.ballotRepository.findByElectionId(electionID);
const candidates = this.candidateRepository.findByElectionId(electionID);

const strategy = this.strategyMap.get(election.electionType);
if (!strategy) {
    throw new Error(`No voting strategy for election type: ${election.electionType}`);
}

return strategy.calculateResults(ballots, candidates);

// From src/services/VotingService.ts:183-185
getVoteCount(electionID: string): number {
    return this.ballotRepository.countByElectionId(electionID);
}

// From FPTPStrategy.ts:32
results.sort((a, b) => b.votes - a.votes);

// From STVStrategy.ts:85
results.sort((a, b) => b.votes - a.votes);

// From AVStrategy.ts:90
results.sort((a, b) => b.votes - a.votes);

// Example from FPTPStrategy.ts:27
percentage: totalVotes > 0 ? (votes / totalVotes) * 100 : 0