Crash Risk Assessment API

Authorization: Bearer YOUR_API_KEY

POST /api/v1/analytics/crash-risk

{
  "weather": "clear|rain|snow|fog|storm",
  "visibility": 10.0,
  "temperature": 22.5,
  "wind_speed": 15.2,
  "precipitation": 0.0,
  "time_of_day": "morning|afternoon|evening|night"
}

{
  "road_type": "highway|urban|rural|residential",
  "surface_condition": "dry|wet|icy|snowy",
  "traffic_density": "light|moderate|heavy|congested",
  "construction": false,
  "speed_limit": 60
}

{
  "success": true,
  "data": {
    "trip_id": "trip_12345",
    "driver_id": "driver_789",
    "vehicle_id": "vehicle_456",
    "assessment_timestamp": "2024-03-15T14:30:00Z",
    "risk_analysis": {
      "overall_risk_score": 23.7,
      "risk_level": "low",
      "confidence_interval": [18.2, 29.1],
      "prediction_accuracy": 94.3
    },
    "risk_factors": [
      {
        "factor": "speed_variation",
        "impact": 8.5,
        "severity": "medium",
        "description": "Frequent speed changes detected"
      },
      {
        "factor": "harsh_braking",
        "impact": 12.3,
        "severity": "high",
        "description": "Multiple harsh braking events"
      },
      {
        "factor": "weather_conditions",
        "impact": 3.2,
        "severity": "low",
        "description": "Light rain reducing visibility"
      }
    ],
    "predictions": {
      "next_15_minutes": {
        "risk_score": 26.1,
        "risk_level": "low",
        "key_factors": ["upcoming_intersection", "traffic_density"]
      },
      "next_hour": {
        "risk_score": 31.8,
        "risk_level": "medium",
        "key_factors": ["rush_hour_traffic", "weather_deterioration"]
      }
    },
    "recommendations": [
      {
        "action": "reduce_speed",
        "priority": "medium",
        "description": "Reduce speed by 10-15% to improve safety margin",
        "expected_impact": "15% risk reduction"
      },
      {
        "action": "increase_following_distance",
        "priority": "high",
        "description": "Maintain 4-second following distance",
        "expected_impact": "22% risk reduction"
      }
    ],
    "benchmarking": {
      "driver_average": 28.5,
      "fleet_average": 31.2,
      "industry_average": 35.8,
      "percentile_rank": 25
    }
  }
}

// Fleet-wide risk monitoring
async function monitorFleetRisk(activeTrips) {
  const riskAssessments = await Promise.all(
    activeTrips.map(trip => sdk.analytics.assessCrashRisk({
      trip_id: trip.id,
      driver_id: trip.driver_id,
      vehicle_id: trip.vehicle_id,
      analysis_window: "real-time"
    }))
  );
  
  // Identify high-risk trips
  const highRiskTrips = riskAssessments.filter(
    assessment => assessment.risk_analysis.overall_risk_score > 70
  );
  
  // Send immediate alerts for critical situations
  for (const assessment of highRiskTrips) {
    await sendEmergencyAlert({
      trip_id: assessment.trip_id,
      risk_score: assessment.risk_analysis.overall_risk_score,
      recommendations: assessment.recommendations,
      location: await getLatestLocation(assessment.trip_id)
    });
  }
  
  return {
    total_trips: activeTrips.length,
    high_risk_trips: highRiskTrips.length,
    average_risk: riskAssessments.reduce((sum, a) => 
      sum + a.risk_analysis.overall_risk_score, 0) / riskAssessments.length
  };
}

async def calculate_insurance_premium(driver_id: str, vehicle_id: str, policy_period_days: int):
    # Analyze historical risk patterns
    risk_history = []
    for i in range(30):  # Last 30 trips
        try:
            assessment = await sdk.analytics.assess_crash_risk(
                trip_id=f"historical_trip_{i}",
                driver_id=driver_id,
                vehicle_id=vehicle_id,
                analysis_window="last_day"
            )
            risk_history.append(assessment.risk_analysis.overall_risk_score)
        except Exception:
            continue
    
    if not risk_history:
        return {"error": "Insufficient historical data"}
    
    # Calculate risk metrics
    avg_risk = sum(risk_history) / len(risk_history)
    max_risk = max(risk_history)
    risk_variability = np.std(risk_history)
    
    # Base premium calculation
    base_premium = 1000  # Base annual premium
    risk_multiplier = 1 + (avg_risk / 100)  # Risk adjustment
    variability_penalty = 1 + (risk_variability / 200)  # Consistency penalty
    
    adjusted_premium = base_premium * risk_multiplier * variability_penalty
    period_premium = (adjusted_premium / 365) * policy_period_days
    
    return {
        "base_premium": base_premium,
        "adjusted_premium": adjusted_premium,
        "period_premium": period_premium,
        "risk_metrics": {
            "average_risk_score": avg_risk,
            "maximum_risk_score": max_risk,
            "risk_variability": risk_variability,
            "risk_grade": get_risk_grade(avg_risk)
        },
        "premium_factors": {
            "risk_multiplier": risk_multiplier,
            "variability_penalty": variability_penalty
        }
    }

func schedulePredictiveMaintenance(ctx context.Context, client *bookovia.Client, fleetVehicles []Vehicle) error {
    var maintenanceSchedule []MaintenanceTask
    
    for _, vehicle := range fleetVehicles {
        // Get recent trips for this vehicle
        trips, err := client.Trips.GetVehicleTrips(ctx, vehicle.ID, 7) // Last 7 days
        if err != nil {
            continue
        }
        
        var totalRiskScore float64
        var highRiskEvents int
        
        for _, trip := range trips {
            assessment, err := client.Analytics.AssessCrashRisk(ctx, &bookovia.CrashRiskRequest{
                TripID:    trip.ID,
                DriverID:  trip.DriverID,
                VehicleID: vehicle.ID,
            })
            
            if err != nil {
                continue
            }
            
            totalRiskScore += assessment.RiskAnalysis.OverallRiskScore
            
            // Check for mechanical risk factors
            for _, factor := range assessment.RiskFactors {
                switch factor.Factor {
                case "brake_performance", "tire_condition", "engine_stress":
                    if factor.Severity == "high" {
                        highRiskEvents++
                    }
                }
            }
        }
        
        if len(trips) == 0 {
            continue
        }
        
        avgRiskScore := totalRiskScore / float64(len(trips))
        
        // Schedule maintenance based on risk patterns
        if avgRiskScore > 60 || highRiskEvents > 3 {
            priority := "high"
            if avgRiskScore > 80 {
                priority = "critical"
            }
            
            maintenanceSchedule = append(maintenanceSchedule, MaintenanceTask{
                VehicleID:   vehicle.ID,
                Priority:    priority,
                Type:        "safety_inspection",
                Reason:      fmt.Sprintf("High crash risk detected (%.1f avg score, %d mechanical risk events)", avgRiskScore, highRiskEvents),
                ScheduledBy: time.Now().Add(24 * time.Hour), // Within 24 hours
            })
        }
    }
    
    // Submit maintenance schedule
    return submitMaintenanceSchedule(ctx, maintenanceSchedule)
}

class DriverCoachingService {
    private let sdk = BookoviaSDK(apiKey: "your-api-key")
    
    func generatePersonalizedCoaching(for driverId: String, recentTrips: [String]) async throws -> CoachingProgram {
        var riskPatterns: [String: Int] = [:]
        var totalRiskScore: Double = 0
        var assessmentCount = 0
        
        // Analyze recent driving patterns
        for tripId in recentTrips {
            do {
                let assessment = try await sdk.analytics.assessCrashRisk(
                    CrashRiskRequest(
                        tripId: tripId,
                        driverId: driverId,
                        vehicleId: "vehicle_id",
                        analysisWindow: "complete_trip"
                    )
                )
                
                totalRiskScore += assessment.riskAnalysis.overallRiskScore
                assessmentCount += 1
                
                // Track risk factor patterns
                for factor in assessment.riskFactors {
                    riskPatterns[factor.factor, default: 0] += 1
                }
                
            } catch {
                continue
            }
        }
        
        guard assessmentCount > 0 else {
            throw CoachingError.insufficientData
        }
        
        let avgRiskScore = totalRiskScore / Double(assessmentCount)
        
        // Generate personalized coaching modules
        var coachingModules: [CoachingModule] = []
        
        // Address most frequent risk factors
        let sortedPatterns = riskPatterns.sorted { $0.value > $1.value }
        
        for (factor, frequency) in sortedPatterns.prefix(3) {
            let module = generateCoachingModule(for: factor, frequency: frequency)
            coachingModules.append(module)
        }
        
        // Add progressive difficulty based on risk level
        let difficulty = getDifficultyLevel(for: avgRiskScore)
        
        return CoachingProgram(
            driverId: driverId,
            overallRiskScore: avgRiskScore,
            targetRiskScore: max(20.0, avgRiskScore * 0.7), // 30% improvement target
            modules: coachingModules,
            difficulty: difficulty,
            estimatedDuration: TimeInterval(coachingModules.count * 1800), // 30 min per module
            progressTracking: ProgressTracking(
                checkpoints: generateCheckpoints(for: coachingModules),
                assessmentFrequency: .weekly
            )
        )
    }
    
    private func generateCoachingModule(for riskFactor: String, frequency: Int) -> CoachingModule {
        switch riskFactor {
        case "harsh_braking":
            return CoachingModule(
                title: "Smooth Braking Techniques",
                description: "Learn anticipation and gradual braking methods",
                exercises: [
                    "Following distance simulation",
                    "Progressive braking practice",
                    "Hazard anticipation training"
                ],
                targetImprovement: 25.0
            )
        case "speed_variation":
            return CoachingModule(
                title: "Consistent Speed Management", 
                description: "Maintain steady speeds for safer driving",
                exercises: [
                    "Cruise control optimization",
                    "Traffic flow adaptation",
                    "Speed limit awareness"
                ],
                targetImprovement: 20.0
            )
        default:
            return CoachingModule(
                title: "General Safety Improvement",
                description: "Overall driving safety enhancement",
                exercises: ["Defensive driving techniques"],
                targetImprovement: 15.0
            )
        }
    }
}

{
  "success": false,
  "error": {
    "code": "INSUFFICIENT_DATA",
    "message": "Not enough driving data available for accurate crash risk assessment",
    "details": {
      "minimum_data_points": 10,
      "available_data_points": 3,
      "suggestion": "Continue driving for more accurate assessment"
    }
  }
}