split-engine.js

// Track Split Calculator Engine
// Core calculation logic and track configuration data

const SplitEngine = (() => {
    // Track configurations with standard race distances
    const TRACK_CONFIGS = {
        400: {
            name: '400m Outdoor',
            lapDistance: 400,
            races: [
                { name: '800m', distance: 800, startOffset: 0, firstLapDistance: 400 },
                { name: '1000m', distance: 1000, startOffset: 200, firstLapDistance: 200 },
                { name: '1200m', distance: 1200, startOffset: 0, firstLapDistance: 400 },
                { name: '1500m', distance: 1500, startOffset: 100, firstLapDistance: 300 },
                { name: '1600m', distance: 1600, startOffset: 0, firstLapDistance: 400 },
                { name: '1 Mile', distance: 1609.344, startOffset: -9.344, firstLapDistance: 409.344 },
                { name: '2 Mile', distance: 3218.688, startOffset: -18.688, firstLapDistance: 418.688 },
                { name: '3000m', distance: 3000, startOffset: 200, firstLapDistance: 200 },
                { name: '3200m', distance: 3200, startOffset: 0, firstLapDistance: 400 },
                { name: '5000m', distance: 5000, startOffset: 200, firstLapDistance: 200 },
                { name: '10000m', distance: 10000, startOffset: 0, firstLapDistance: 400 }
            ]
        },
        200: {
            name: '200m Indoor',
            lapDistance: 200,
            races: [
                { name: '600m', distance: 600, startOffset: 0, firstLapDistance: 200 },
                { name: '800m', distance: 800, startOffset: 0, firstLapDistance: 200 },
                { name: '1000m', distance: 1000, startOffset: 0, firstLapDistance: 200 },
                { name: '1200m', distance: 1200, startOffset: 0, firstLapDistance: 200 },
                { name: '1500m', distance: 1500, startOffset: 100, firstLapDistance: 100 },
                { name: '1600m', distance: 1600, startOffset: 0, firstLapDistance: 200 },
                { name: '1 Mile', distance: 1609.344, startOffset: -9.344, firstLapDistance: 209.344 },
                { name: '2 Mile', distance: 3218.688, startOffset: -18.688, firstLapDistance: 218.688 },
                { name: '3000m', distance: 3000, startOffset: 0, firstLapDistance: 200 },
                { name: '3200m', distance: 3200, startOffset: 0, firstLapDistance: 200 },
                { name: '5000m', distance: 5000, startOffset: 0, firstLapDistance: 200 },
                { name: '10000m', distance: 10000, startOffset: 0, firstLapDistance: 200 }
            ]
        }
    };

    // Calculate race configuration based on inputs
    function calculateRaceConfig(trackSize, raceName, goalTimeSeconds) {
        const track = TRACK_CONFIGS[trackSize];
        if (!track) throw new Error('Invalid track size');

        const race = track.races.find(r => r.name === raceName);
        if (!race) throw new Error('Invalid race distance');

        const { distance, firstLapDistance } = race;
        const lapDistance = track.lapDistance;
        
        // Calculate number of laps
        const remainingDistance = distance - firstLapDistance;
        const fullLaps = Math.floor(remainingDistance / lapDistance);
        const totalLaps = 1 + fullLaps + (remainingDistance % lapDistance > 0 ? 1 : 0);
        
        // Calculate last lap distance if partial
        const lastLapDistance = remainingDistance % lapDistance || lapDistance;
        
        // Calculate even split per full lap (400m or 200m)
        const evenSplitPerLap = (goalTimeSeconds / distance) * lapDistance;
        
        // Calculate target splits for each lap
        const laps = [];
        let cumulativeTime = 0;
        
        for (let i = 1; i <= totalLaps; i++) {
            let currentLapDistance;
            if (i === 1) {
                currentLapDistance = firstLapDistance;
            } else if (i === totalLaps && lastLapDistance !== track.lapDistance) {
                currentLapDistance = lastLapDistance;
            } else {
                currentLapDistance = track.lapDistance;
            }
            
            const targetSplit = (goalTimeSeconds / distance) * currentLapDistance;
            cumulativeTime += targetSplit;
            
            laps.push({
                lapNumber: i,
                distance: currentLapDistance,
                targetSplit: targetSplit,
                targetCumulative: cumulativeTime,
                actualSplit: null,
                actualCumulative: null,
                difference: null,
                isFastest: false,
                isSlowest: false
            });
        }
        
        return {
            trackSize,
            trackName: track.name,
            raceName: race.name,
            raceDistance: distance,
            goalTimeSeconds,
            lapDistance: track.lapDistance,
            totalLaps,
            firstLapDistance,
            lastLapDistance,
            evenSplitPerLap,
            laps
        };
    }

    // Record a lap split
    function recordLapSplit(raceConfig, lapNumber, actualTime) {
        if (lapNumber < 1 || lapNumber > raceConfig.totalLaps) {
            throw new Error('Invalid lap number');
        }
        
        const lap = raceConfig.laps[lapNumber - 1];
        const previousLap = lapNumber > 1 ? raceConfig.laps[lapNumber - 2] : null;
        
        // Calculate actual split time
        const actualCumulative = actualTime;
        const actualSplit = previousLap 
            ? actualCumulative - previousLap.actualCumulative 
            : actualCumulative;
        
        // Calculate difference (positive = slow, negative = fast)
        const difference = Math.round(actualSplit - lap.targetSplit);
        
        // Update lap data
        lap.actualSplit = actualSplit;
        lap.actualCumulative = actualCumulative;
        lap.difference = difference;
        
        // Update fastest/slowest lap markers (only for completed laps with full distance)
        updateFastestSlowest(raceConfig);
        
        return {
            lapNumber,
            actualSplit,
            actualCumulative,
            targetSplit: lap.targetSplit,
            difference,
            isComplete: lapNumber === raceConfig.totalLaps
        };
    }

    // Update fastest and slowest lap markers
    function updateFastestSlowest(raceConfig) {
        // Reset all markers
        raceConfig.laps.forEach(lap => {
            lap.isFastest = false;
            lap.isSlowest = false;
        });
        
        // Find completed laps with actual splits
        const completedLaps = raceConfig.laps.filter(lap => lap.actualSplit !== null);
        if (completedLaps.length < 2) return; // Need at least 2 laps to compare
        
        // Find fastest and slowest
        let fastest = completedLaps[0];
        let slowest = completedLaps[0];
        
        completedLaps.forEach(lap => {
            if (lap.actualSplit < fastest.actualSplit) fastest = lap;
            if (lap.actualSplit > slowest.actualSplit) slowest = lap;
        });
        
        // Mark them (only if they're different)
        if (fastest !== slowest) {
            fastest.isFastest = true;
            slowest.isSlowest = true;
        }
    }

    // Undo last recorded lap
    function undoLastLap(raceConfig) {
        // Find the last completed lap
        const lastCompletedLapIndex = raceConfig.laps.findIndex((lap, index) => {
            return lap.actualSplit !== null && 
                   (index === raceConfig.laps.length - 1 || raceConfig.laps[index + 1].actualSplit === null);
        });
        
        if (lastCompletedLapIndex === -1) {
            return null; // No laps to undo
        }
        
        const lap = raceConfig.laps[lastCompletedLapIndex];
        lap.actualSplit = null;
        lap.actualCumulative = null;
        lap.difference = null;
        lap.isFastest = false;
        lap.isSlowest = false;
        
        // Update fastest/slowest markers
        updateFastestSlowest(raceConfig);
        
        return lastCompletedLapIndex + 1; // Return lap number
    }

    // Calculate race statistics
    function calculateRaceStats(raceConfig) {
        const completedLaps = raceConfig.laps.filter(lap => lap.actualSplit !== null);
        if (completedLaps.length === 0) return null;
        
        const lastLap = completedLaps[completedLaps.length - 1];
        const finalTime = lastLap.actualCumulative;
        const goalTime = raceConfig.goalTimeSeconds;
        const timeDifference = finalTime - goalTime;
        
        // Average lap pace (for standard lap distance)
        const totalSplitTime = completedLaps.reduce((sum, lap) => sum + lap.actualSplit, 0);
        const avgLapPace = totalSplitTime / completedLaps.length;
        
        // Average per-mile pace (time for 1609.344m)
        const avgMilePace = (finalTime / raceConfig.raceDistance) * 1609.344;
        
        // Average per-kilometer pace (time for 1000m)
        const avgKmPace = (finalTime / raceConfig.raceDistance) * 1000;
        
        // Find fastest and slowest laps
        const fastest = completedLaps.reduce((min, lap) => 
            lap.actualSplit < min.actualSplit ? lap : min
        );
        const slowest = completedLaps.reduce((max, lap) => 
            lap.actualSplit > max.actualSplit ? lap : max
        );
        
        return {
            finalTime,
            goalTime,
            timeDifference,
            avgLapPace,
            avgMilePace,
            avgKmPace,
            fastestLap: fastest.lapNumber,
            fastestTime: fastest.actualSplit,
            slowestLap: slowest.lapNumber,
            slowestTime: slowest.actualSplit,
            isComplete: completedLaps.length === raceConfig.totalLaps
        };
    }

    // Format time in seconds to MM:SS.T format
    function formatTime(seconds, includeDecimal = true) {
        if (seconds === null || seconds === undefined || isNaN(seconds)) {
            return '--';
        }
        const mins = Math.floor(seconds / 60);
        const secs = seconds % 60;
        
        if (includeDecimal) {
            return `${mins}:${secs.toFixed(1).padStart(4, '0')}`;
        } else {
            return `${mins}:${Math.floor(secs).toString().padStart(2, '0')}`;
        }
    }

    // Parse time string to seconds
    function parseTime(minutes, seconds) {
        return parseInt(minutes) * 60 + parseInt(seconds);
    }

    // Get pace category (fast, target, slow)
    function getPaceCategory(difference) {
        if (difference < -2) return 'fast';
        if (difference > 2) return 'slow';
        return 'target';
    }

    // Public API
    return {
        TRACK_CONFIGS,
        calculateRaceConfig,
        recordLapSplit,
        undoLastLap,
        calculateRaceStats,
        formatTime,
        parseTime,
        getPaceCategory
    };
})();

// Export for use in other modules
if (typeof module !== 'undefined' && module.exports) {
    module.exports = SplitEngine;
}