searchPlaces method

Implementation

// III.C - Search Methods
///////////////
/// Searches for places based on a query with improved state handling and proximity prioritization
Future<List<SearchResult>> searchPlaces(
  String query, {
  int limit = 5,
  geo.Position? proximity,
  List<String> types = const ['address', 'poi', 'place', 'neighborhood'],
}) async {
  debugPrint("[DEBUG] searchPlaces called with query: '$query', limit: $limit at ${DateTime.now()}");
  if (query.trim().isEmpty) return [];

  // Preprocess the query to better handle address formats
  final processedQuery = _preprocessQuery(query);
  debugPrint("[DEBUG] Preprocessed query: '$processedQuery'");

  // Check cache first for quick responses
  final cacheKey = '${processedQuery}_${proximity?.latitude}_${proximity?.longitude}';
  if (_searchCache.containsKey(cacheKey)) {
    debugPrint("[DEBUG] Cache hit for query: '$processedQuery'");
    return _searchCache[cacheKey]!;
  }
  debugPrint("[DEBUG] Cache miss, making API request");

  try {
    // Basic query parameters
    final queryParams = {
      'access_token': accessToken,
      'limit': (limit * 3).toString(), // Request more results to allow better filtering/sorting
      'types': types.join(','),
      'fuzzyMatch': 'true',
      'autocomplete': 'true',
    };

    // Add proximity if available for context-aware results (higher weight for local searches)
    if (proximity != null) {
      queryParams['proximity'] = '${proximity.longitude},${proximity.latitude}';
      // Set proximity bias to high for better local results
      queryParams['proximity_bias'] = '1.0';
      debugPrint("[DEBUG] Added proximity parameters: [${proximity.longitude}, ${proximity.latitude}]");
    }

    // Try to extract state/location information from the query
    final stateInfo = _extractLocationInfo(processedQuery);
    debugPrint("[DEBUG] Extracted location info: '$stateInfo'");

    // If a state was found or the pattern suggests a US address format
    if (stateInfo.isNotEmpty || _looksLikeUSAddress(processedQuery)) {
      // Set country filter to US for better results
      queryParams['country'] = 'us';
      debugPrint("[DEBUG] Adding US country filter based on query pattern");
    }

    final url = Uri.https(
      _baseUrl,
      '$_geocodingPath/${Uri.encodeComponent(processedQuery)}.json',
      queryParams,
    );

    debugPrint("[DEBUG] Search API Request: $url");
    final response = await http.get(url);

    debugPrint("[DEBUG] Search API Response status: ${response.statusCode}");
    if (response.statusCode == 200) {
      debugPrint("[DEBUG] Search API Response body length: ${response.body.length} bytes");

      // For Two Rivers Ct specifically, log more details
      if (processedQuery.toLowerCase().contains('two rivers') &&
          (processedQuery.toLowerCase().contains('ct') ||
           processedQuery.toLowerCase().contains('court'))) {
        debugPrint("[DEBUG] Two Rivers Ct special case detected, full response: ${response.body}");
      }

      final jsonData = json.decode(response.body);
      final features = jsonData['features'] as List;

      debugPrint("[DEBUG] Got ${features.length} raw results");

      // Parse results
      final results = features
        .map((feature) {
          try {
            return SearchResult.fromJson(feature, userPosition: proximity);
          } catch (e) {
            debugPrint("[DEBUG] Error parsing individual search result: $e");
            return null;
          }
        })
        .whereType<SearchResult>()
        .toList();

      // Apply smarter sorting and filtering:

      // First, extract the core components of the query for better matching
      final addressComponents = _extractAddressComponents(processedQuery);
      final stateCode = addressComponents['state'];
      final city = addressComponents['city'];
      final streetNumber = addressComponents['number'];
      final streetName = addressComponents['street'];

      // Special handling for "Two Rivers Ct" in Nashville (known problem address)
      bool isTwoRiversCt = false;
      if (processedQuery.toLowerCase().contains('two rivers') &&
          (processedQuery.toLowerCase().contains('ct') ||
           processedQuery.toLowerCase().contains('court'))) {
        isTwoRiversCt = true;
      }

      // Score results based on how well they match the key components
      final scoredResults = results.map((result) {
        double score = 1.0;

        // Exact matches for street number are high priority
        if (streetNumber != null &&
            result.placeName.contains(streetNumber)) {
          score *= 3.0;
        }

        // Matching street name is important
        if (streetName != null) {
          // Full match
          if (result.placeName.toLowerCase().contains(streetName.toLowerCase())) {
            score *= 2.5;
          }
          // Partial match (e.g., matching "Rivers" when searching for "Two Rivers")
          else if (streetName.toLowerCase().contains(' ')) {
            final streetParts = streetName.toLowerCase().split(' ');
            bool hasPartialMatch = streetParts.any(
              (part) => result.placeName.toLowerCase().contains(part) && part.length > 2);
            if (hasPartialMatch) {
              score *= 1.5;
            }
          }
        }

        // Special handling for Two Rivers Court in Nashville
        if (isTwoRiversCt &&
            result.placeName.toLowerCase().contains('two rivers') &&
            (result.placeName.toLowerCase().contains('ct') ||
             result.placeName.toLowerCase().contains('court'))) {
          score *= 5.0; // Strong boost for this specific case
        }

        // City match is also valuable
        if (city != null &&
            result.placeName.toLowerCase().contains(city.toLowerCase())) {
          score *= 1.8;
        }

        // State match helps confirm geographic region
        if (stateCode != null && _resultContainsState(result, stateCode)) {
          score *= 1.5;
        }

        // Consider proximity if we have user location
        if (proximity != null && result.proximityDistance != null) {
          // Apply an inverse distance score for nearby places (within 50km)
          // Higher for closer, with diminishing returns beyond 50km
          final distanceKm = result.proximityDistance! / 1000;
          if (distanceKm < 50) {
            score *= (1 + (1 - distanceKm / 50));
          }
        }

        // Type boost: Addresses get priority for address-like queries
        if (streetNumber != null &&
            (result.type == 'address' ||
             (result.addressComponents != null &&
              result.addressComponents!.containsKey('address')))) {
          score *= 2.0;
        }

        return {'result': result, 'score': score};
      }).toList();

      // Sort by score (highest first)
      scoredResults.sort((a, b) => (b['score'] as double).compareTo(a['score'] as double));

      // Extract results in sorted order, limited to requested count
      final sortedResults = scoredResults
          .take(limit)
          .map((item) => item['result'] as SearchResult)
          .toList();

      // Cache the result for future use
      _searchCache[cacheKey] = sortedResults;

      return sortedResults;
    } else {
      throw HttpException('Failed to search: ${response.statusCode}');
    }
  } catch (e) {
    print('Error searching places: $e');
    return [];
  }
}