Amazon Location Service

// Request contacts and opening hours
const command = new amazonLocationClient.places.SearchTextCommand({
  QueryText: "coffee shops in Austin",
  AdditionalFeatures: ["Contact"],
  MaxResults: 5,
});

const response = await client.send(command);

response.ResultItems.forEach((place) => {
  console.log(place.Title);
  console.log("Phone:", place.Contacts?.Phones?.[0]?.Value);
  console.log("Website:", place.Contacts?.Websites?.[0]?.Value);
  console.log("Hours:", place.OpeningHours);
});

const authHelper = amazonLocationClient.withAPIKey(API_KEY, REGION);
const client = new amazonLocationClient.GeoPlacesClient(
  authHelper.getClientConfig(),
);

async function searchPlaces(query) {
  try {
    const command = new amazonLocationClient.places.SearchTextCommand({
      QueryText: query,
      MaxResults: 10,
    });

    const response = await client.send(command);

    // Display results
    response.ResultItems.forEach((place) => {
      console.log(place.Title); // "Starbucks"
      console.log(place.Address?.Label); // "123 Main St, Austin, TX"
      console.log(place.Position); // [lon, lat]
      // Categories are objects: { Id: string, Name: string, LocalizedName?: string, Primary?: boolean }
      console.log(place.Categories); // [{ Id: "9000", Name: "Coffee Shop" }, { Id: "5814", Name: "Café" }]
      console.log(place.PlaceId); // For fetching details
    });

    return response.ResultItems;
  } catch (error) {
    console.error("Search error:", error);
    return [];
  }
}

// Usage
searchPlaces("coffee shops in Austin");

// Bias results toward a specific location
async function searchNear(query, biasPosition) {
  const command = new amazonLocationClient.places.SearchTextCommand({
    QueryText: query,
    BiasPosition: biasPosition, // [lon, lat] - prefer results near here
    MaxResults: 10,
  });

  const response = await client.send(command);
  return response.ResultItems;
}

// Usage - find tacos near Austin
searchNear("tacos", [-97.7431, 30.2747]);

async function searchByCategory(query, categories) {
  const command = new amazonLocationClient.places.SearchTextCommand({
    QueryText: query,
    Filter: {
      Categories: categories, // Filter by category codes
    },
    MaxResults: 20,
  });

  const response = await client.send(command);
  return response.ResultItems;
}

// Usage - find only restaurants
searchByCategory("food near downtown", ["Restaurant"]);

// Restrict search to specific geographic area
async function searchInBounds(query, boundingBox) {
  const command = new amazonLocationClient.places.SearchTextCommand({
    QueryText: query,
    Filter: {
      BoundingBox: boundingBox, // [west, south, east, north]
    },
    MaxResults: 10,
  });

  const response = await client.send(command);
  return response.ResultItems;
}

// Usage - find hotels in downtown Austin area
const austinDowntown = [-97.7535, 30.2586, -97.7327, 30.2747];
searchInBounds("hotels", austinDowntown);

async function searchNearby(position, radius, categories = null) {
  const params = {
    QueryPosition: position, // [lon, lat]
    MaxResults: 20,
  };

  // Optional: filter by categories
  if (categories) {
    params.Filter = { Categories: categories };
  }

  // Optional: specify radius (default is context-dependent)
  if (radius) {
    params.MaxDistance = radius; // in meters
  }

  const command = new amazonLocationClient.places.SearchNearbyCommand(params);

  try {
    const response = await client.send(command);

    // Results are already sorted by distance
    response.ResultItems.forEach((place) => {
      console.log(place.Title);
      console.log(place.Distance, "meters away");
      console.log(place.Position);
    });

    return response.ResultItems;
  } catch (error) {
    console.error("Nearby search error:", error);
    return [];
  }
}

// Usage - find restaurants within 5km
const userLocation = [-97.7431, 30.2747];
searchNearby(userLocation, 5000, ["Restaurant"]);

// Find single nearest place of a specific type
async function findNearest(position, category) {
  const command = new amazonLocationClient.places.SearchNearbyCommand({
    QueryPosition: position,
    Filter: { Categories: [category] },
    MaxResults: 1, // Just the nearest
  });

  const response = await client.send(command);

  if (response.ResultItems.length === 0) {
    return null;
  }

  return response.ResultItems[0];
}

// Usage - find nearest gas station
const nearest = await findNearest([-97.7431, 30.2747], "Gas Station");
if (nearest) {
  console.log(`Nearest: ${nearest.Title}, ${nearest.Distance}m away`);
}

// Display nearby search results on map
async function showNearbyOnMap(map, position, category) {
  const results = await searchNearby(position, 2000, [category]);

  // Clear existing markers
  document.querySelectorAll(".nearby-marker").forEach((el) => el.remove());

  // Add markers for each result
  results.forEach((place, index) => {
    const marker = new maplibregl.Marker({ color: "#FF0000" })
      .setLngLat(place.Position)
      .setPopup(
        new maplibregl.Popup().setHTML(`
          <h4>${place.Title}</h4>
          <p>${place.Address?.Label || ""}</p>
          <p>${Math.round(place.Distance)}m away</p>
        `),
      )
      .addTo(map);

    marker.getElement().classList.add("nearby-marker");
  });

  // Fit map to show all results
  if (results.length > 0) {
    const bounds = new maplibregl.LngLatBounds();
    results.forEach((place) => bounds.extend(place.Position));
    bounds.extend(position); // Include search center
    map.fitBounds(bounds, { padding: 50 });
  }
}

// Like Autocomplete but for places/POIs (not just addresses)
async function suggestPlaces(partialQuery, biasPosition = null) {
  const params = {
    QueryText: partialQuery,
    MaxResults: 5,
  };

  if (biasPosition) {
    params.BiasPosition = biasPosition;
  }

  const command = new amazonLocationClient.places.SuggestCommand(params);

  try {
    const response = await client.send(command);

    response.ResultItems.forEach((item) => {
      console.log(item.Title); // "Starbucks"
      console.log(item.Place?.PlaceId); // For fetching full details
      console.log(item.SuggestResultItemType); // "Place" or "Query"
    });

    return response.ResultItems;
  } catch (error) {
    console.error("Suggest error:", error);
    return [];
  }
}

// Usage - type-ahead for place search
document.getElementById("place-search").addEventListener("input", async (e) => {
  const query = e.target.value;

  if (query.length < 3) return;

  const suggestions = await suggestPlaces(query);

  // Display suggestions (similar to autocomplete)
  displaySuggestions(suggestions);
});

function parsePlaceResult(place) {
  return {
    id: place.PlaceId,
    name: place.Title,
    address: place.Address?.Label || "Address not available",
    coordinates: {
      lat: place.Position[1],
      lon: place.Position[0],
    },
    categories: (place.Categories || []).map((c) => c.Name), // Category is { Id, Name, LocalizedName?, Primary? }
    primaryCategory: place.Categories?.find((c) => c.Primary)?.Name,
    distance: place.Distance, // Only in SearchNearby results

    // Optional fields - check before using
    phone: place.Contacts?.Phones?.[0]?.Value,
    website: place.Contacts?.Websites?.[0]?.Value,

    // Use GetPlace for more details
    hasMoreDetails: !!place.PlaceId,
  };
}

// Usage
const results = await searchPlaces("coffee");
const parsed = results.map(parsePlaceResult);

// Get full details including hours, contact info
async function getPlaceDetails(placeId) {
  const command = new amazonLocationClient.places.GetPlaceCommand({
    PlaceId: placeId,
  });

  try {
    const response = await client.send(command);

    return {
      name: response.Title,
      address: response.Address,
      position: response.Position,
      categories: response.Categories,
      contacts: {
        phones: response.Contacts?.Phones || [],
        websites: response.Contacts?.Websites || [],
        emails: response.Contacts?.Emails || [],
      },
      openingHours: response.OpeningHours || [],
      accessPoints: response.AccessPoints || [], // Entrances
      timeZone: response.TimeZone,
    };
  } catch (error) {
    console.error("GetPlace error:", error);
    return null;
  }
}

// Usage - user clicks on search result to see details
async function showPlaceDetails(placeId) {
  const details = await getPlaceDetails(placeId);

  if (details) {
    console.log("Phone:", details.contacts.phones[0]?.Value);
    console.log("Hours:", details.openingHours);
  }
}

async function searchWithErrorHandling(query) {
  try {
    const command = new amazonLocationClient.places.SearchTextCommand({
      QueryText: query,
      MaxResults: 10,
    });

    const response = await client.send(command);

    if (response.ResultItems.length === 0) {
      // No results found
      showMessage("No places found. Try a different search.");
      return [];
    }

    return response.ResultItems;
  } catch (error) {
    // API errors
    if (error.name === "ValidationException") {
      showMessage("Invalid search query. Please check your input.");
    } else if (error.name === "AccessDeniedException") {
      showMessage("API key lacks permission for place search.");
    } else if (error.name === "ThrottlingException") {
      showMessage("Too many requests. Please wait and try again.");
    } else {
      showMessage("Search failed. Please try again.");
    }

    console.error("Search error:", error);
    return [];
  }
}

// Try nearby search, fall back to text search if no results
async function searchWithFallback(query, position) {
  // Try nearby search first
  let results = await searchNearby(position, 5000);

  if (results.length === 0) {
    console.log("No nearby results, trying text search...");
    // Fall back to text search with position bias
    results = await searchNear(query, position);
  }

  return results;
}