// Fleet API — exposed to frontend and other services
POST   /api/vehicles         // Create vehicle
GET    /api/vehicles         // List vehicles
GET    /api/vehicles/:id     // Get vehicle details
PATCH  /api/vehicles/:id     // Update vehicle

// Telemetry Service — internal API
POST   /api/telemetry/gps    // Receive GPS data (from truck devices)
GET    /api/telemetry/position/:truckId  // Get latest position
POST   /api/telemetry/alert  // Create alert

// Admin Service — internal admin panel
GET    /admin/dashboard      // Admin dashboard
GET    /admin/invoices       // Invoice management

// Fleet API calling Telemetry Service synchronously
@Injectable()
export class TelemetryClient {
  constructor(private readonly httpService: HttpService) {}

  async getVehiclePosition(truckId: string): Promise<Position> {
    const { data } = await this.httpService.axiosRef.get(
      `${TELEMETRY_URL}/api/telemetry/position/${truckId}`,
      { timeout: 3000 }, // Always set timeouts!
    );
    return data;
  }
}

// Telemetry Service publishes an event
async function onGpsReceived(data: GpsData) {
  // Save to database
  await this.gpsRepo.save(data);

  // Publish event — anyone listening can react
  await this.redis.publish('telemetry:gps-update', JSON.stringify({
    truckId: data.truckId,
    lat: data.latitude,
    lng: data.longitude,
    speed: data.speed,
    timestamp: data.recordedAt,
  }));
}

// Fleet API subscribes to the event
this.redis.subscribe('telemetry:gps-update', (message) => {
  const data = JSON.parse(message);
  // Update the real-time dashboard via WebSocket
  this.wsGateway.broadcastPosition(data);
});

# nginx.conf — Simple API Gateway
upstream fleet_api {
    server 127.0.0.1:3001;
}

upstream telemetry_api {
    server 127.0.0.1:3002;
}

upstream admin_api {
    server 127.0.0.1:8000;
}

server {
    listen 80;

    # Route by URL prefix
    location /api/vehicles {
        proxy_pass http://fleet_api;
    }

    location /api/telemetry {
        proxy_pass http://telemetry_api;
    }

    location /admin {
        proxy_pass http://admin_api;
    }
}

// Fleet API — Step 1: Assign driver
async assignDriver(vehicleId: string, driverId: string) {
  const vehicle = await this.vehicleRepo.findOneOrFail(vehicleId);
  vehicle.currentDriverId = driverId;
  await this.vehicleRepo.save(vehicle);

  // Publish event
  await this.eventBus.publish('driver.assigned', {
    vehicleId, driverId, timestamp: new Date(),
  });
}

// Fleet API — Step 3: Compensate on failure
@OnEvent('invoice.failed')
async handleInvoiceFailed(event: InvoiceFailedEvent) {
  // Roll back the driver assignment
  const vehicle = await this.vehicleRepo.findOneOrFail(event.vehicleId);
  vehicle.currentDriverId = null;
  await this.vehicleRepo.save(vehicle);

  this.logger.warn(`Rolled back driver assignment for vehicle ${event.vehicleId}`);
}

// Simple circuit breaker implementation
class CircuitBreaker {
  private failures = 0;
  private lastFailure: number = 0;
  private state: 'CLOSED' | 'OPEN' | 'HALF_OPEN' = 'CLOSED';

  constructor(
    private readonly threshold: number = 5,     // Open after 5 failures
    private readonly resetTimeout: number = 30000, // Try again after 30s
  ) {}

  async call<T>(fn: () => Promise<T>, fallback: T): Promise<T> {
    if (this.state === 'OPEN') {
      if (Date.now() - this.lastFailure > this.resetTimeout) {
        this.state = 'HALF_OPEN'; // Try one request
      } else {
        return fallback; // Return fallback immediately
      }
    }

    try {
      const result = await fn();
      this.onSuccess();
      return result;
    } catch (error) {
      this.onFailure();
      return fallback;
    }
  }

  private onSuccess() {
    this.failures = 0;
    this.state = 'CLOSED';
  }

  private onFailure() {
    this.failures++;
    this.lastFailure = Date.now();
    if (this.failures >= this.threshold) {
      this.state = 'OPEN';
    }
  }
}

// Usage
const telemetryBreaker = new CircuitBreaker(5, 30000);

async function getVehiclePosition(truckId: string) {
  return telemetryBreaker.call(
    () => telemetryClient.getPosition(truckId),
    { lat: 0, lng: 0, status: 'unavailable' } // Fallback
  );
}