Get Safety Score

// Comprehensive driver performance management system
class DriverPerformanceManager {
  constructor(client) {
    this.client = client;
    this.performanceThresholds = {
      excellent: 90,
      good: 80,
      acceptable: 70,
      needsImprovement: 60
    };
  }
  
  async generateDriverPerformanceReport(driverId, evaluationPeriod = '30d') {
    // Get all trips for the driver in the period
    const trips = await this.getDriverTrips(driverId, evaluationPeriod);
    
    // Analyze safety scores for all trips
    const safetyAnalyses = await Promise.all(
      trips.map(trip => 
        this.client.analytics.getSafetyScore(trip.trip_id, {
          includeBreakdown: true,
          includeBenchmarks: true,
          includeRecommendations: true
        })
      )
    );
    
    // Generate comprehensive performance analysis
    return this.generatePerformanceAnalysis(driverId, safetyAnalyses, evaluationPeriod);
  }
  
  generatePerformanceAnalysis(driverId, safetyAnalyses, period) {
    const scores = safetyAnalyses.map(a => a.overallSafetyScore);
    const currentAverage = scores.reduce((sum, score) => sum + score, 0) / scores.length;
    
    // Trend analysis
    const trendAnalysis = this.calculatePerformanceTrend(scores);
    
    // Behavior analysis
    const behaviorAnalysis = this.analyzeBehaviorPatterns(safetyAnalyses);
    
    // Risk assessment
    const riskAssessment = this.assessRiskProfile(safetyAnalyses);
    
    // Generate coaching recommendations
    const coachingPlan = this.generateCoachingPlan(behaviorAnalysis, riskAssessment);
    
    return {
      driverId,
      evaluationPeriod: period,
      overallPerformance: {
        currentScore: Math.round(currentAverage),
        grade: this.calculateGrade(currentAverage),
        performanceLevel: this.getPerformanceLevel(currentAverage),
        trend: trendAnalysis,
        totalTripsAnalyzed: safetyAnalyses.length
      },
      behaviorAnalysis,
      riskAssessment,
      coachingPlan,
      benchmarkComparison: this.extractBenchmarkData(safetyAnalyses),
      nextEvaluationDate: this.calculateNextEvaluationDate(currentAverage, trendAnalysis.direction)
    };
  }
  
  calculatePerformanceTrend(scores) {
    if (scores.length < 3) return { direction: 'insufficient_data', stability: 'unknown' };
    
    const recentScores = scores.slice(-Math.min(5, scores.length));
    const olderScores = scores.slice(0, Math.min(5, scores.length));
    
    const recentAverage = recentScores.reduce((sum, s) => sum + s, 0) / recentScores.length;
    const olderAverage = olderScores.reduce((sum, s) => sum + s, 0) / olderScores.length;
    
    const difference = recentAverage - olderAverage;
    const standardDeviation = this.calculateStandardDeviation(scores);
    
    let direction;
    if (Math.abs(difference) < 2) direction = 'stable';
    else if (difference > 0) direction = 'improving';
    else direction = 'declining';
    
    return {
      direction,
      changePoints: Math.abs(Math.round(difference)),
      stability: standardDeviation < 5 ? 'consistent' : standardDeviation < 10 ? 'variable' : 'volatile',
      volatility: standardDeviation
    };
  }
  
  analyzeBehaviorPatterns(safetyAnalyses) {
    const behaviors = {
      acceleration: [],
      braking: [],
      cornering: [],
      speedCompliance: [],
      followingDistance: [],
      distraction: []
    };
    
    // Aggregate behavior scores
    safetyAnalyses.forEach(analysis => {
      const breakdown = analysis.scoreBreakdown;
      behaviors.acceleration.push(breakdown.accelerationScore);
      behaviors.braking.push(breakdown.brakingScore);
      behaviors.cornering.push(breakdown.corneringScore);
      behaviors.speedCompliance.push(breakdown.speedComplianceScore);
      behaviors.followingDistance.push(breakdown.followingDistanceScore);
      behaviors.distraction.push(breakdown.distractionScore);
    });
    
    // Calculate averages and identify strengths/weaknesses
    const behaviorSummary = {};
    const strengths = [];
    const weaknesses = [];
    
    for (const [behavior, scores] of Object.entries(behaviors)) {
      const average = scores.reduce((sum, s) => sum + s, 0) / scores.length;
      const trend = this.calculateBehaviorTrend(scores);
      
      behaviorSummary[behavior] = {
        averageScore: Math.round(average),
        trend: trend.direction,
        consistency: trend.consistency,
        grade: this.calculateGrade(average)
      };
      
      if (average >= 85) strengths.push(behavior);
      if (average < 75) weaknesses.push(behavior);
    }
    
    return {
      behaviorScores: behaviorSummary,
      strengths,
      weaknesses,
      primaryFocusArea: weaknesses[0] || null
    };
  }
  
  assessRiskProfile(safetyAnalyses) {
    const allRiskFactors = [];
    const riskFrequency = {};
    let totalScoreImpact = 0;
    
    safetyAnalyses.forEach(analysis => {
      analysis.riskFactors.forEach(risk => {
        allRiskFactors.push(risk);
        riskFrequency[risk.factorType] = (riskFrequency[risk.factorType] || 0) + 1;
        totalScoreImpact += risk.scoreImpact;
      });
    });
    
    // Calculate risk metrics
    const avgRisksPerTrip = allRiskFactors.length / safetyAnalyses.length;
    const mostCommonRisk = Object.entries(riskFrequency)
      .sort(([,a], [,b]) => b - a)[0];
    
    // Determine risk level
    let riskLevel;
    if (avgRisksPerTrip < 0.5) riskLevel = 'low';
    else if (avgRisksPerTrip < 1.5) riskLevel = 'moderate';
    else if (avgRisksPerTrip < 3) riskLevel = 'high';
    else riskLevel = 'critical';
    
    return {
      riskLevel,
      avgRisksPerTrip: Math.round(avgRisksPerTrip * 10) / 10,
      totalRiskIncidents: allRiskFactors.length,
      avgScoreImpactPerTrip: Math.round(totalScoreImpact / safetyAnalyses.length),
      mostCommonRiskType: mostCommonRisk ? mostCommonRisk[0] : null,
      riskFrequencyDistribution: riskFrequency,
      recentRiskTrend: this.analyzeRiskTrend(safetyAnalyses)
    };
  }
  
  generateCoachingPlan(behaviorAnalysis, riskAssessment) {
    const coachingPlan = {
      priority: this.determineCoachingPriority(behaviorAnalysis, riskAssessment),
      focusAreas: [],
      recommendedActions: [],
      timeframe: '',
      expectedImprovement: ''
    };
    
    // Identify focus areas based on weaknesses
    if (behaviorAnalysis.weaknesses.length > 0) {
      coachingPlan.focusAreas = behaviorAnalysis.weaknesses.slice(0, 2); // Top 2 weaknesses
    }
    
    // Add risk-based focus areas
    if (riskAssessment.mostCommonRiskType) {
      coachingPlan.focusAreas.push(`risk_reduction_${riskAssessment.mostCommonRiskType}`);
    }
    
    // Generate specific actions
    coachingPlan.recommendedActions = this.generateSpecificActions(
      behaviorAnalysis.weaknesses,
      riskAssessment.mostCommonRiskType,
      coachingPlan.priority
    );
    
    // Set timeframe and expectations
    switch (coachingPlan.priority) {
      case 'high':
        coachingPlan.timeframe = '2-3 weeks';
        coachingPlan.expectedImprovement = '5-10 points';
        break;
      case 'medium':
        coachingPlan.timeframe = '1-2 months';
        coachingPlan.expectedImprovement = '3-7 points';
        break;
      case 'low':
        coachingPlan.timeframe = '2-3 months';
        coachingPlan.expectedImprovement = '2-5 points';
        break;
    }
    
    return coachingPlan;
  }
  
  // Helper methods
  calculateStandardDeviation(values) {
    const mean = values.reduce((sum, val) => sum + val, 0) / values.length;
    const variance = values.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / values.length;
    return Math.sqrt(variance);
  }
  
  calculateGrade(score) {
    if (score >= 95) return 'A+';
    if (score >= 90) return 'A';
    if (score >= 85) return 'B+';
    if (score >= 80) return 'B';
    if (score >= 75) return 'C+';
    if (score >= 70) return 'C';
    if (score >= 65) return 'D+';
    if (score >= 60) return 'D';
    return 'F';
  }
  
  getPerformanceLevel(score) {
    if (score >= this.performanceThresholds.excellent) return 'excellent';
    if (score >= this.performanceThresholds.good) return 'good';
    if (score >= this.performanceThresholds.acceptable) return 'acceptable';
    return 'needs_improvement';
  }
}

// Usage example
const performanceManager = new DriverPerformanceManager(client);

const driverReport = await performanceManager.generateDriverPerformanceReport('driver_456', '30d');

console.log('Driver Performance Report');
console.log('========================');
console.log(`Current Score: ${driverReport.overallPerformance.currentScore} (${driverReport.overallPerformance.grade})`);
console.log(`Performance Level: ${driverReport.overallPerformance.performanceLevel}`);
console.log(`Trend: ${driverReport.overallPerformance.trend.direction}`);

console.log('\nBehavior Analysis:');
console.log(`Strengths: ${driverReport.behaviorAnalysis.strengths.join(', ') || 'None identified'}`);
console.log(`Weaknesses: ${driverReport.behaviorAnalysis.weaknesses.join(', ') || 'None identified'}`);

console.log('\nRisk Assessment:');
console.log(`Risk Level: ${driverReport.riskAssessment.riskLevel}`);
console.log(`Avg Risks per Trip: ${driverReport.riskAssessment.avgRisksPerTrip}`);

console.log('\nCoaching Recommendations:');
console.log(`Priority: ${driverReport.coachingPlan.priority}`);
console.log(`Timeframe: ${driverReport.coachingPlan.timeframe}`);
console.log(`Expected Improvement: ${driverReport.coachingPlan.expectedImprovement}`);