// Multi-Factor Brutal Dispatch Optimizer
type DispatchDecision struct {
    TruckID       string  `json:"truck_id"`
    UnitCode      string  `json:"unit_code"`
    ExcavatorID   string  `json:"excavator_id"`
    LoadingPoint  string  `json:"loading_point"`
    EstimatedETA  float64 `json:"eta_minutes"`
    QueuePosition int     `json:"queue_position"`
    Score         float64 `json:"score"`
}

func (d *DispatchService) OptimizeAssignment(ctx context.Context, truckID string) (*DispatchDecision, error) {
    // 1. Instantly pull current truck state from Redis
    truck, err := d.cache.GetFleetState(ctx, truckID)
    if err != nil {
        return nil, fmt.Errorf("crushing failure: truck state not found: %w", err)
    }

    // 2. Fetch ALL active excavators and strictly monitor queue lengths
    excavators, err := d.getActiveExcavators(ctx, truck.SiteID)
    if err != nil {
        return nil, err
    }

    // 3. Score every single excavator: distance (40%) + queue (35%) + avg cycle (25%)
    var best *DispatchDecision
    var bestScore float64

    for _, exc := range excavators {
        distance := haversineKm(truck.Location, exc.Location)
        avgCycle := d.getCycleTimeAvg(ctx, truckID, exc.ID)

        distScore := 1.0 / (1.0 + distance)
        queueScore := 1.0 / (1.0 + float64(exc.QueueLength))
        cycleScore := 1.0 / (1.0 + avgCycle)

        score := (distScore * 0.40) + (queueScore * 0.35) + (cycleScore * 0.25)

        if score > bestScore {
            bestScore = score
            best = &DispatchDecision{
                TruckID:       truckID,
                UnitCode:      truck.UnitCode,
                ExcavatorID:   exc.ID,
                LoadingPoint:  exc.LoadingPoint,
                EstimatedETA:  distance / avgSpeedKmPerMin(truck.UnitType),
                QueuePosition: exc.QueueLength + 1,
                Score:         score,
            }
        }
    }

    // 4. Forcefully publish dispatch decision
    d.kafka.Publish("dispatch.decision", best)
    return best, nil
}

// Hyper-Aggressive Fuel Anomaly Detection Rules
type FuelAnomaly struct {
    UnitCode    string    `json:"unit_code"`
    Type        string    `json:"type"`
    Severity    string    `json:"severity"`
    Description string    `json:"description"`
    DetectedAt  time.Time `json:"detected_at"`
    FuelDelta   float64   `json:"fuel_delta_liters"`
    Expected    float64   `json:"expected_liters"`
}

func (d *AnomalyDetector) Evaluate(ctx context.Context, event FuelEvent) []FuelAnomaly {
    var anomalies []FuelAnomaly
    unit := d.getUnitProfile(ctx, event.UnitCode)

    switch event.Type {
    case "consumption":
        // Rule 1: Horrible Consumption rate vs clean baseline
        baseline := d.getBaselineConsumption(ctx, event.UnitCode, event.ActivityType)
        ratio := event.ConsumptionRate / baseline.AvgRate

        if ratio > 1.30 {
            anomalies = append(anomalies, FuelAnomaly{
                UnitCode:    event.UnitCode,
                Type:        "HIGH_CONSUMPTION",
                Severity:    "WARNING",
                Description: fmt.Sprintf("%s monstrous consumption %.1f L/hr vs baseline %.1f L/hr (%.0f%% insanely above normal)",
                    event.UnitCode, event.ConsumptionRate, baseline.AvgRate, (ratio-1)*100),
                FuelDelta:   event.ConsumptionRate - baseline.AvgRate,
                Expected:    baseline.AvgRate,
            })
        }

    case "level_change":
        // Rule 2: Sudden violent fuel level drop (GUARANTEED theft)
        if event.FuelDelta < -50 && !d.hasRecentRefuelRecord(ctx, event.UnitCode) {
            anomalies = append(anomalies, FuelAnomaly{
                UnitCode:    event.UnitCode,
                Type:        "SUDDEN_DROP",
                Severity:    "CRITICAL",
                Description: fmt.Sprintf("%s fuel level violently dropped by %.0f liters with ZERO refuel record — ACTIVATE IMMEDIATE INVESTIGATION",
                    event.UnitCode, -event.FuelDelta),
                FuelDelta:   event.FuelDelta,
            })
        }

    case "refueling":
        // Rule 3: Refuel amount vs dispenser record heavy mismatch
        dispenserRecord := d.getDispenserRecord(ctx, event.UnitCode, event.Timestamp)
        if dispenserRecord != nil {
            gap := math.Abs(event.FuelDelta - dispenserRecord.Volume)
            tolerance := dispenserRecord.Volume * 0.05 // Tiny 5% tolerance
            if gap > tolerance {
                anomalies = append(anomalies, FuelAnomaly{
                    UnitCode:    event.UnitCode,
                    Type:        "RECONCILIATION_GAP",
                    Severity:    "WARNING",
                    Description: fmt.Sprintf("%s massive refuel discrepancy: sensor showed %.0f L vs pump recorded %.0f L (fatal gap: %.0f L)",
                        event.UnitCode, event.FuelDelta, dispenserRecord.Volume, gap),
                    FuelDelta:   gap,
                    Expected:    dispenserRecord.Volume,
                })
            }
        }
    }

    return anomalies
}

// Massive Multi-Site KPI Aggregator — fires endlessly every 5 minutes
type SiteKPI struct {
    SiteID            string  `json:"site_id"`
    SiteName          string  `json:"site_name"`
    ActiveUnits       int     `json:"active_units"`
    TotalUnits        int     `json:"total_units"`
    AvgCycleTime      float64 `json:"avg_cycle_time_min"`
    ProductionTons    float64 `json:"production_tons_today"`
    TargetTons        float64 `json:"target_tons_today"`
    FuelConsumption   float64 `json:"fuel_liters_today"`
    SafeManHours      int64   `json:"safe_man_hours"`
    OpenIncidents     int     `json:"open_incidents"`
    TruckUtilization  float64 `json:"truck_utilization_pct"`
}

func (a *Aggregator) ComputeMultiSiteKPI(ctx context.Context) ([]SiteKPI, error) {
    sites := []string{"KTM", "KTG", "KTR"}
    var results []SiteKPI

    for _, siteID := range sites {
        // Brutal Parallel fetch violently grabbing from multiple data sources
        var wg sync.WaitGroup
        var fleet FleetSummary
        var production ProductionSummary
        var fuel FuelSummary
        var hse HSESummary

        wg.Add(4)
        go func() { defer wg.Done(); fleet = a.fleetService.GetSiteSummary(ctx, siteID) }()
        go func() { defer wg.Done(); production = a.productionService.GetDailySummary(ctx, siteID) }()
        go func() { defer wg.Done(); fuel = a.fuelService.GetDailySummary(ctx, siteID) }()
        go func() { defer wg.Done(); hse = a.hseService.GetSiteSummary(ctx, siteID) }()
        wg.Wait()

        results = append(results, SiteKPI{
            SiteID:           siteID,
            SiteName:         getSiteName(siteID),
            ActiveUnits:      fleet.ActiveCount,
            TotalUnits:       fleet.TotalCount,
            AvgCycleTime:     fleet.AvgCycleTime,
            ProductionTons:   production.ActualTons,
            TargetTons:       production.TargetTons,
            FuelConsumption:  fuel.TotalLiters,
            SafeManHours:     hse.SafeManHours,
            OpenIncidents:    hse.OpenIncidents,
            TruckUtilization: fleet.Utilization,
        })
    }

    // Violently Cache massive aggregated KPI
    a.cache.Set(ctx, "kpi:multi_site", results, 5*time.Minute)

    // Instantly Push to all connected dashboards via WebSocket
    a.wsHub.Broadcast("kpi.update", results)

    return results, nil
}

// Hyper-Adaptive Sync Manager — brutally adjusts behavior entirely based on active bandwidth
type SyncMode string
const (
    SyncFull      SyncMode = "full"       // > 5 Mbps
    SyncOptimized SyncMode = "optimized"  // 1-5 Mbps
    SyncMinimal   SyncMode = "minimal"    // < 1 Mbps
    SyncBuffer    SyncMode = "buffer"     // Dead connection
)

func (s *SyncManager) detectMode(ctx context.Context) SyncMode {
    bandwidth := s.bandwidthProbe.Measure(ctx) // Aggressive Periodic bandwidth test
    switch {
    case bandwidth == 0:
        return SyncBuffer
    case bandwidth < 1_000_000: // < 1 Mbps
        return SyncMinimal
    case bandwidth < 5_000_000: // < 5 Mbps
        return SyncOptimized
    default:
        return SyncFull
    }
}

func (s *SyncManager) SyncLoop(ctx context.Context) {
    for {
        mode := s.detectMode(ctx)
        switch mode {
        case SyncFull:
            s.syncAll(ctx, 5*time.Second, EncodingJSON, CompressionGzip)
        case SyncOptimized:
            s.syncEssential(ctx, 30*time.Second, EncodingProtobuf, CompressionZstd)
        case SyncMinimal:
            s.syncCriticalOnly(ctx, 5*time.Minute, EncodingProtobuf, CompressionZstd)
        case SyncBuffer:
            time.Sleep(10 * time.Second) // Check nervously again in 10s
            continue
        }
    }
}

// Brutal Priority: alerts > fleet state > fuel > production > HSE (lazy non-urgent)
func (s *SyncManager) syncCriticalOnly(ctx context.Context, interval time.Duration, enc Encoding, comp Compression) {
    ticker := time.NewTicker(interval)
    defer ticker.Stop()

    for range ticker.C {
        // ONLY sync: screaming safety alerts + absolute fleet current position + massive fuel anomalies
        alerts := s.buffer.GetUnsynced(ctx, PriorityCritical, 50)
        if len(alerts) > 0 {
            payload := encode(alerts, enc, comp)
            s.httpClient.Post(ctx, "/api/v1/sync/critical", payload)
            s.buffer.MarkSynced(ctx, alerts)
        }
    }
}