const logger = require('../config/logger');
const telemetryService = require('../services/telemetryService');
const { broadcastToRoute } = require('../services/realtimeService');

function sendError(res, error, fallbackMessage) {
  if (error.status) {
    return res.status(error.status).json({ error: error.message });
  }

  logger.error(fallbackMessage, error);
  return res.status(500).json({ error: fallbackMessage });
}

class TelemetryController {
  async ingest(req, res) {
    try {
      const sourceType = req.body.sourceType || (req.user ? 'user' : 'api-key');
      const sourceRef = req.body.sourceRef || (
        req.user
          ? `user:${req.user.id}`
          : req.apiKeyInfo
            ? `api-key:${req.apiKeyInfo.id}`
            : null
      );

      const vehicle = await telemetryService.ingestTelemetry({
        ...req.body,
        sourceType,
        sourceRef,
        rawPayload: req.body
      });

      broadcastToRoute(vehicle.route_id, {
        type: 'vehicle:position',
        routeId: vehicle.route_id,
        vehicle
      });

      const routeVehicles = await telemetryService.getRouteLiveVehicles(vehicle.route_id).catch((error) => {
        logger.error('Failed to build realtime snapshot after official telemetry ingest:', error);
        return null;
      });

      if (routeVehicles) {
        broadcastToRoute(vehicle.route_id, {
          type: 'snapshot:route',
          routeId: vehicle.route_id,
          vehicles: routeVehicles
        });
      }

      return res.status(201).json({
        message: 'Telemetry ingested successfully',
        vehicle
      });
    } catch (error) {
      return sendError(res, error, 'Failed to ingest telemetry');
    }
  }

  async getRouteLiveVehicles(req, res) {
    try {
      const includeStale = req.query.includeStale === 'true';
      const staleAfterSeconds = req.query.staleAfterSeconds
        ? Number.parseInt(req.query.staleAfterSeconds, 10)
        : undefined;

      const vehicles = await telemetryService.getRouteLiveVehicles(req.params.routeId, {
        includeStale,
        staleAfterSeconds
      });

      return res.json(vehicles);
    } catch (error) {
      return sendError(res, error, 'Failed to fetch route live vehicles');
    }
  }

  async getVehicleLiveState(req, res) {
    try {
      const staleAfterSeconds = req.query.staleAfterSeconds
        ? Number.parseInt(req.query.staleAfterSeconds, 10)
        : undefined;

      const vehicle = await telemetryService.getVehicleLiveState(
        req.params.vehicleId,
        staleAfterSeconds
      );

      return res.json(vehicle);
    } catch (error) {
      return sendError(res, error, 'Failed to fetch vehicle live state');
    }
  }
}

module.exports = new TelemetryController();