Making Predictions

def predict_race(self, race_features):
    """Predict winner for a new race"""
    # Get probability predictions
    rf_proba = self.rf_model.predict_proba(
        race_features[self.feature_columns]
    )[0]
    xgb_proba = self.xgb_model.predict_proba(
        race_features[self.feature_columns]
    )[0]
    
    # Average ensemble
    ensemble_proba = (rf_proba + xgb_proba) / 2
    
    return {
        'rf_probability': rf_proba[1],
        'xgb_probability': xgb_proba[1],
        'ensemble_probability': ensemble_proba[1],
        'prediction': int(ensemble_proba[1] > 0.5)
    }

@app.route('/api/predict_v2')
def predict_v2():
    if not model:
        return jsonify({'error': 'Model not loaded'}), 500
    
    # Get parameters from request
    grid = int(request.args.get('grid', 1))
    weather = request.args.get('weather', 'DRY')
    tire = request.args.get('tire', 'MEDIUM')
    circuit = request.args.get('circuit', 'STANDARD')
    
    # Build feature dictionary
    fd = {
        'GridPosition': grid,
        'Driver_AvgPosition': 3.0,
        'Driver_AvgPoints': 15.0,
        'Driver_TotalWins': 10,
        'Driver_TotalPodiums': 25,
        'Weather_Impact': 1.0 if weather=='DRY' else 1.05 if weather=='LIGHT_RAIN' else 1.15,
        'Is_Wet_Race': 0 if weather=='DRY' else 1,
        'Tire_Degradation_Rate': 0.08 if tire=='SOFT' else 0.05 if tire=='MEDIUM' else 0.03,
        'Optimal_Pit_Lap': 25 if tire=='SOFT' else 35 if tire=='MEDIUM' else 45,
        'Tire_Advantage': 1.0 if tire=='SOFT' else 0.8 if tire=='MEDIUM' else 0.6,
        'Circuit_Familiarity': 5,
        'Is_Street_Circuit': 1 if circuit=='STREET' else 0,
        'Is_High_Speed': 1 if circuit=='FAST' else 0,
        'Team_AvgPosition': 2.5,
        'Team_TotalWins': 20,
        'Team_AvgPoints': 300.0
    }
    
    # Create DataFrame and predict
    df = pd.DataFrame([fd])
    for feat in features:
        if feat not in df.columns:
            df[feat] = 0
    
    prob = model.predict_proba(df[features])[0][1]
    
    # Generate insights
    insights = f'P{grid} in {weather.lower()} on {tire.lower()} tires = '
    insights += 'Excellent podium chances!' if prob > 0.7 else \
                'Good podium chances!' if prob > 0.5 else \
                'Tough but possible!'
    
    return jsonify({
        'probability': float(prob),
        'prediction': 'Top-3 Likely' if prob > 0.5 else 'Top-3 Unlikely',
        'insights': insights
    })

def simulate_qualifying(race_info, weather):
    """Simulate qualifying to get grid positions"""
    quali_scores = {}
    
    for code, driver in DRIVERS_2026.items():
        # Base skill
        skill = driver['skill']
        
        # Apply wet skill if qualifying in rain
        if weather != 'DRY':
            skill = (skill + driver['wet_skill']) / 2
        
        # Apply team car performance
        team_boost = TEAM_PERFORMANCE_2026.get(driver['team'], 0.80)
        
        # Apply circuit specialist bonus
        circuit_bonus = CIRCUIT_SPECIALIST.get(
            race_info['circuit'], {}
        ).get(code, 0)
        
        # Add realistic randomness
        luck = np.random.normal(0, 0.06)
        
        quali_scores[code] = skill * team_boost + circuit_bonus + luck
    
    # Sort by qualifying score
    sorted_drivers = sorted(
        quali_scores.items(), 
        key=lambda x: x[1], 
        reverse=True
    )
    return {driver: pos + 1 for pos, (driver, _) in enumerate(sorted_drivers)}

def simulate_race(race_info, grid_positions, weather):
    """Simulate race from grid positions"""
    race_scores = {}
    
    for code, driver in DRIVERS_2026.items():
        grid = grid_positions.get(code, 10)
        skill = driver['skill']
        
        # Wet weather specialist bonus
        if weather != 'DRY':
            skill = (skill * 0.4) + (driver['wet_skill'] * 0.6)
        
        # Team car performance
        team_boost = TEAM_PERFORMANCE_2026.get(driver['team'], 0.80)
        
        # Grid position penalty
        grid_penalty = grid * 0.008
        
        # Race luck and DNF chance (5% per race)
        race_luck = np.random.normal(0, 0.09)
        dnf = np.random.random() < 0.05
        
        if dnf:
            race_scores[code] = -1.0  # DNF marker
            continue
        
        race_scores[code] = (skill * team_boost) + circuit_bonus - grid_penalty + race_luck
    
    # Sort results (DNFs go to back)
    sorted_results = sorted(race_scores.items(), key=lambda x: x[1], reverse=True)
    return sorted_results

@app.route('/api/season_2026')
def season_2026():
    try:
        with open('./data/2026_prediction.json', 'r') as f:
            data = json.load(f)
        return jsonify(data)
    except:
        return jsonify({
            'error': 'No 2026 predictions found. Run season_2026_calendar.py first!'
        })

@app.route('/api/feature_importance')
def feature_importance():
    if not model:
        return jsonify({'error': 'Model not loaded'}), 500
    
    importance = model.feature_importances_
    idx = sorted(range(len(importance)), key=lambda i: importance[i], reverse=True)
    
    return jsonify({
        'features': [features[i] for i in idx],
        'importance': [float(importance[i]) for i in idx]
    })