// Simplified Telemetry Ingestion Service
type TelemetryPayload struct {
    DeviceID    string    `json:"device_id"`
    Timestamp   time.Time `json:"timestamp"`
    Latitude    float64   `json:"lat"`
    Longitude   float64   `json:"lng"`
    Speed       float64   `json:"speed"`
    FuelLevel   float64   `json:"fuel_level"`
    EngineTemp  float64   `json:"engine_temp"`
    OilPressure float64   `json:"oil_pressure"`
    Payload     float64   `json:"payload_tonnage"`
}

func (s *IngestionService) ProcessBatch(ctx context.Context, payloads []TelemetryPayload) error {
    // 1. Sort by timestamp to ensure chronological order
    sort.Slice(payloads, func(i, j int) bool {
        return payloads[i].Timestamp.Before(payloads[j].Timestamp)
    })

    // 2. Bloom Filter + Redis idempotency check
    uniquePayloads := s.deduplicator.FilterUnique(ctx, payloads)
    if len(uniquePayloads) == 0 {
        return nil // All duplicates — skip
    }

    // 3. Batch insert to Time-Series DB
    if err := s.tsdb.InsertBatch(ctx, uniquePayloads); err != nil {
        return fmt.Errorf("failed to insert batch telemetry: %w", err)
    }

    // 4. Update "Current State" in Redis for real-time dashboard
    latest := getLatestPerDevice(uniquePayloads)
    for deviceID, payload := range latest {
        s.cache.Set(ctx, fmt.Sprintf("fleet_state:%s", deviceID), payload, 0)
    }

    // 5. Publish processed events for downstream consumers
    for _, p := range uniquePayloads {
        s.kafka.Publish("processed-telemetry", p)
    }

    s.metrics.IngestCounter.Add(float64(len(uniquePayloads)))
    return nil
}

// Ray-Casting Point in Polygon — O(n) per polygon edge
func isPointInPolygon(point Point, polygon []Point) bool {
    inPolygon := false
    j := len(polygon) - 1
    for i := 0; i < len(polygon); i++ {
        if (polygon[i].Y < point.Y && polygon[j].Y >= point.Y ||
            polygon[j].Y < point.Y && polygon[i].Y >= point.Y) &&
            (polygon[i].X <= point.X || polygon[j].X <= point.X) {
            if polygon[i].X+(point.Y-polygon[i].Y)/
                (polygon[j].Y-polygon[i].Y)*(polygon[j].X-polygon[i].X) < point.X {
                inPolygon = !inPolygon
            }
        }
        j = i
    }
    return inPolygon
}

// Evaluate all geofence rules for a single telemetry point
func (e *GeofenceEvaluator) Evaluate(ctx context.Context, payload TelemetryPayload) []Alert {
    point := Point{X: payload.Longitude, Y: payload.Latitude}
    var alerts []Alert

    for _, zone := range e.zones.GetAll() {
        inside := isPointInPolygon(point, zone.Polygon)

        switch zone.Type {
        case "restricted":
            if inside {
                alerts = append(alerts, Alert{
                    DeviceID: payload.DeviceID,
                    Type:     "ZONE_BREACH",
                    Severity: "CRITICAL",
                    Message:  fmt.Sprintf("Unit %s entered restricted zone: %s", payload.DeviceID, zone.Name),
                    Location: point,
                })
            }
        case "speed_limit":
            if inside && payload.Speed > zone.SpeedLimit {
                alerts = append(alerts, Alert{
                    DeviceID: payload.DeviceID,
                    Type:     "OVERSPEED",
                    Severity: "WARNING",
                    Message:  fmt.Sprintf("Unit %s: %.1f km/h in %.0f km/h zone (%s)",
                        payload.DeviceID, payload.Speed, zone.SpeedLimit, zone.Name),
                    Location: point,
                })
            }
        }
    }
    return alerts
}

// Fleet Dispatch Optimizer
type DispatchDecision struct {
    TruckID      string  `json:"truck_id"`
    ExcavatorID  string  `json:"excavator_id"`
    EstimatedETA float64 `json:"estimated_eta_minutes"`
    QueuePosition int    `json:"queue_position"`
    Route        []Point `json:"route"`
}

func (d *DispatchService) OptimizeAssignment(ctx context.Context, truckID string) (*DispatchDecision, error) {
    // 1. Get current truck position
    truckState, err := d.cache.Get(ctx, fmt.Sprintf("fleet_state:%s", truckID))
    if err != nil {
        return nil, fmt.Errorf("truck state not found: %w", err)
    }

    // 2. Get all available excavators and their queue lengths
    excavators, err := d.getActiveExcavators(ctx)
    if err != nil {
        return nil, err
    }

    // 3. Score each excavator based on multi-factor optimization
    var bestScore float64
    var bestExcavator *Excavator
    for _, exc := range excavators {
        score := d.calculateScore(truckState, exc)
        if score > bestScore {
            bestScore = score
            bestExcavator = &exc
        }
    }

    // 4. Build dispatch decision
    return &DispatchDecision{
        TruckID:       truckID,
        ExcavatorID:   bestExcavator.ID,
        EstimatedETA:  calculateETA(truckState.Location, bestExcavator.Location),
        QueuePosition: bestExcavator.QueueLength + 1,
    }, nil
}

// Multi-factor scoring: distance (40%), queue length (35%), cycle time (25%)
func (d *DispatchService) calculateScore(truck *FleetState, exc Excavator) float64 {
    distance := haversineDistance(truck.Location, exc.Location)
    distScore := 1.0 / (1.0 + distance)                    // Closer = better
    queueScore := 1.0 / (1.0 + float64(exc.QueueLength))   // Shorter queue = better
    cycleScore := 1.0 / (1.0 + exc.AvgCycleTime)           // Faster cycle = better

    return (distScore * 0.40) + (queueScore * 0.35) + (cycleScore * 0.25)
}

// Engine Health Rules - evaluated in real-time
type EngineHealthRule struct {
    Name       string
    Condition  func(current, avg30d TelemetrySummary) bool
    Severity   string
    Message    string
}

var engineHealthRules = []EngineHealthRule{
    {
        Name: "engine_temp_anomaly",
        Condition: func(current, avg30d TelemetrySummary) bool {
            // Temperature > 2 standard deviations above 30-day average
            return current.EngineTemp > (avg30d.EngineTemp + 2*avg30d.EngineTempStdDev)
        },
        Severity: "WARNING",
        Message:  "Engine temperature trending above normal range",
    },
    {
        Name: "oil_pressure_drop",
        Condition: func(current, avg30d TelemetrySummary) bool {
            // Oil pressure dropped > 20% from 30-day average
            dropPercent := (avg30d.OilPressure - current.OilPressure) / avg30d.OilPressure * 100
            return dropPercent > 20
        },
        Severity: "CRITICAL",
        Message:  "Oil pressure significantly below normal — potential engine failure risk",
    },
    {
        Name: "fuel_consumption_spike",
        Condition: func(current, avg30d TelemetrySummary) bool {
            // Fuel consumption > 30% above average indicates engine inefficiency
            return current.FuelRate > (avg30d.FuelRate * 1.30)
        },
        Severity: "INFO",
        Message:  "Fuel consumption above normal — schedule efficiency check",
    },
}

func (e *MaintenanceEvaluator) EvaluateHealth(ctx context.Context, deviceID string, current TelemetrySummary) []Alert {
    avg30d, err := e.tsdb.Get30DayAverage(ctx, deviceID)
    if err != nil {
        return nil // Insufficient historical data
    }

    var alerts []Alert
    for _, rule := range engineHealthRules {
        if rule.Condition(current, avg30d) {
            alerts = append(alerts, Alert{
                DeviceID: deviceID,
                Type:     "MAINTENANCE",
                Severity: rule.Severity,
                Message:  rule.Message,
                Metadata: map[string]interface{}{
                    "current_temp":     current.EngineTemp,
                    "avg_30d_temp":     avg30d.EngineTemp,
                    "current_pressure": current.OilPressure,
                    "avg_30d_pressure": avg30d.OilPressure,
                    "engine_hours":     current.EngineHours,
                },
            })
        }
    }
    return alerts
}

// Adaptive Sync Manager — prioritizes critical data
type SyncManager struct {
    buffer    *SQLiteBuffer
    mqtt      *MQTTClient
    maxBatch  int
    backoff   *ExponentialBackoff
}

func (s *SyncManager) SyncLoop(ctx context.Context) error {
    for {
        select {
        case <-ctx.Done():
            return nil
        default:
            if !s.mqtt.IsConnected() {
                time.Sleep(5 * time.Second)
                continue
            }

            // Phase 1: Send critical alerts immediately (MQTT QoS 2)
            alerts, _ := s.buffer.GetUnsyncedByPriority(ctx, "critical", 10)
            for _, alert := range alerts {
                if err := s.mqtt.PublishQoS2(ctx, "telemetry/alert", alert); err != nil {
                    break // Connection lost — will retry
                }
                s.buffer.MarkSynced(ctx, alert.ID)
            }

            // Phase 2: Batch send recent data (last 30 min)
            recent, _ := s.buffer.GetUnsyncedRecent(ctx, 30*time.Minute, s.maxBatch)
            if len(recent) > 0 {
                batch := encodeBatch(recent) // Protocol Buffers encoding
                if err := s.mqtt.PublishQoS1(ctx, "telemetry/batch", batch); err != nil {
                    s.backoff.Wait()
                    continue
                }
                s.buffer.MarkBatchSynced(ctx, recent)
                s.backoff.Reset()
            }

            // Phase 3: Throttled historical data
            historical, _ := s.buffer.GetUnsyncedOld(ctx, s.maxBatch/2)
            if len(historical) > 0 {
                batch := encodeBatch(historical)
                s.mqtt.PublishQoS1(ctx, "telemetry/batch", batch)
                s.buffer.MarkBatchSynced(ctx, historical)
                time.Sleep(500 * time.Millisecond) // Throttle to avoid flooding
            }

            time.Sleep(1 * time.Second)
        }
    }
}