refactor: remove deprecated GeocodingService and clean up warnings

- Delete deprecated geocoding.rs module
- Update imports and remove unused code
- Simplify event storage to extract coordinates only
- Fix code quality issues and eliminate all warnings

src/errors.rs

···
     };
 
     match extra.split_once(':') {
-        Some((message, param)) => (error_code.to_string(), param.trim().to_string()),
+        Some((_message, param)) => (error_code.to_string(), param.trim().to_string()),
         None => (error_code.to_string(), "".to_string()),
     }
 }

src/http/handle_create_event.rs

···
 use crate::http::middleware_i18n::Language;
 use crate::http::timezones::supported_timezones;
 use crate::http::utils::url_from_aturi;
-use crate::services::{NominatimClient, AddressGeocodingStrategies, AddressComponents};
 use crate::services::nominatim_client::GeoExt;
 use crate::storage::event::event_insert;
 

src/http/handle_event_location_venue.rs

···
 //! while maintaining full compatibility with existing location workflows.
 
 use axum::{
-    extract::{Path, Query, State},
+    extract::{Query, State},
     http::StatusCode,
     response::{Html, IntoResponse, Json},
 };
···
                 ));
 
                 // Add coordinates if available (extract from Geo enum)
-                if let crate::atproto::lexicon::community::lexicon::location::Geo::Current { latitude, longitude, .. } = &venue.geo {
-                    html.push_str(&format!(
-                        r#"<input type="hidden" name="latitude" value="{}" hx-swap-oob="true">"#,
-                        latitude
-                    ));
-                    html.push_str(&format!(
-                        r#"<input type="hidden" name="longitude" value="{}" hx-swap-oob="true">"#,
-                        longitude
-                    ));
-                }
+                let crate::atproto::lexicon::community::lexicon::location::Geo::Current { latitude, longitude, .. } = &venue.geo;
+                html.push_str(&format!(
+                    r#"<input type="hidden" name="latitude" value="{}" hx-swap-oob="true">"#,
+                    latitude
+                ));
+                html.push_str(&format!(
+                    r#"<input type="hidden" name="longitude" value="{}" hx-swap-oob="true">"#,
+                    longitude
+                ));
 
                 // Clear the venue search suggestions
                 html.push_str(r#"<div id="venue-suggestions" hx-swap-oob="innerHTML"></div>"#);

src/services/address_geocoding_strategies.rs

···
 //! ```
 
 use anyhow::Result;
-use crate::services::nominatim_client::{NominatimClient, NominatimSearchResult, NominatimError};
-use crate::atproto::lexicon::community::lexicon::location::Address;
+use crate::services::nominatim_client::{NominatimClient, NominatimSearchResult};
 use tracing;
 
 /// Address geocoding strategies with progressive fallback

src/services/geocoding.rs

···
-use anyhow::Result;
-use serde::{Deserialize, Serialize};
-use reqwest::Client;
-use std::time::Duration;
-
-/// Legacy geocoding result - DEPRECATED
-/// Use the new NominatimClient in nominatim_client.rs for new implementations
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[deprecated(note = "Use NominatimClient instead for lexicon-compatible venue data")]
-pub struct GeocodingResult {
-    pub latitude: f64,
-    pub longitude: f64,
-    pub display_name: String,
-}
-
-/// Legacy geocoding service - DEPRECATED
-/// Use the new NominatimClient in nominatim_client.rs for new implementations
-#[deprecated(note = "Use NominatimClient instead for lexicon-compatible venue data")]
-pub struct GeocodingService {
-    client: Client,
-}
-
-impl GeocodingService {
-    pub fn new() -> Self {
-        let client = Client::builder()
-            .timeout(Duration::from_secs(10))
-            .user_agent("Smokesignal-Events/1.0")
-            .build()
-            .unwrap_or_default();
-
-        Self { client }
-    }
-
-    /// Geocode an address string using multiple strategies
-    pub async fn geocode_address(&self, address: &str) -> Result<GeocodingResult> {
-        // Strategy 1: Try exact address
-        if let Ok(result) = self.geocode_exact(address).await {
-            return Ok(result);
-        }
-
-        // Strategy 2: Try simplified address (remove building numbers, etc.)
-        let simplified = self.simplify_address(address);
-        if simplified != address {
-            if let Ok(result) = self.geocode_exact(&simplified).await {
-                return Ok(result);
-            }
-        }
-
-        // Strategy 3: Try city/region only
-        let city_only = self.extract_city_from_address(address);
-        if !city_only.is_empty() && city_only != address {
-            if let Ok(result) = self.geocode_exact(&city_only).await {
-                return Ok(result);
-            }
-        }
-
-        Err(anyhow::anyhow!("Unable to geocode address: {}", address))
-    }
-
-    /// Perform exact geocoding using Nominatim
-    async fn geocode_exact(&self, address: &str) -> Result<GeocodingResult> {
-        let url = format!(
-            "https://localhost:8080/search?format=json&q={}&limit=1&addressdetails=1&accept-language=fr",
-            urlencoding::encode(address)
-        );
-
-        let response = self.client.get(&url).send().await?;
-        let data: Vec<NominatimResult> = response.json().await?;
-
-        if let Some(result) = data.first() {
-            Ok(GeocodingResult {
-                latitude: result.lat.parse()?,
-                longitude: result.lon.parse()?,
-                display_name: result.display_name.clone(),
-            })
-        } else {
-            Err(anyhow::anyhow!("No results found"))
-        }
-    }
-
-    /// Simplify address by removing only very specific details, preserving most address components
-    fn simplify_address(&self, address: &str) -> String {
-        let mut simplified = address.to_string();
-
-        // Remove house/building numbers at the beginning of the address
-        simplified = regex::Regex::new(r"^\d+(-\d+)?\s+")
-            .unwrap()
-            .replace(&simplified, "")
-            .to_string();
-
-        // Remove apartment/suite numbers (e.g., "Apt 123", "Suite 456") - these are too specific
-        // Updated regex to be case-insensitive and handle more variations
-        simplified = regex::Regex::new(r"(?i),?\s*(apt|apartment|suite|unit|#)\s*\d+\w*")
-            .unwrap()
-            .replace_all(&simplified, "")
-            .to_string();
-
-        // Remove postal codes (various formats) - often too specific for initial geocoding
-        simplified = regex::Regex::new(r"\b[A-Z]\d[A-Z]\s*\d[A-Z]\d\b")
-            .unwrap()
-            .replace_all(&simplified, "")
-            .to_string(); // Canadian postal codes
-        simplified = regex::Regex::new(r"\b\d{5}(-\d{4})?\b")
-            .unwrap()
-            .replace_all(&simplified, "")
-            .to_string(); // US ZIP codes
-
-        // Clean up extra whitespace and commas
-        simplified = regex::Regex::new(r"\s*,\s*,\s*")
-            .unwrap()
-            .replace_all(&simplified, ", ")
-            .to_string();
-        simplified = regex::Regex::new(r"\s+")
-            .unwrap()
-            .replace_all(&simplified, " ")
-            .trim()
-            .to_string();
-
-        simplified
-    }
-
-    /// Extract city/region from address for fallback geocoding
-    fn extract_city_from_address(&self, address: &str) -> String {
-        // Look for common patterns to extract city/province
-        let parts: Vec<&str> = address.split(',').collect();
-        
-        if parts.len() >= 2 {
-            // Strategy: Skip the first part (likely street address) and take city/region/country components
-            // For "123 Main St, Montreal, Quebec, Canada" -> take last 3: "Montreal, Quebec, Canada"
-            // For "Complex Address, Montreal, QC" -> take last 2: "Montreal, QC"
-            
-            let remaining_parts: Vec<&str> = parts.iter()
-                .skip(1) // Always skip the first part (street address)
-                .map(|s| s.trim())
-                .filter(|s| !s.is_empty())
-                .collect();
-            
-            remaining_parts.join(", ")
-        } else {
-            // Fallback: try to extract just words (remove numbers and special chars)
-            regex::Regex::new(r"[^\w\s,]")
-                .unwrap()
-                .replace_all(address, "")
-                .trim()
-                .to_string()
-        }
-    }
-}
-
-#[derive(Debug, Deserialize)]
-struct NominatimResult {
-    lat: String,
-    lon: String,
-    display_name: String,
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_simplify_address() {
-        let service = GeocodingService::new();
-        
-        assert_eq!(
-            service.simplify_address("123 Main St, Apt 456, Montreal, QC H1A 1A1"),
-            "Main St, Montreal, QC"
-        );
-        
-        assert_eq!(
-            service.simplify_address("1000-1010 Sherbrooke St, Montreal, QC"),
-            "Sherbrooke St, Montreal, QC"
-        );
-    }
-
-    #[test]
-    fn test_extract_city() {
-        let service = GeocodingService::new();
-        
-        assert_eq!(
-            service.extract_city_from_address("123 Main St, Montreal, Quebec, Canada"),
-            "Montreal, Quebec, Canada"
-        );
-        
-        assert_eq!(
-            service.extract_city_from_address("Complex Address, Montreal, QC"),
-            "Montreal, QC"
-        );
-    }
-}

src/services/mod.rs

···
-pub mod geocoding;
 pub mod nominatim_client;
 pub mod address_geocoding_strategies;
 pub mod venues;
···
 #[cfg(test)]
 mod nominatim_client_tests;
 
-pub use geocoding::{GeocodingService, GeocodingResult};
 pub use nominatim_client::{NominatimClient, NominatimSearchResult, VenueMetadata, BilingualNames};
 pub use address_geocoding_strategies::{AddressGeocodingStrategies, AddressComponents, GeocodingStrategyResult};
 pub use venues::{
     VenueSearchService, VenueSearchRequest, VenueSearchResponse, VenueNearbyRequest,
-    VenueSearchResult, VenueDetails, VenueCategory, SearchRadius, handle_venue_search, 
+    VenueSearchResult, VenueDetails, VenueCategory, handle_venue_search, 
     handle_venue_nearby, handle_venue_enrich, handle_venue_suggest
 };
 pub use events::{EventVenueIntegrationService, VenueIntegrationError};

src/services/nominatim_client.rs

···
 #[derive(Debug, Deserialize)]
 struct NominatimApiResponse {
     place_id: Option<u64>,
+    #[allow(dead_code)]
     licence: Option<String>,
     osm_type: Option<String>,
     osm_id: Option<u64>,
···
     type_: Option<String>,
     place_rank: Option<u32>,
     importance: Option<f64>,
+    #[allow(dead_code)]
     addresstype: Option<String>,
     name: Option<String>,
     display_name: String,
···
 struct NominatimAddress {
     house_number: Option<String>,
     road: Option<String>,
+    #[allow(dead_code)]
     neighbourhood: Option<String>,
+    #[allow(dead_code)]
     suburb: Option<String>,
     city: Option<String>,
     town: Option<String>,
     village: Option<String>,
     municipality: Option<String>,
+    #[allow(dead_code)]
     county: Option<String>,
     state_district: Option<String>,
     state: Option<String>,
     region: Option<String>,
     postcode: Option<String>,
     country: Option<String>,
+    #[allow(dead_code)]
     country_code: Option<String>,
 }
 

src/services/venues/venue_cache.rs

···
 /// Cache TTL constants
 const VENUE_CACHE_TTL_SECS: u64 = 604800; // 7 days for venue enhancement data
 const SEARCH_CACHE_TTL_SECS: u64 = 86400; // 24 hours for search results
-const SUGGESTION_CACHE_TTL_SECS: u64 = 43200; // 12 hours for autocomplete suggestions
 
 /// Cache key prefixes for different data types
 const CACHE_PREFIX_VENUE_ENHANCEMENT: &str = "venue:enhanced";

src/services/venues/venue_endpoints.rs

···
     limit: Option<usize>,
 }
 
-/// Path parameters for venue enrichment endpoint
-#[derive(Debug, Deserialize)]
-pub struct VenueEnrichParams {
-    /// Latitude for venue enhancement lookup
-    lat: f64,
-    /// Longitude for venue enhancement lookup
-    lng: f64,
-}
-
 /// GET /api/venues/search - Text-based venue search
 pub async fn handle_venue_search(
     State(web_context): State<WebContext>,

src/services/venues/venue_search.rs

···
 use crate::services::nominatim_client::{NominatimClient, NominatimSearchResult};
 use super::venue_types::{
     VenueSearchRequest, VenueNearbyRequest, VenueSearchResponse, VenueSearchResult, 
-    VenueDetails, VenueQuality, SearchRadius
+    VenueDetails, VenueQuality
 };
 use super::venue_cache::{VenueCacheManager, VenueCacheError};
 
···
         }
     }
 
-    #[tokio::test]
-    async fn test_search_radius_validation() {
-        let valid_radius = SearchRadius::new(1000);
-        assert!(valid_radius.is_ok());
-        
-        let invalid_radius = SearchRadius::new(50);
-        assert!(invalid_radius.is_err());
-    }
+
 
     #[test]
     fn test_coordinate_validation() {

src/storage/event.rs

···
 use crate::atproto::lexicon::community::lexicon::calendar::rsvp::{
     Rsvp as RsvpLexicon, RsvpStatus as RsvpStatusLexicon,
 };
-use crate::services::GeocodingService;
 
 use super::errors::StorageError;
 use super::StoragePool;
···
     }
 }
 
-// Helper function to try geocoding an event record if it needs it
+// Helper function to extract coordinates from event record without geocoding
+// Geocoding should be handled at the API level using the venue services
 async fn try_geocode_event_record<T: serde::Serialize>(
     record: &T,
 ) -> (Option<(f64, f64)>, serde_json::Value) {
     // Try to parse the event record
-    if let Ok(mut event_record) = serde_json::from_str::<EventLexicon>(&serde_json::to_string(record).unwrap_or_default()) {
-        match &mut event_record {
+    if let Ok(event_record) = serde_json::from_str::<EventLexicon>(&serde_json::to_string(record).unwrap_or_default()) {
+        match &event_record {
             EventLexicon::Current { locations, .. } => {
-                // First, try to extract existing coordinates
+                // Extract existing coordinates only - no geocoding performed
                 let existing_coords = extract_coordinates_from_locations(locations);
-                
-                if existing_coords.is_some() {
-                    // Already has coordinates, use as-is
-                    (existing_coords, json!(record))
-                } else {
-                    // No coordinates found, try to geocode address-only locations
-                    let mut updated_locations = locations.clone();
-                    let mut found_coordinates = None;
-                    
-                    // Look for address-only locations to geocode
-                    for location in locations.iter() {
-                        if let crate::atproto::lexicon::community::lexicon::calendar::event::EventLocation::Address(address) = location {
-                            // Format the address for geocoding
-                            let address_string = format_address(address);
-                            if !address_string.trim().is_empty() {
-                                // Attempt to geocode the address
-                                let geocoding_service = GeocodingService::new();
-                                if let Ok(geocoding_result) = geocoding_service.geocode_address(&address_string).await {
-                                    // Create a Geo location with the coordinates
-                                    let geo_location = crate::atproto::lexicon::community::lexicon::location::Geo::Current {
-                                        latitude: geocoding_result.latitude.to_string(),
-                                        longitude: geocoding_result.longitude.to_string(),
-                                        name: Some(geocoding_result.display_name),
-                                    };
-                                    
-                                    // Add the geocoded location to the locations list
-                                    updated_locations.push(crate::atproto::lexicon::community::lexicon::calendar::event::EventLocation::Geo(geo_location));
-                                    
-                                    // Use these coordinates for spatial indexing
-                                    found_coordinates = Some((geocoding_result.latitude, geocoding_result.longitude));
-                                    break; // Only geocode the first address found
-                                }
-                            }
-                        }
-                    }
-                    
-                    // Update the event record with the new locations if we geocoded something
-                    if found_coordinates.is_some() {
-                        let updated_event = match event_record {
-                            EventLexicon::Current { name, description, created_at, starts_at, ends_at, mode, status, uris, extra, .. } => {
-                                EventLexicon::Current {
-                                    name,
-                                    description,
-                                    created_at,
-                                    starts_at,
-                                    ends_at,
-                                    mode,
-                                    status,
-                                    locations: updated_locations,
-                                    uris,
-                                    extra,
-                                }
-                            }
-                        };
-                        (found_coordinates, json!(updated_event))
-                    } else {
-                        // No geocoding performed, use original record
-                        (None, json!(record))
-                    }
-                }
+                (existing_coords, json!(record))
             }
         }
     } else {