{
  "origin": {
    "location": {
      "latLng": {
        "latitude": 40.712776,
        "longitude": -74.005974
      }
    }
  },
  "destination": {
    "location": {
      "latLng": {
        "latitude": 34.052235,
        "longitude": -118.243683
      }
    }
  },
  "travelMode": "DRIVE",
  "routingPreference": "TRAFFIC_AWARE",
  "computeAlternativeRoutes": false,
  "routeModifiers": {
    "avoidFerries": true
  },
  "languageCode": "en",
  "units": "METRIC",
  "polylineQuality": "HIGH_QUALITY"
}

// Helper function to decode an encoded polyline string (standard algorithm)
function decodePolyline(encodedPolyline) {
  const points = [];
  let index = 0;
  let lat = 0;
  let lng = 0;

  while (index < encodedPolyline.length) {
    let b;
    let shift = 0;
    let result = 0;
    do {
      b = encodedPolyline.charCodeAt(index++) - 63;
      result |= (b & 0x1f) << shift;
      shift += 5;
    } while (b >= 0x20);
    const dlat = ((result & 1) ? ~(result >> 1) : (result >> 1));
    lat += dlat;

    shift = 0;
    result = 0;
    do {
      b = encodedPolyline.charCodeAt(index++) - 63;
      result |= (b & 0x1f) << shift;
      shift += 5;
    } while (b >= 0x20);
    const dlng = ((result & 1) ? ~(result >> 1) : (result >> 1));
    lng += dlng;

    points.push({ latitude: lat / 1e5, longitude: lng / 1e5 });
  }
  return points;
}

// --- Main logic: Fetching from Routes API, decoding, and formatting ---

const originPayload = { /* ... define your origin ... */ };
const destinationPayload = { /* ... define your destination ... */ };
const googleMapsApiKey = 'YOUR_GOOGLE_MAPS_API_KEY';

async function getFormattedAdastraStepsFromRoutesAPI() {
  const routeRequestData = {
    origin: originPayload,
    destination: destinationPayload,
    travelMode: 'DRIVE',
    routingPreference: 'TRAFFIC_AWARE',
    computeAlternativeRoutes: false,
    routeModifiers: { avoidFerries: true },
    languageCode: 'en',
    units: 'METRIC',
    polylineQuality: "HIGH_QUALITY" // Important for detailed routes
  };

  try {
    const response = await fetch(`https://routes.googleapis.com/directions/v2:computeRoutes`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'X-Goog-Api-Key': googleMapsApiKey,
        'X-Goog-FieldMask': 'routes.polyline.encodedPolyline', // Request only the polyline
      },
      body: JSON.stringify(routeRequestData),
    });

    if (!response.ok) {
      const errorData = await response.json();
      throw new Error(`Routes API Error: ${response.status} - ${errorData.error.message}`);
    }

    const result = await response.json();

    if (result.routes && result.routes.length > 0) {
      const encodedPolyline = result.routes[0].polyline.encodedPolyline;
      console.log("Routes API Encoded Polyline:", encodedPolyline);

      // 1. Decode the polyline into an array of {latitude, longitude} objects
      const decodedPoints = decodePolyline(encodedPolyline);

      // 2. Format each point to 5 decimal places and join with semicolons
      const stepsString = decodedPoints.map(point =>
        `${point.latitude.toFixed(5)},${point.longitude.toFixed(5)}`
      ).join(';');

      console.log("Formatted Adastra Toll API Steps String (from Routes API):", stepsString);
      return stepsString;

    } else {
      console.warn("No routes found by Google Routes API.");
      return "";
    }

  } catch (error) {
    console.error("Error processing route data from Routes API:", error);
    return "";
  }
}

// Example usage:
// getFormattedAdastraStepsFromRoutesAPI().then(adastraSteps => {
//   if (adastraSteps) {
//     console.log("Adastra Toll API 'steps' parameter ready:", adastraSteps);
//     // Now you can call the Adastra Toll API with this 'steps' string
//     // const adastraTollRequest = { vehicleTypeId: "1", mapsource: "google", steps: adastraSteps };
//     // fetch('https://api.adastrai.com/toll?key=YOUR_ADASTRA_API_KEY', { /* ... */ });
//   }
// });

// This function assumes you have a `google.maps.DirectionsResult` object
// obtained from a successful `directionsService.route()` call.
async function getFormattedAdastraStepsFromDirectionsService(directionsResult) {
  if (!directionsResult || !directionsResult.routes || directionsResult.routes.length === 0) {
    console.warn("No routes found in DirectionsResult.");
    return "";
  }

  const route = directionsResult.routes[0]; // Usually, you'd pick the first route

  let allRoutePoints = [];

  // Iterate through all legs (segments between waypoints) of the route
  for (const leg of route.legs) {
    // Iterate through all individual steps within each leg
    for (const step of leg.steps) {
      // Each step.polyline.path is an array of google.maps.LatLng objects
      const stepPoints = step.polyline.path.map(latLng => ({
        latitude: latLng.lat(),
        longitude: latLng.lng(),
      }));
      // Concatenate points from this step to the overall list
      allRoutePoints = allRoutePoints.concat(stepPoints);
    }
  }

  // 1. Format the combined points to 5 decimal places
  //    DirectionsService usually provides distinct points, so no explicit deduplication is needed.
  const stepsString = allRoutePoints.map(point =>
    `${point.latitude.toFixed(5)},${point.longitude.toFixed(5)}`
  ).join(';');

  console.log("Formatted Adastra Toll API Steps String (from DirectionsService):", stepsString);
  return stepsString;
}

// Example usage within your DirectionsService callback:
/*
// Assuming 'map' is your google.maps.Map object
// Assuming 'directionsService' is your google.maps.DirectionsService object
// Assuming 'directionsRenderer' is your google.maps.DirectionsRenderer object

function initMapAndCalculateRoute() {
  const request = {
    origin: "Istanbul, Turkey",
    destination: "Ankara, Turkey",
    travelMode: google.maps.TravelMode.DRIVING,
    unitSystem: google.maps.UnitSystem.METRIC,
    avoidFerries: true,
  };

  directionsService.route(request, function(result, status) {
    if (status === google.maps.DirectionsStatus.OK) {
      directionsRenderer.setDirections(result); // Renders the route on the map

      getFormattedAdastraStepsFromDirectionsService(result).then(adastraSteps => {
        if (adastraSteps) {
          console.log("Adastra Toll API 'steps' parameter ready (from DirectionsService):", adastraSteps);
          // Now you can call the Adastra Toll API with this 'steps' string
          // const adastraTollRequest = { vehicleTypeId: "1", mapsource: "google", steps: adastraSteps };
          // fetch('https://api.adastrai.com/toll?key=YOUR_ADASTRA_API_KEY', { /* ... */ });
        }
      });
    } else {
      window.alert("Directions request failed due to " + status);
    }
  });
}

// Call initMapAndCalculateRoute after the Google Maps JavaScript API has loaded.
// Make sure to include the 'routes' library in your API script tag:
// <script async src="https://maps.googleapis.com/maps/api/js?key=YOUR_GOOGLE_MAPS_API_KEY&libraries=routes&callback=initMapAndCalculateRoute"></script>
*/

// This array represents a hypothetical set of route points.
// You would obtain this from a polyline decoder or by extracting from API responses.
const rawRoutePoints = [
    { latitude: 40.90878345, longitude: 29.31577123 },
    { latitude: 41.00305489, longitude: 28.96112578 },
    { latitude: 41.00312345, longitude: 28.96123456 },
    { latitude: 40.90878000, longitude: 29.31577000 }, // Example with more trailing zeros
];

// Format each point to exactly 5 decimal places and join them with semicolons
const formattedStepsString = rawRoutePoints.map(point =>
    `${point.latitude.toFixed(5)},${point.longitude.toFixed(5)}`
).join(';');

console.log("General formatted steps string:", formattedStepsString);
// Expected output: "40.90878,29.31577;41.00305,28.96113;41.00312,28.96123;40.90878,29.31577"

// This `formattedStepsString` is now ready to be used as the `steps` parameter
// in your Adastra Toll API request.