use anyhow::Result;
use base64::Engine as _;
use chrono::{DateTime, NaiveDate, Utc};
use image::ImageFormat;
use opentelemetry::KeyValue;
use opentelemetry::trace::{Span, Status, TraceContextExt, Tracer};
use serde::Deserialize;
use std::fs::File;
use std::io::Cursor;
use std::sync::{Arc, Mutex};

use crate::ai::ollama::{ChatMessage, OllamaClient, Tool};
use crate::ai::sms_client::SmsApiClient;
use crate::database::models::InsertPhotoInsight;
use crate::database::{
    CalendarEventDao, DailySummaryDao, ExifDao, InsightDao, KnowledgeDao, LocationHistoryDao,
    SearchHistoryDao,
};
use crate::memories::extract_date_from_filename;
use crate::otel::global_tracer;
use crate::tags::TagDao;
use crate::utils::normalize_path;

#[derive(Deserialize)]
struct NominatimResponse {
    display_name: Option<String>,
    address: Option<NominatimAddress>,
}

#[derive(Deserialize)]
struct NominatimAddress {
    city: Option<String>,
    town: Option<String>,
    village: Option<String>,
    state: Option<String>,
}

#[derive(Clone)]
pub struct InsightGenerator {
    ollama: OllamaClient,
    sms_client: SmsApiClient,
    insight_dao: Arc<Mutex<Box<dyn InsightDao>>>,
    exif_dao: Arc<Mutex<Box<dyn ExifDao>>>,
    daily_summary_dao: Arc<Mutex<Box<dyn DailySummaryDao>>>,

    // Google Takeout data sources
    calendar_dao: Arc<Mutex<Box<dyn CalendarEventDao>>>,
    location_dao: Arc<Mutex<Box<dyn LocationHistoryDao>>>,
    search_dao: Arc<Mutex<Box<dyn SearchHistoryDao>>>,
    tag_dao: Arc<Mutex<Box<dyn TagDao>>>,

    // Knowledge memory
    knowledge_dao: Arc<Mutex<Box<dyn KnowledgeDao>>>,

    base_path: String,
}

impl InsightGenerator {
    pub fn new(
        ollama: OllamaClient,
        sms_client: SmsApiClient,
        insight_dao: Arc<Mutex<Box<dyn InsightDao>>>,
        exif_dao: Arc<Mutex<Box<dyn ExifDao>>>,
        daily_summary_dao: Arc<Mutex<Box<dyn DailySummaryDao>>>,
        calendar_dao: Arc<Mutex<Box<dyn CalendarEventDao>>>,
        location_dao: Arc<Mutex<Box<dyn LocationHistoryDao>>>,
        search_dao: Arc<Mutex<Box<dyn SearchHistoryDao>>>,
        tag_dao: Arc<Mutex<Box<dyn TagDao>>>,
        knowledge_dao: Arc<Mutex<Box<dyn KnowledgeDao>>>,
        base_path: String,
    ) -> Self {
        Self {
            ollama,
            sms_client,
            insight_dao,
            exif_dao,
            daily_summary_dao,
            calendar_dao,
            location_dao,
            search_dao,
            tag_dao,
            knowledge_dao,
            base_path,
        }
    }

    /// Extract contact name from file path
    /// e.g., "Sarah/img.jpeg" -> Some("Sarah")
    /// e.g., "img.jpeg" -> None
    fn extract_contact_from_path(file_path: &str) -> Option<String> {
        use std::path::Path;

        let path = Path::new(file_path);
        let components: Vec<_> = path.components().collect();

        // If path has at least 2 components (directory + file), extract first directory
        if components.len() >= 2
            && let Some(component) = components.first()
            && let Some(os_str) = component.as_os_str().to_str()
        {
            return Some(os_str.to_string());
        }

        None
    }

    /// Load image file, resize it, and encode as base64 for vision models
    /// Resizes to max 1024px on longest edge to reduce context usage
    fn load_image_as_base64(&self, file_path: &str) -> Result<String> {
        use image::imageops::FilterType;
        use std::path::Path;

        let full_path = Path::new(&self.base_path).join(file_path);

        log::debug!("Loading image for vision model: {:?}", full_path);

        // Open and decode the image
        let img = image::open(&full_path)
            .map_err(|e| anyhow::anyhow!("Failed to open image file: {}", e))?;

        let (original_width, original_height) = (img.width(), img.height());

        // Resize to max 1024px on longest edge
        let resized = img.resize(1024, 1024, FilterType::Lanczos3);

        log::debug!(
            "Resized image from {}x{} to {}x{}",
            original_width,
            original_height,
            resized.width(),
            resized.height()
        );

        // Encode as JPEG at 85% quality
        let mut buffer = Vec::new();
        let mut cursor = Cursor::new(&mut buffer);
        resized
            .write_to(&mut cursor, ImageFormat::Jpeg)
            .map_err(|e| anyhow::anyhow!("Failed to encode image as JPEG: {}", e))?;

        let base64_string = base64::engine::general_purpose::STANDARD.encode(&buffer);

        log::debug!(
            "Encoded image as base64 ({} bytes -> {} chars)",
            buffer.len(),
            base64_string.len()
        );

        Ok(base64_string)
    }

    /// Find relevant messages using RAG, excluding recent messages (>30 days ago)
    /// This prevents RAG from returning messages already in the immediate time window
    async fn find_relevant_messages_rag_historical(
        &self,
        parent_cx: &opentelemetry::Context,
        date: chrono::NaiveDate,
        location: Option<&str>,
        contact: Option<&str>,
        topics: Option<&[String]>,
        limit: usize,
        extra_context: Option<&str>,
    ) -> Result<Vec<String>> {
        let tracer = global_tracer();
        let span = tracer.start_with_context("ai.rag.filter_historical", parent_cx);
        let filter_cx = parent_cx.with_span(span);

        filter_cx
            .span()
            .set_attribute(KeyValue::new("date", date.to_string()));
        filter_cx
            .span()
            .set_attribute(KeyValue::new("limit", limit as i64));
        filter_cx
            .span()
            .set_attribute(KeyValue::new("exclusion_window_days", 30));
        if let Some(t) = topics {
            filter_cx
                .span()
                .set_attribute(KeyValue::new("topics", t.join(", ")));
        }

        let query_results = self
            .find_relevant_messages_rag(date, location, contact, topics, limit * 2, extra_context)
            .await?;

        filter_cx.span().set_attribute(KeyValue::new(
            "rag_results_count",
            query_results.len() as i64,
        ));

        // Filter out messages from within 30 days of the photo date
        let photo_timestamp = date
            .and_hms_opt(12, 0, 0)
            .ok_or_else(|| anyhow::anyhow!("Invalid date"))?
            .and_utc()
            .timestamp();
        let exclusion_window = 30 * 86400; // 30 days in seconds

        let historical_only: Vec<String> = query_results
            .into_iter()
            .filter(|msg| {
                // Extract date from formatted daily summary "[2024-08-15] Contact ..."
                if let Some(bracket_end) = msg.find(']')
                    && let Some(date_str) = msg.get(1..bracket_end)
                {
                    // Parse just the date (daily summaries don't have time)
                    if let Ok(msg_date) = chrono::NaiveDate::parse_from_str(date_str, "%Y-%m-%d") {
                        let msg_timestamp = msg_date
                            .and_hms_opt(12, 0, 0)
                            .unwrap()
                            .and_utc()
                            .timestamp();
                        let time_diff = (photo_timestamp - msg_timestamp).abs();
                        return time_diff > exclusion_window;
                    }
                }
                false
            })
            .take(limit)
            .collect();

        log::info!(
            "Found {} historical messages (>30 days from photo date)",
            historical_only.len()
        );

        filter_cx.span().set_attribute(KeyValue::new(
            "historical_results_count",
            historical_only.len() as i64,
        ));
        filter_cx.span().set_status(Status::Ok);

        Ok(historical_only)
    }

    /// Find relevant daily summaries using RAG (semantic search)
    /// Returns formatted daily summary strings for LLM context
    async fn find_relevant_messages_rag(
        &self,
        date: chrono::NaiveDate,
        location: Option<&str>,
        contact: Option<&str>,
        topics: Option<&[String]>,
        limit: usize,
        extra_context: Option<&str>,
    ) -> Result<Vec<String>> {
        let tracer = global_tracer();
        let current_cx = opentelemetry::Context::current();
        let mut span = tracer.start_with_context("ai.rag.search_daily_summaries", &current_cx);
        span.set_attribute(KeyValue::new("date", date.to_string()));
        span.set_attribute(KeyValue::new("limit", limit as i64));
        if let Some(loc) = location {
            span.set_attribute(KeyValue::new("location", loc.to_string()));
        }
        if let Some(c) = contact {
            span.set_attribute(KeyValue::new("contact", c.to_string()));
        }

        // Build query string - prioritize topics if available (semantically meaningful)
        let base_query = if let Some(topics) = topics {
            if !topics.is_empty() {
                // Use topics for semantic search - these are actual content keywords
                let topic_str = topics.join(", ");
                if let Some(c) = contact {
                    format!("Conversations about {} with {}", topic_str, c)
                } else {
                    format!("Conversations about {}", topic_str)
                }
            } else {
                // Fallback to metadata-based query
                Self::build_metadata_query(date, location, contact)
            }
        } else {
            // Fallback to metadata-based query
            Self::build_metadata_query(date, location, contact)
        };

        let query = if let Some(extra) = extra_context {
            format!("{}. {}", base_query, extra)
        } else {
            base_query
        };

        span.set_attribute(KeyValue::new("query", query.clone()));

        // Create context with this span for child operations
        let search_cx = current_cx.with_span(span);

        log::info!("========================================");
        log::info!("RAG QUERY: {}", query);
        log::info!("========================================");

        // Generate embedding for the query
        let query_embedding = self.ollama.generate_embedding(&query).await?;

        // Search for similar daily summaries with time-based weighting
        // This prioritizes summaries temporally close to the query date
        let mut summary_dao = self
            .daily_summary_dao
            .lock()
            .expect("Unable to lock DailySummaryDao");

        let date_str = date.format("%Y-%m-%d").to_string();
        let similar_summaries = summary_dao
            .find_similar_summaries_with_time_weight(&search_cx, &query_embedding, &date_str, limit)
            .map_err(|e| anyhow::anyhow!("Failed to find similar summaries: {:?}", e))?;

        log::info!(
            "Found {} relevant daily summaries via RAG",
            similar_summaries.len()
        );

        search_cx.span().set_attribute(KeyValue::new(
            "results_count",
            similar_summaries.len() as i64,
        ));

        // Format daily summaries for LLM context
        let formatted = similar_summaries
            .into_iter()
            .map(|s| {
                format!(
                    "[{}] {} ({} messages):\n{}",
                    s.date, s.contact, s.message_count, s.summary
                )
            })
            .collect();

        search_cx.span().set_status(Status::Ok);

        Ok(formatted)
    }

    /// Build a metadata-based query (fallback when no topics available)
    fn build_metadata_query(
        date: chrono::NaiveDate,
        location: Option<&str>,
        contact: Option<&str>,
    ) -> String {
        let mut query_parts = Vec::new();

        // Add temporal context
        query_parts.push(format!("On {}", date.format("%B %d, %Y")));

        // Add location if available
        if let Some(loc) = location {
            query_parts.push(format!("at {}", loc));
        }

        // Add contact context if available
        if let Some(c) = contact {
            query_parts.push(format!("conversation with {}", c));
        }

        // Add day of week for temporal context
        let weekday = date.format("%A");
        query_parts.push(format!("it was a {}", weekday));

        query_parts.join(", ")
    }

    /// Haversine distance calculation for GPS proximity (in kilometers)
    fn haversine_distance(lat1: f64, lon1: f64, lat2: f64, lon2: f64) -> f64 {
        const R: f64 = 6371.0; // Earth radius in km
        let d_lat = (lat2 - lat1).to_radians();
        let d_lon = (lon2 - lon1).to_radians();
        let a = (d_lat / 2.0).sin().powi(2)
            + lat1.to_radians().cos() * lat2.to_radians().cos() * (d_lon / 2.0).sin().powi(2);
        R * 2.0 * a.sqrt().atan2((1.0 - a).sqrt())
    }

    /// Gather calendar context for photo timestamp
    /// Uses hybrid time + semantic search (±7 days, ranked by relevance)
    async fn gather_calendar_context(
        &self,
        parent_cx: &opentelemetry::Context,
        timestamp: i64,
        location: Option<&str>,
    ) -> Result<Option<String>> {
        let tracer = global_tracer();
        let span = tracer.start_with_context("ai.context.calendar", parent_cx);
        let calendar_cx = parent_cx.with_span(span);

        let query_embedding = if let Some(loc) = location {
            match self.ollama.generate_embedding(loc).await {
                Ok(emb) => Some(emb),
                Err(e) => {
                    log::warn!("Failed to generate embedding for location '{}': {}", loc, e);
                    None
                }
            }
        } else {
            None
        };

        let events = {
            let mut dao = self
                .calendar_dao
                .lock()
                .expect("Unable to lock CalendarEventDao");
            dao.find_relevant_events_hybrid(
                &calendar_cx,
                timestamp,
                7, // ±7 days window
                query_embedding.as_deref(),
                5, // Top 5 events
            )
            .ok()
        };

        calendar_cx.span().set_status(Status::Ok);

        if let Some(events) = events {
            if events.is_empty() {
                return Ok(None);
            }

            let formatted = events
                .iter()
                .map(|e| {
                    let date = DateTime::from_timestamp(e.start_time, 0)
                        .map(|dt| dt.format("%Y-%m-%d %H:%M").to_string())
                        .unwrap_or_else(|| "unknown".to_string());

                    let attendees = e
                        .attendees
                        .as_ref()
                        .and_then(|a| serde_json::from_str::<Vec<String>>(a).ok())
                        .map(|list| format!(" (with {})", list.join(", ")))
                        .unwrap_or_default();

                    format!("[{}] {}{}", date, e.summary, attendees)
                })
                .collect::<Vec<_>>()
                .join("\n");

            Ok(Some(format!("Calendar events:\n{}", formatted)))
        } else {
            Ok(None)
        }
    }

    /// Gather location context for photo timestamp
    /// Finds nearest location record (±30 minutes)
    async fn gather_location_context(
        &self,
        parent_cx: &opentelemetry::Context,
        timestamp: i64,
        exif_gps: Option<(f64, f64)>,
    ) -> Result<Option<String>> {
        let tracer = global_tracer();
        let span = tracer.start_with_context("ai.context.location", parent_cx);
        let location_cx = parent_cx.with_span(span);

        let nearest = {
            let mut dao = self
                .location_dao
                .lock()
                .expect("Unable to lock LocationHistoryDao");
            dao.find_nearest_location(
                &location_cx,
                timestamp,
                10800, // ±3 hours (more realistic for photo timing)
            )
            .ok()
            .flatten()
        };

        location_cx.span().set_status(Status::Ok);

        if let Some(loc) = nearest {
            // Check if this adds NEW information compared to EXIF
            if let Some((exif_lat, exif_lon)) = exif_gps {
                let distance =
                    Self::haversine_distance(exif_lat, exif_lon, loc.latitude, loc.longitude);

                // Skip only if very close AND no useful activity/place info
                // Allow activity context even if coordinates match
                if distance < 0.5 && loc.activity.is_none() && loc.place_name.is_none() {
                    log::debug!(
                        "Location history matches EXIF GPS ({}m) with no extra context, skipping",
                        (distance * 1000.0) as i32
                    );
                    return Ok(None);
                } else if distance < 0.5 {
                    log::debug!(
                        "Location history close to EXIF ({}m) but has activity/place info",
                        (distance * 1000.0) as i32
                    );
                }
            }

            let activity = loc
                .activity
                .as_ref()
                .map(|a| format!(" ({})", a))
                .unwrap_or_default();

            let place = loc
                .place_name
                .as_ref()
                .map(|p| format!(" at {}", p))
                .unwrap_or_default();

            Ok(Some(format!(
                "Location history: You were{}{}{}",
                activity,
                place,
                if activity.is_empty() && place.is_empty() {
                    format!(" near {:.4}, {:.4}", loc.latitude, loc.longitude)
                } else {
                    String::new()
                }
            )))
        } else {
            Ok(None)
        }
    }

    /// Gather search context for photo date
    /// Uses semantic search on queries (±30 days, top 5 relevant)
    async fn gather_search_context(
        &self,
        parent_cx: &opentelemetry::Context,
        timestamp: i64,
        location: Option<&str>,
        contact: Option<&str>,
        enrichment: Option<&str>,
    ) -> Result<Option<String>> {
        let tracer = global_tracer();
        let span = tracer.start_with_context("ai.context.search", parent_cx);
        let search_cx = parent_cx.with_span(span);

        // Use enrichment (topics + photo description + tags) if available;
        // fall back to generic temporal query.
        let query_text = if let Some(enriched) = enrichment {
            enriched.to_string()
        } else {
            // Fallback: generic temporal query
            format!(
                "searches about {} {} {}",
                DateTime::from_timestamp(timestamp, 0)
                    .map(|dt| dt.format("%B %Y").to_string())
                    .unwrap_or_default(),
                location.unwrap_or(""),
                contact
                    .map(|c| format!("involving {}", c))
                    .unwrap_or_default()
            )
        };

        let query_embedding = match self.ollama.generate_embedding(&query_text).await {
            Ok(emb) => emb,
            Err(e) => {
                log::warn!("Failed to generate search embedding: {}", e);
                search_cx.span().set_status(Status::Error {
                    description: e.to_string().into(),
                });
                return Ok(None);
            }
        };

        let searches = {
            let mut dao = self
                .search_dao
                .lock()
                .expect("Unable to lock SearchHistoryDao");
            dao.find_relevant_searches_hybrid(
                &search_cx,
                timestamp,
                30, // ±30 days (wider window than calendar)
                Some(&query_embedding),
                5, // Top 5 searches
            )
            .ok()
        };

        search_cx.span().set_status(Status::Ok);

        if let Some(searches) = searches {
            if searches.is_empty() {
                log::warn!(
                    "No relevant searches found for photo timestamp {}",
                    timestamp
                );
                return Ok(None);
            }

            let formatted = searches
                .iter()
                .map(|s| {
                    let date = DateTime::from_timestamp(s.timestamp, 0)
                        .map(|dt| dt.format("%Y-%m-%d").to_string())
                        .unwrap_or_else(|| "unknown".to_string());
                    format!("[{}] \"{}\"", date, s.query)
                })
                .collect::<Vec<_>>()
                .join("\n");

            Ok(Some(format!("Search history:\n{}", formatted)))
        } else {
            Ok(None)
        }
    }

    /// Combine all context sources with equal weight
    fn combine_contexts(
        sms: Option<String>,
        calendar: Option<String>,
        location: Option<String>,
        search: Option<String>,
        tags: Option<String>,
    ) -> String {
        let mut parts = Vec::new();

        if let Some(s) = sms {
            parts.push(format!("## Messages\n{}", s));
        }
        if let Some(c) = calendar {
            parts.push(format!("## Calendar\n{}", c));
        }
        if let Some(l) = location {
            parts.push(format!("## Location\n{}", l));
        }
        if let Some(s) = search {
            parts.push(format!("## Searches\n{}", s));
        }
        if let Some(t) = tags {
            parts.push(format!("## Tags\n{}", t));
        }

        if parts.is_empty() {
            "No additional context available".to_string()
        } else {
            parts.join("\n\n")
        }
    }

    /// Generate AI insight for a single photo with custom configuration
    pub async fn generate_insight_for_photo_with_config(
        &self,
        file_path: &str,
        custom_model: Option<String>,
        custom_system_prompt: Option<String>,
        num_ctx: Option<i32>,
    ) -> Result<()> {
        let tracer = global_tracer();
        let current_cx = opentelemetry::Context::current();
        let mut span = tracer.start_with_context("ai.insight.generate", &current_cx);

        // Normalize path to ensure consistent forward slashes in database
        let file_path = normalize_path(file_path);
        log::info!("Generating insight for photo: {}", file_path);

        span.set_attribute(KeyValue::new("file_path", file_path.clone()));

        // Create custom Ollama client if model is specified
        let mut ollama_client = if let Some(model) = custom_model {
            log::info!("Using custom model: {}", model);
            span.set_attribute(KeyValue::new("custom_model", model.clone()));
            OllamaClient::new(
                self.ollama.primary_url.clone(),
                self.ollama.fallback_url.clone(),
                model.clone(),
                Some(model), // Use the same custom model for fallback server
            )
        } else {
            span.set_attribute(KeyValue::new("model", self.ollama.primary_model.clone()));
            self.ollama.clone()
        };

        // Set context size if specified
        if let Some(ctx) = num_ctx {
            log::info!("Using custom context size: {}", ctx);
            span.set_attribute(KeyValue::new("num_ctx", ctx as i64));
            ollama_client.set_num_ctx(Some(ctx));
        }

        // Create context with this span for child operations
        let insight_cx = current_cx.with_span(span);

        // 1. Get EXIF data for the photo
        let exif = {
            let mut exif_dao = self.exif_dao.lock().expect("Unable to lock ExifDao");
            exif_dao
                .get_exif(&insight_cx, &file_path)
                .map_err(|e| anyhow::anyhow!("Failed to get EXIF: {:?}", e))?
        };

        // Get full timestamp for proximity-based message filtering
        let timestamp = if let Some(ts) = exif.as_ref().and_then(|e| e.date_taken) {
            ts
        } else {
            log::warn!("No date_taken in EXIF for {}, trying filename", file_path);

            extract_date_from_filename(&file_path)
                .map(|dt| dt.timestamp())
                .or_else(|| {
                    // Combine base_path with file_path to get full path
                    let full_path = std::path::Path::new(&self.base_path).join(&file_path);
                    File::open(&full_path)
                        .and_then(|f| f.metadata())
                        .and_then(|m| m.created().or(m.modified()))
                        .map(|t| DateTime::<Utc>::from(t).timestamp())
                        .inspect_err(|e| {
                            log::warn!(
                                "Failed to get file timestamp for insight {}: {}",
                                file_path,
                                e
                            )
                        })
                        .ok()
                })
                .unwrap_or_else(|| Utc::now().timestamp())
        };

        let date_taken = DateTime::from_timestamp(timestamp, 0)
            .map(|dt| dt.date_naive())
            .unwrap_or_else(|| Utc::now().date_naive());

        // 3. Extract contact name from file path
        let contact = Self::extract_contact_from_path(&file_path);
        log::info!("Extracted contact from path: {:?}", contact);

        insight_cx
            .span()
            .set_attribute(KeyValue::new("date_taken", date_taken.to_string()));
        if let Some(ref c) = contact {
            insight_cx
                .span()
                .set_attribute(KeyValue::new("contact", c.clone()));
        }

        // Fetch file tags (used to enrich RAG and final context)
        let tag_names: Vec<String> = {
            let mut dao = self.tag_dao.lock().expect("Unable to lock TagDao");
            dao.get_tags_for_path(&insight_cx, &file_path)
                .unwrap_or_else(|e| {
                    log::warn!("Failed to fetch tags for insight {}: {}", file_path, e);
                    Vec::new()
                })
                .into_iter()
                .map(|t| t.name)
                .collect()
        };
        log::info!(
            "Fetched {} tags for photo: {:?}",
            tag_names.len(),
            tag_names
        );

        // 4. Get location name from GPS coordinates (needed for RAG query)
        let location = match exif {
            Some(ref exif) => {
                if let (Some(lat), Some(lon)) = (exif.gps_latitude, exif.gps_longitude) {
                    let loc = self.reverse_geocode(lat as f64, lon as f64).await;
                    if let Some(ref l) = loc {
                        insight_cx
                            .span()
                            .set_attribute(KeyValue::new("location", l.clone()));
                        Some(l.clone())
                    } else {
                        // Fallback: If reverse geocoding fails, use coordinates
                        log::warn!(
                            "Reverse geocoding failed for {}, {}, using coordinates as fallback",
                            lat,
                            lon
                        );
                        Some(format!("{:.4}, {:.4}", lat, lon))
                    }
                } else {
                    None
                }
            }
            None => None,
        };

        // Check if the model has vision capabilities
        let model_to_check = ollama_client.primary_model.clone();
        let has_vision = match OllamaClient::check_model_capabilities(
            &ollama_client.primary_url,
            &model_to_check,
        )
        .await
        {
            Ok(capabilities) => {
                log::info!(
                    "Model '{}' vision capability: {}",
                    model_to_check,
                    capabilities.has_vision
                );
                capabilities.has_vision
            }
            Err(e) => {
                log::warn!(
                    "Failed to check vision capabilities for model '{}', assuming no vision support: {}",
                    model_to_check,
                    e
                );
                false
            }
        };

        insight_cx
            .span()
            .set_attribute(KeyValue::new("model_has_vision", has_vision));

        // Load image and encode as base64 only if model supports vision
        let image_base64 = if has_vision {
            match self.load_image_as_base64(&file_path) {
                Ok(b64) => {
                    log::info!(
                        "Successfully loaded image for vision-capable model '{}'",
                        model_to_check
                    );
                    Some(b64)
                }
                Err(e) => {
                    log::warn!("Failed to load image for vision model: {}", e);
                    None
                }
            }
        } else {
            log::info!(
                "Model '{}' does not support vision, skipping image processing",
                model_to_check
            );
            None
        };

        // Generate brief photo description for RAG enrichment (vision models only)
        let photo_description: Option<String> = if let Some(ref img_b64) = image_base64 {
            match ollama_client.generate_photo_description(img_b64).await {
                Ok(desc) => {
                    log::info!("Photo description for RAG enrichment: {}", desc);
                    Some(desc)
                }
                Err(e) => {
                    log::warn!(
                        "Failed to generate photo description for RAG enrichment: {}",
                        e
                    );
                    None
                }
            }
        } else {
            None
        };

        // Build enriched context string for RAG: photo description + tags
        // (SMS topics are passed separately to RAG functions)
        let enriched_query: Option<String> = {
            let mut parts: Vec<String> = Vec::new();
            if let Some(ref desc) = photo_description {
                parts.push(desc.clone());
            }
            if !tag_names.is_empty() {
                parts.push(format!("tags: {}", tag_names.join(", ")));
            }
            if parts.is_empty() {
                None
            } else {
                Some(parts.join(". "))
            }
        };

        let mut search_enrichment: Option<String> = enriched_query.clone();

        // 5. Intelligent retrieval: Hybrid approach for better context
        let mut sms_summary = None;
        let mut used_rag = false;

        // TEMPORARY: Set to true to disable RAG and use only time-based retrieval for testing
        let disable_rag_for_testing = false;

        if disable_rag_for_testing {
            log::warn!("RAG DISABLED FOR TESTING - Using only time-based retrieval (±4 days)");
            // Skip directly to fallback
        } else {
            // ALWAYS use Strategy B: Expanded immediate context + historical RAG
            // This is more reliable than pure semantic search which can match irrelevant messages
            log::info!("Using expanded immediate context + historical RAG approach");

            // Step 1: Get FULL immediate temporal context (±4 days, ALL messages)
            let immediate_messages = self
                .sms_client
                .fetch_messages_for_contact(contact.as_deref(), timestamp)
                .await
                .unwrap_or_else(|e| {
                    log::error!("Failed to fetch immediate messages: {}", e);
                    Vec::new()
                });

            log::info!(
                "Fetched {} messages from ±4 days window (using ALL for immediate context)",
                immediate_messages.len()
            );

            if !immediate_messages.is_empty() {
                // Step 2: Extract topics from immediate messages to enrich RAG query
                let topics = self
                    .extract_topics_from_messages(&immediate_messages, &ollama_client)
                    .await;

                log::info!("Extracted topics for query enrichment: {:?}", topics);

                // Build full search enrichment: SMS topics + photo description + tag names
                search_enrichment = {
                    let mut parts: Vec<String> = Vec::new();
                    if !topics.is_empty() {
                        parts.push(topics.join(", "));
                    }
                    if let Some(ref desc) = photo_description {
                        parts.push(desc.clone());
                    }
                    if !tag_names.is_empty() {
                        parts.push(format!("tags: {}", tag_names.join(", ")));
                    }
                    if parts.is_empty() {
                        None
                    } else {
                        Some(parts.join(". "))
                    }
                };

                // Step 3: Try historical RAG (>30 days ago) using extracted topics
                let topics_slice = if topics.is_empty() {
                    None
                } else {
                    Some(topics.as_slice())
                };
                match self
                    .find_relevant_messages_rag_historical(
                        &insight_cx,
                        date_taken,
                        None,
                        contact.as_deref(),
                        topics_slice,
                        10, // Top 10 historical matches
                        enriched_query.as_deref(),
                    )
                    .await
                {
                    Ok(historical_messages) if !historical_messages.is_empty() => {
                        log::info!(
                            "Two-context approach: {} immediate (full conversation) + {} historical (similar past moments)",
                            immediate_messages.len(),
                            historical_messages.len()
                        );
                        used_rag = true;

                        // Step 4: Summarize contexts separately, then combine
                        let immediate_summary = self
                            .summarize_context_from_messages(
                                &immediate_messages,
                                &ollama_client,
                                custom_system_prompt.as_deref(),
                            )
                            .await
                            .unwrap_or_else(|| String::from("No immediate context"));

                        let historical_summary = self
                            .summarize_messages(
                                &historical_messages,
                                &ollama_client,
                                custom_system_prompt.as_deref(),
                            )
                            .await
                            .unwrap_or_else(|| String::from("No historical context"));

                        // Combine summaries
                        sms_summary = Some(format!(
                            "Immediate context (±4 days): {}\n\nSimilar moments from the past: {}",
                            immediate_summary, historical_summary
                        ));
                    }
                    Ok(_) => {
                        // RAG found no historical matches, just use immediate context
                        log::info!("No historical RAG matches, using immediate context only");
                        sms_summary = self
                            .summarize_context_from_messages(
                                &immediate_messages,
                                &ollama_client,
                                custom_system_prompt.as_deref(),
                            )
                            .await;
                    }
                    Err(e) => {
                        log::warn!("Historical RAG failed, using immediate context only: {}", e);
                        sms_summary = self
                            .summarize_context_from_messages(
                                &immediate_messages,
                                &ollama_client,
                                custom_system_prompt.as_deref(),
                            )
                            .await;
                    }
                }
            } else {
                log::info!("No immediate messages found, trying basic RAG as fallback");
                // Fallback to basic RAG even without strong query
                match self
                    .find_relevant_messages_rag(
                        date_taken,
                        None,
                        contact.as_deref(),
                        None,
                        20,
                        enriched_query.as_deref(),
                    )
                    .await
                {
                    Ok(rag_messages) if !rag_messages.is_empty() => {
                        used_rag = true;
                        sms_summary = self
                            .summarize_messages(
                                &rag_messages,
                                &ollama_client,
                                custom_system_prompt.as_deref(),
                            )
                            .await;
                    }
                    _ => {}
                }
            }
        }

        // 6. Fallback to traditional time-based message retrieval if RAG didn't work
        if !used_rag {
            log::info!("Using traditional time-based message retrieval (±4 days)");
            let sms_messages = self
                .sms_client
                .fetch_messages_for_contact(contact.as_deref(), timestamp)
                .await
                .unwrap_or_else(|e| {
                    log::error!("Failed to fetch SMS messages: {}", e);
                    Vec::new()
                });

            log::info!(
                "Fetched {} SMS messages closest to {}",
                sms_messages.len(),
                DateTime::from_timestamp(timestamp, 0)
                    .map(|dt| dt.format("%Y-%m-%d %H:%M:%S").to_string())
                    .unwrap_or_else(|| "unknown time".to_string())
            );

            // Summarize time-based messages
            if !sms_messages.is_empty() {
                match self
                    .sms_client
                    .summarize_context(&sms_messages, &ollama_client)
                    .await
                {
                    Ok(summary) => {
                        sms_summary = Some(summary);
                    }
                    Err(e) => {
                        log::warn!("Failed to summarize SMS context: {}", e);
                    }
                }
            }
        }

        let retrieval_method = if used_rag { "RAG" } else { "time-based" };
        insight_cx
            .span()
            .set_attribute(KeyValue::new("retrieval_method", retrieval_method));
        insight_cx
            .span()
            .set_attribute(KeyValue::new("has_sms_context", sms_summary.is_some()));

        log::info!(
            "Photo context: date={}, location={:?}, retrieval_method={}",
            date_taken,
            location,
            retrieval_method
        );

        // 6. Gather Google Takeout context from all sources
        let calendar_context = self
            .gather_calendar_context(&insight_cx, timestamp, location.as_deref())
            .await
            .ok()
            .flatten();

        let exif_gps = exif.as_ref().and_then(|e| {
            if let (Some(lat), Some(lon)) = (e.gps_latitude, e.gps_longitude) {
                Some((lat as f64, lon as f64))
            } else {
                None
            }
        });

        let location_context = self
            .gather_location_context(&insight_cx, timestamp, exif_gps)
            .await
            .ok()
            .flatten();

        let search_context = self
            .gather_search_context(
                &insight_cx,
                timestamp,
                location.as_deref(),
                contact.as_deref(),
                search_enrichment.as_deref(),
            )
            .await
            .ok()
            .flatten();

        // 7. Combine all context sources with equal weight
        let tags_context = if tag_names.is_empty() {
            None
        } else {
            Some(tag_names.join(", "))
        };

        let combined_context = Self::combine_contexts(
            sms_summary,
            calendar_context,
            location_context,
            search_context,
            tags_context,
        );

        log::info!(
            "Combined context from all sources ({} chars)",
            combined_context.len()
        );

        // 10. Generate summary first, then derive title from the summary
        let summary = ollama_client
            .generate_photo_summary(
                date_taken,
                location.as_deref(),
                contact.as_deref(),
                Some(&combined_context),
                custom_system_prompt.as_deref(),
                image_base64.clone(),
            )
            .await?;

        let title = ollama_client
            .generate_photo_title(&summary, custom_system_prompt.as_deref())
            .await?;

        log::info!("Generated title: {}", title);
        log::info!("Generated summary: {}", summary);

        insight_cx
            .span()
            .set_attribute(KeyValue::new("title_length", title.len() as i64));
        insight_cx
            .span()
            .set_attribute(KeyValue::new("summary_length", summary.len() as i64));

        // 11. Store in database
        let insight = InsertPhotoInsight {
            file_path: file_path.to_string(),
            title,
            summary,
            generated_at: Utc::now().timestamp(),
            model_version: ollama_client.primary_model.clone(),
            is_current: true,
        };

        let mut dao = self.insight_dao.lock().expect("Unable to lock InsightDao");
        let result = dao
            .store_insight(&insight_cx, insight)
            .map_err(|e| anyhow::anyhow!("Failed to store insight: {:?}", e));

        match &result {
            Ok(_) => {
                log::info!("Successfully stored insight for {}", file_path);
                insight_cx.span().set_status(Status::Ok);
            }
            Err(e) => {
                log::error!("Failed to store insight: {:?}", e);
                insight_cx.span().set_status(Status::error(e.to_string()));
            }
        }

        result?;
        Ok(())
    }

    /// Extract key topics/entities from messages using LLM for query enrichment
    async fn extract_topics_from_messages(
        &self,
        messages: &[crate::ai::SmsMessage],
        ollama: &OllamaClient,
    ) -> Vec<String> {
        if messages.is_empty() {
            return Vec::new();
        }

        // Format a sample of messages for topic extraction
        let sample_size = messages.len().min(20);
        let sample_text: Vec<String> = messages
            .iter()
            .take(sample_size)
            .map(|m| format!("{}: {}", if m.is_sent { "Me" } else { &m.contact }, m.body))
            .collect();

        let prompt = format!(
            r#"Extract important entities from these messages that provide context about what was happening. Focus on:

1. **People**: Names of specific people mentioned (first names, nicknames)
2. **Places**: Locations, cities, buildings, workplaces, parks, restaurants, venues
3. **Activities**: Specific events, hobbies, groups, organizations (e.g., "drum corps", "auditions")
4. **Unique terms**: Domain-specific words or phrases that might need explanation (e.g., "Hyland", "Vanguard", "DCI")

Messages:
{}

Return a comma-separated list of 3-7 specific entities (people, places, activities, unique terms).
Focus on proper nouns and specific terms that provide context.
Return ONLY the comma-separated list, nothing else."#,
            sample_text.join("\n")
        );

        match ollama
            .generate(&prompt, Some("You are an entity extraction assistant. Extract proper nouns, people, places, and domain-specific terms that provide context."))
            .await
        {
            Ok(response) => {
                log::debug!("Topic extraction raw response: {}", response);

                // Parse comma-separated topics
                let topics: Vec<String> = response
                    .split(',')
                    .map(|s| s.trim().to_string())
                    .filter(|s| !s.is_empty() && s.len() > 1) // Filter out single chars
                    .take(7) // Increased from 5 to 7
                    .collect();

                if topics.is_empty() {
                    log::warn!("Topic extraction returned empty list from {} messages", messages.len());
                } else {
                    log::info!("Extracted {} topics from {} messages: {}", topics.len(), messages.len(), topics.join(", "));
                }

                topics
            }
            Err(e) => {
                log::warn!("Failed to extract topics from messages: {}", e);
                Vec::new()
            }
        }
    }

    /// Summarize pre-formatted message strings using LLM (concise version for historical context)
    async fn summarize_messages(
        &self,
        messages: &[String],
        ollama: &OllamaClient,
        custom_system: Option<&str>,
    ) -> Option<String> {
        if messages.is_empty() {
            return None;
        }

        let messages_text = messages.join("\n");

        let prompt = format!(
            r#"Summarize the context from these messages in 2-3 sentences. Focus on activities, locations, events, and relationships mentioned.

Messages:
{}

Return ONLY the summary, nothing else."#,
            messages_text
        );

        let system = custom_system
            .unwrap_or("You are a context summarization assistant. Be concise and factual.");

        match ollama.generate(&prompt, Some(system)).await {
            Ok(summary) => Some(summary),
            Err(e) => {
                log::warn!("Failed to summarize messages: {}", e);
                None
            }
        }
    }

    /// Convert SmsMessage objects to formatted strings and summarize with more detail
    /// This is used for immediate context (±2 days) to preserve conversation details
    async fn summarize_context_from_messages(
        &self,
        messages: &[crate::ai::SmsMessage],
        ollama: &OllamaClient,
        custom_system: Option<&str>,
    ) -> Option<String> {
        if messages.is_empty() {
            return None;
        }

        // Format messages
        let formatted: Vec<String> = messages
            .iter()
            .map(|m| {
                let sender = if m.is_sent { "Me" } else { &m.contact };
                let timestamp = chrono::DateTime::from_timestamp(m.timestamp, 0)
                    .map(|dt| dt.format("%Y-%m-%d %H:%M").to_string())
                    .unwrap_or_else(|| "unknown time".to_string());
                format!("[{}] {}: {}", timestamp, sender, m.body)
            })
            .collect();

        let messages_text = formatted.join("\n");

        // Use a more detailed prompt for immediate context
        let prompt = format!(
            r#"Provide a detailed summary of the conversation context from these messages. Include:
- Key activities, events, and plans discussed
- Important locations or places mentioned
- Emotional tone and relationship dynamics
- Any significant details that provide context about what was happening

Be thorough but organized. Use 1-2 paragraphs.

Messages:
{}

Return ONLY the summary, nothing else."#,
            messages_text
        );

        let system = custom_system.unwrap_or(
            "You are a context summarization assistant. Be detailed and factual, preserving important context.",
        );

        match ollama.generate(&prompt, Some(system)).await {
            Ok(summary) => Some(summary),
            Err(e) => {
                log::warn!("Failed to summarize immediate context: {}", e);
                None
            }
        }
    }

    // ── Tool executors for agentic loop ────────────────────────────────

    /// Dispatch a tool call to the appropriate executor
    async fn execute_tool(
        &self,
        tool_name: &str,
        arguments: &serde_json::Value,
        ollama: &OllamaClient,
        image_base64: &Option<String>,
        file_path: &str,
        cx: &opentelemetry::Context,
    ) -> String {
        let result = match tool_name {
            "search_rag" => self.tool_search_rag(arguments, cx).await,
            "get_sms_messages" => self.tool_get_sms_messages(arguments, cx).await,
            "get_calendar_events" => self.tool_get_calendar_events(arguments, cx).await,
            "get_location_history" => self.tool_get_location_history(arguments, cx).await,
            "get_file_tags" => self.tool_get_file_tags(arguments, cx).await,
            "describe_photo" => self.tool_describe_photo(ollama, image_base64).await,
            "reverse_geocode" => self.tool_reverse_geocode(arguments).await,
            "recall_entities" => self.tool_recall_entities(arguments, cx).await,
            "recall_facts_for_photo" => self.tool_recall_facts_for_photo(arguments, cx).await,
            "store_entity" => self.tool_store_entity(arguments, ollama, cx).await,
            "store_fact" => self.tool_store_fact(arguments, file_path, cx).await,
            unknown => format!("Unknown tool: {}", unknown),
        };
        if result.starts_with("Error") || result.starts_with("No ") {
            log::warn!("Tool '{}' result: {}", tool_name, result);
        } else {
            log::info!("Tool '{}' result: {} chars", tool_name, result.len());
        }
        result
    }

    /// Tool: search_rag — semantic search over daily summaries
    async fn tool_search_rag(
        &self,
        args: &serde_json::Value,
        _cx: &opentelemetry::Context,
    ) -> String {
        let query = match args.get("query").and_then(|v| v.as_str()) {
            Some(q) => q.to_string(),
            None => return "Error: missing required parameter 'query'".to_string(),
        };
        let date_str = match args.get("date").and_then(|v| v.as_str()) {
            Some(d) => d,
            None => return "Error: missing required parameter 'date'".to_string(),
        };
        let date = match NaiveDate::parse_from_str(date_str, "%Y-%m-%d") {
            Ok(d) => d,
            Err(e) => return format!("Error: failed to parse date '{}': {}", date_str, e),
        };
        let contact = args
            .get("contact")
            .and_then(|v| v.as_str())
            .map(|s| s.to_string());

        log::info!(
            "tool_search_rag: query='{}', date={}, contact={:?}",
            query,
            date,
            contact
        );

        match self
            .find_relevant_messages_rag(date, None, contact.as_deref(), None, 5, Some(&query))
            .await
        {
            Ok(results) if !results.is_empty() => results.join("\n\n"),
            Ok(_) => "No relevant messages found.".to_string(),
            Err(e) => format!("Error searching RAG: {}", e),
        }
    }

    /// Tool: get_sms_messages — fetch SMS messages near a date for a contact
    async fn tool_get_sms_messages(
        &self,
        args: &serde_json::Value,
        _cx: &opentelemetry::Context,
    ) -> String {
        let date_str = match args.get("date").and_then(|v| v.as_str()) {
            Some(d) => d,
            None => return "Error: missing required parameter 'date'".to_string(),
        };
        let contact = args
            .get("contact")
            .and_then(|v| v.as_str())
            .map(|s| s.to_string());
        let days_radius = args
            .get("days_radius")
            .and_then(|v| v.as_i64())
            .unwrap_or(4);

        let date = match NaiveDate::parse_from_str(date_str, "%Y-%m-%d") {
            Ok(d) => d,
            Err(e) => return format!("Error: failed to parse date '{}': {}", date_str, e),
        };
        let timestamp = date.and_hms_opt(12, 0, 0).unwrap().and_utc().timestamp();

        log::info!(
            "tool_get_sms_messages: date={}, contact={:?}, days_radius={}",
            date,
            contact,
            days_radius
        );

        match self
            .sms_client
            .fetch_messages_for_contact(contact.as_deref(), timestamp)
            .await
        {
            Ok(messages) if !messages.is_empty() => {
                let formatted: Vec<String> = messages
                    .iter()
                    .take(30)
                    .map(|m| {
                        let sender = if m.is_sent { "Me" } else { &m.contact };
                        let ts = DateTime::from_timestamp(m.timestamp, 0)
                            .map(|dt| dt.format("%Y-%m-%d %H:%M").to_string())
                            .unwrap_or_else(|| "unknown".to_string());
                        format!("[{}] {}: {}", ts, sender, m.body)
                    })
                    .collect();
                format!(
                    "Found {} messages:\n{}",
                    messages.len(),
                    formatted.join("\n")
                )
            }
            Ok(_) => "No messages found.".to_string(),
            Err(e) => {
                log::warn!("tool_get_sms_messages failed: {}", e);
                format!("Error fetching SMS messages: {}", e)
            }
        }
    }

    /// Tool: get_calendar_events — fetch calendar events near a date
    async fn tool_get_calendar_events(
        &self,
        args: &serde_json::Value,
        cx: &opentelemetry::Context,
    ) -> String {
        let date_str = match args.get("date").and_then(|v| v.as_str()) {
            Some(d) => d,
            None => return "Error: missing required parameter 'date'".to_string(),
        };
        let days_radius = args
            .get("days_radius")
            .and_then(|v| v.as_i64())
            .unwrap_or(7);

        let date = match NaiveDate::parse_from_str(date_str, "%Y-%m-%d") {
            Ok(d) => d,
            Err(e) => return format!("Error: failed to parse date '{}': {}", date_str, e),
        };
        let timestamp = date.and_hms_opt(12, 0, 0).unwrap().and_utc().timestamp();

        log::info!(
            "tool_get_calendar_events: date={}, days_radius={}",
            date,
            days_radius
        );

        let events = {
            let mut dao = self
                .calendar_dao
                .lock()
                .expect("Unable to lock CalendarEventDao");
            dao.find_relevant_events_hybrid(cx, timestamp, days_radius, None, 10)
                .ok()
        };

        match events {
            Some(evts) if !evts.is_empty() => {
                let formatted: Vec<String> = evts
                    .iter()
                    .map(|e| {
                        let dt = DateTime::from_timestamp(e.start_time, 0)
                            .map(|dt| dt.format("%Y-%m-%d %H:%M").to_string())
                            .unwrap_or_else(|| "unknown".to_string());
                        let loc = e
                            .location
                            .as_ref()
                            .map(|l| format!(" at {}", l))
                            .unwrap_or_default();
                        let attendees = e
                            .attendees
                            .as_ref()
                            .and_then(|a| serde_json::from_str::<Vec<String>>(a).ok())
                            .map(|list| format!(" (with {})", list.join(", ")))
                            .unwrap_or_default();
                        format!("[{}] {}{}{}", dt, e.summary, loc, attendees)
                    })
                    .collect();
                format!(
                    "Found {} calendar events:\n{}",
                    evts.len(),
                    formatted.join("\n")
                )
            }
            Some(_) => "No calendar events found.".to_string(),
            None => "No calendar events found.".to_string(),
        }
    }

    /// Tool: get_location_history — fetch location records near a date
    async fn tool_get_location_history(
        &self,
        args: &serde_json::Value,
        cx: &opentelemetry::Context,
    ) -> String {
        let date_str = match args.get("date").and_then(|v| v.as_str()) {
            Some(d) => d,
            None => return "Error: missing required parameter 'date'".to_string(),
        };
        let days_radius = args
            .get("days_radius")
            .and_then(|v| v.as_i64())
            .unwrap_or(14);

        let date = match NaiveDate::parse_from_str(date_str, "%Y-%m-%d") {
            Ok(d) => d,
            Err(e) => return format!("Error: failed to parse date '{}': {}", date_str, e),
        };
        let timestamp = date.and_hms_opt(12, 0, 0).unwrap().and_utc().timestamp();

        log::info!(
            "tool_get_location_history: date={}, days_radius={}",
            date,
            days_radius
        );

        let start_ts = timestamp - (days_radius * 86400);
        let end_ts = timestamp + (days_radius * 86400);

        let locations = {
            let mut dao = self
                .location_dao
                .lock()
                .expect("Unable to lock LocationHistoryDao");
            dao.find_locations_in_range(cx, start_ts, end_ts).ok()
        };

        match locations {
            Some(locs) if !locs.is_empty() => {
                let formatted: Vec<String> = locs
                    .iter()
                    .take(20)
                    .map(|loc| {
                        let dt = DateTime::from_timestamp(loc.timestamp, 0)
                            .map(|dt| dt.format("%Y-%m-%d %H:%M").to_string())
                            .unwrap_or_else(|| "unknown".to_string());
                        let activity = loc
                            .activity
                            .as_ref()
                            .map(|a| format!(" ({})", a))
                            .unwrap_or_default();
                        let place = loc
                            .place_name
                            .as_ref()
                            .map(|p| format!(" at {}", p))
                            .unwrap_or_default();
                        format!(
                            "[{}] {:.4}, {:.4}{}{}",
                            dt, loc.latitude, loc.longitude, place, activity
                        )
                    })
                    .collect();
                format!(
                    "Found {} location records:\n{}",
                    locs.len(),
                    formatted.join("\n")
                )
            }
            Some(_) => "No location history found.".to_string(),
            None => "No location history found.".to_string(),
        }
    }

    /// Tool: get_file_tags — fetch tags for a file path
    async fn tool_get_file_tags(
        &self,
        args: &serde_json::Value,
        cx: &opentelemetry::Context,
    ) -> String {
        let file_path = match args.get("file_path").and_then(|v| v.as_str()) {
            Some(p) => p.to_string(),
            None => return "Error: missing required parameter 'file_path'".to_string(),
        };

        log::info!("tool_get_file_tags: file_path='{}'", file_path);

        let tags = {
            let mut dao = self.tag_dao.lock().expect("Unable to lock TagDao");
            dao.get_tags_for_path(cx, &file_path).ok()
        };

        match tags {
            Some(t) if !t.is_empty() => {
                let names: Vec<String> = t.into_iter().map(|tag| tag.name).collect();
                names.join(", ")
            }
            Some(_) => "No tags found.".to_string(),
            None => "No tags found.".to_string(),
        }
    }

    /// Tool: describe_photo — generate a visual description of the photo
    async fn tool_describe_photo(
        &self,
        ollama: &OllamaClient,
        image_base64: &Option<String>,
    ) -> String {
        log::info!("tool_describe_photo: generating visual description");

        match image_base64 {
            Some(img) => match ollama.generate_photo_description(img).await {
                Ok(desc) => desc,
                Err(e) => format!("Error describing photo: {}", e),
            },
            None => "No image available for description.".to_string(),
        }
    }

    /// Tool: reverse_geocode — convert GPS coordinates to a human-readable place name
    async fn tool_reverse_geocode(&self, args: &serde_json::Value) -> String {
        let lat = match args.get("latitude").and_then(|v| v.as_f64()) {
            Some(v) => v,
            None => return "Error: missing required parameter 'latitude'".to_string(),
        };
        let lon = match args.get("longitude").and_then(|v| v.as_f64()) {
            Some(v) => v,
            None => return "Error: missing required parameter 'longitude'".to_string(),
        };

        log::info!("tool_reverse_geocode: lat={}, lon={}", lat, lon);

        match self.reverse_geocode(lat, lon).await {
            Some(place) => place,
            None => "Could not resolve coordinates to a place name.".to_string(),
        }
    }

    /// Tool: recall_entities — search the knowledge memory for known entities
    async fn tool_recall_entities(
        &self,
        args: &serde_json::Value,
        cx: &opentelemetry::Context,
    ) -> String {
        use crate::database::EntityFilter;

        let name_search = args
            .get("name")
            .and_then(|v| v.as_str())
            .map(|s| s.to_string());
        let entity_type = args
            .get("entity_type")
            .and_then(|v| v.as_str())
            .map(|s| s.to_string());
        let limit = args.get("limit").and_then(|v| v.as_i64()).unwrap_or(10);

        log::info!(
            "tool_recall_entities: name={:?}, type={:?}, limit={}",
            name_search,
            entity_type,
            limit
        );

        let filter = EntityFilter {
            entity_type,
            status: Some("active".to_string()),
            search: name_search,
            limit,
            offset: 0,
        };

        let mut kdao = self
            .knowledge_dao
            .lock()
            .expect("Unable to lock KnowledgeDao");
        match kdao.list_entities(cx, filter) {
            Ok((entities, _total)) if entities.is_empty() => {
                "No known entities found matching the query.".to_string()
            }
            Ok((entities, _total)) => {
                let lines: Vec<String> = entities
                    .iter()
                    .map(|e| {
                        format!(
                            "ID:{} | {} | {} | {} | confidence:{:.2}",
                            e.id, e.entity_type, e.name, e.description, e.confidence
                        )
                    })
                    .collect();
                format!("Known entities:\n{}", lines.join("\n"))
            }
            Err(e) => format!("Error recalling entities: {:?}", e),
        }
    }

    /// Tool: recall_facts_for_photo — retrieve facts linked to a specific photo
    async fn tool_recall_facts_for_photo(
        &self,
        args: &serde_json::Value,
        cx: &opentelemetry::Context,
    ) -> String {
        let file_path = match args.get("file_path").and_then(|v| v.as_str()) {
            Some(p) => p.to_string(),
            None => return "Error: missing required parameter 'file_path'".to_string(),
        };

        log::info!("tool_recall_facts_for_photo: file_path={}", file_path);

        let mut kdao = self
            .knowledge_dao
            .lock()
            .expect("Unable to lock KnowledgeDao");

        // Fetch photo links to find which entities appear in this photo
        let links = match kdao.get_links_for_photo(cx, &file_path) {
            Ok(l) => l,
            Err(e) => return format!("Error fetching photo links: {:?}", e),
        };

        if links.is_empty() {
            return "No knowledge facts found for this photo.".to_string();
        }

        let mut output_lines = Vec::new();
        let entity_ids: Vec<i32> = links.iter().map(|l| l.entity_id).collect();

        // For each linked entity, fetch its facts
        for entity_id in entity_ids {
            if let Ok(entity) = kdao.get_entity_by_id(cx, entity_id) {
                if let Some(e) = entity {
                    let role = links
                        .iter()
                        .find(|l| l.entity_id == entity_id)
                        .map(|l| l.role.as_str())
                        .unwrap_or("subject");
                    output_lines.push(format!(
                        "Entity: {} ({}, role: {})",
                        e.name, e.entity_type, role
                    ));
                    if let Ok(facts) = kdao.get_facts_for_entity(cx, entity_id) {
                        for f in facts.iter().filter(|f| f.status == "active") {
                            let obj = if let Some(ref v) = f.object_value {
                                v.clone()
                            } else if let Some(oid) = f.object_entity_id {
                                kdao.get_entity_by_id(cx, oid)
                                    .ok()
                                    .flatten()
                                    .map(|e| format!("{} (entity ID: {})", e.name, e.id))
                                    .unwrap_or_else(|| format!("entity:{}", oid))
                            } else {
                                "(unknown)".to_string()
                            };
                            output_lines.push(format!("  - {} {}", f.predicate, obj));
                        }
                    }
                }
            }
        }

        if output_lines.is_empty() {
            "No active knowledge facts found for this photo.".to_string()
        } else {
            format!("Knowledge for this photo:\n{}", output_lines.join("\n"))
        }
    }

    /// Tool: store_entity — upsert an entity into the knowledge memory
    async fn tool_store_entity(
        &self,
        args: &serde_json::Value,
        ollama: &OllamaClient,
        cx: &opentelemetry::Context,
    ) -> String {
        use crate::database::models::InsertEntity;

        let name = match args.get("name").and_then(|v| v.as_str()) {
            Some(n) => n.to_string(),
            None => return "Error: missing required parameter 'name'".to_string(),
        };
        let entity_type = match args.get("entity_type").and_then(|v| v.as_str()) {
            Some(t) => t.to_string(),
            None => return "Error: missing required parameter 'entity_type'".to_string(),
        };
        let description = args
            .get("description")
            .and_then(|v| v.as_str())
            .unwrap_or("")
            .to_string();

        log::info!(
            "tool_store_entity: name='{}', type='{}', description='{}'",
            name,
            entity_type,
            description
        );

        // Generate embedding for name + description (best-effort)
        let embed_text = format!("{} {}", name, description);
        let embedding: Option<Vec<u8>> = match ollama.generate_embedding(&embed_text).await {
            Ok(vec) => {
                let bytes: Vec<u8> = vec.iter().flat_map(|f| f.to_le_bytes()).collect();
                Some(bytes)
            }
            Err(e) => {
                log::warn!("Embedding generation failed for entity '{}': {}", name, e);
                None
            }
        };

        let now = chrono::Utc::now().timestamp();
        let insert = InsertEntity {
            name,
            entity_type,
            description,
            embedding,
            confidence: 0.6,
            status: "active".to_string(),
            created_at: now,
            updated_at: now,
        };

        let mut kdao = self
            .knowledge_dao
            .lock()
            .expect("Unable to lock KnowledgeDao");
        match kdao.upsert_entity(cx, insert) {
            Ok(entity) => format!(
                "Entity stored: ID:{} | {} | {} | confidence:{:.2}",
                entity.id, entity.entity_type, entity.name, entity.confidence
            ),
            Err(e) => format!("Error storing entity: {:?}", e),
        }
    }

    /// Tool: store_fact — record a fact about an entity, linked to the current photo
    async fn tool_store_fact(
        &self,
        args: &serde_json::Value,
        file_path: &str,
        cx: &opentelemetry::Context,
    ) -> String {
        use crate::database::models::{InsertEntityFact, InsertEntityPhotoLink};

        let subject_entity_id = match args.get("subject_entity_id").and_then(|v| v.as_i64()) {
            Some(id) => id as i32,
            None => return "Error: missing required parameter 'subject_entity_id'".to_string(),
        };
        let predicate = match args.get("predicate").and_then(|v| v.as_str()) {
            Some(p) => p.to_string(),
            None => return "Error: missing required parameter 'predicate'".to_string(),
        };
        let object_entity_id = args
            .get("object_entity_id")
            .and_then(|v| v.as_i64())
            .map(|id| id as i32);
        let object_value = args
            .get("object_value")
            .and_then(|v| v.as_str())
            .map(|s| s.to_string());

        if object_entity_id.is_none() && object_value.is_none() {
            return "Error: provide either object_entity_id or object_value".to_string();
        }

        let photo_role = args
            .get("photo_role")
            .and_then(|v| v.as_str())
            .unwrap_or("subject")
            .to_string();

        log::info!(
            "tool_store_fact: entity_id={}, predicate='{}', object_entity_id={:?}, object_value={:?}, photo='{}'",
            subject_entity_id,
            predicate,
            object_entity_id,
            object_value,
            file_path
        );

        let fact = InsertEntityFact {
            subject_entity_id,
            predicate,
            object_entity_id,
            object_value,
            source_photo: Some(file_path.to_string()),
            source_insight_id: None, // will be backfilled after store_insight
            confidence: 0.6,
            status: "active".to_string(),
            created_at: chrono::Utc::now().timestamp(),
        };

        let mut kdao = self
            .knowledge_dao
            .lock()
            .expect("Unable to lock KnowledgeDao");

        // Upsert the fact (corroboration bumps confidence if duplicate)
        let (stored_fact, is_new) = match kdao.upsert_fact(cx, fact) {
            Ok(r) => r,
            Err(e) => return format!("Error storing fact: {:?}", e),
        };

        // Upsert a photo link so this entity is associated with this photo
        let link = InsertEntityPhotoLink {
            entity_id: subject_entity_id,
            file_path: file_path.to_string(),
            role: photo_role,
        };
        if let Err(e) = kdao.upsert_photo_link(cx, link) {
            log::warn!(
                "Failed to upsert photo link for entity {}: {:?}",
                subject_entity_id,
                e
            );
        }

        let action = if is_new {
            "Stored new fact"
        } else {
            "Corroborated existing fact"
        };
        format!(
            "{}: ID:{} | confidence:{:.2}",
            action, stored_fact.id, stored_fact.confidence
        )
    }

    // ── Agentic insight generation ──────────────────────────────────────

    /// Build the list of tool definitions for the agentic loop
    fn build_tool_definitions(has_vision: bool) -> Vec<Tool> {
        let mut tools = vec![
            Tool::function(
                "search_rag",
                "Search conversation history using semantic search. Use this to find relevant past conversations about specific topics, people, or events.",
                serde_json::json!({
                    "type": "object",
                    "required": ["query", "date"],
                    "properties": {
                        "query": {
                            "type": "string",
                            "description": "The search query to find relevant conversations"
                        },
                        "date": {
                            "type": "string",
                            "description": "The reference date in YYYY-MM-DD format"
                        },
                        "contact": {
                            "type": "string",
                            "description": "Optional contact name to filter results"
                        }
                    }
                }),
            ),
            Tool::function(
                "get_sms_messages",
                "Fetch SMS/text messages near a specific date. Returns the actual message conversation. Omit contact to search across all conversations.",
                serde_json::json!({
                    "type": "object",
                    "required": ["date"],
                    "properties": {
                        "date": {
                            "type": "string",
                            "description": "The center date in YYYY-MM-DD format"
                        },
                        "contact": {
                            "type": "string",
                            "description": "Optional contact name to filter messages. If omitted, searches all conversations."
                        },
                        "days_radius": {
                            "type": "integer",
                            "description": "Number of days before and after the date to search (default: 4)"
                        }
                    }
                }),
            ),
            Tool::function(
                "get_calendar_events",
                "Fetch calendar events near a specific date. Shows scheduled events, meetings, and activities.",
                serde_json::json!({
                    "type": "object",
                    "required": ["date"],
                    "properties": {
                        "date": {
                            "type": "string",
                            "description": "The center date in YYYY-MM-DD format"
                        },
                        "days_radius": {
                            "type": "integer",
                            "description": "Number of days before and after the date to search (default: 7)"
                        }
                    }
                }),
            ),
            Tool::function(
                "get_location_history",
                "Fetch location history records near a specific date. Shows places visited and activities.",
                serde_json::json!({
                    "type": "object",
                    "required": ["date"],
                    "properties": {
                        "date": {
                            "type": "string",
                            "description": "The center date in YYYY-MM-DD format"
                        },
                        "days_radius": {
                            "type": "integer",
                            "description": "Number of days before and after the date to search (default: 14)"
                        }
                    }
                }),
            ),
            Tool::function(
                "get_file_tags",
                "Get tags/labels that have been applied to a specific photo file.",
                serde_json::json!({
                    "type": "object",
                    "required": ["file_path"],
                    "properties": {
                        "file_path": {
                            "type": "string",
                            "description": "The file path of the photo to get tags for"
                        }
                    }
                }),
            ),
        ];

        tools.push(Tool::function(
            "reverse_geocode",
            "Convert GPS latitude/longitude coordinates to a human-readable place name (city, state). Use this when GPS coordinates are available in the photo metadata, or to resolve coordinates returned by get_location_history.",
            serde_json::json!({
                "type": "object",
                "required": ["latitude", "longitude"],
                "properties": {
                    "latitude": {
                        "type": "number",
                        "description": "GPS latitude in decimal degrees"
                    },
                    "longitude": {
                        "type": "number",
                        "description": "GPS longitude in decimal degrees"
                    }
                }
            }),
        ));

        // Knowledge memory tools
        tools.push(Tool::function(
            "recall_entities",
            "Search the knowledge memory for people, places, events, or things previously learned from other photos. Use this to retrieve context about subjects appearing in this photo.",
            serde_json::json!({
                "type": "object",
                "properties": {
                    "name": {
                        "type": "string",
                        "description": "Name or partial name to search for (case-insensitive substring match)"
                    },
                    "entity_type": {
                        "type": "string",
                        "enum": ["person", "place", "event", "thing"],
                        "description": "Filter by entity type (optional)"
                    },
                    "limit": {
                        "type": "integer",
                        "description": "Maximum number of results to return (default: 10)"
                    }
                }
            }),
        ));

        tools.push(Tool::function(
            "recall_facts_for_photo",
            "Retrieve all known facts linked to a specific photo from the knowledge memory. Use this at the start of insight generation to load any previously stored knowledge about subjects in this photo.",
            serde_json::json!({
                "type": "object",
                "required": ["file_path"],
                "properties": {
                    "file_path": {
                        "type": "string",
                        "description": "The file path of the photo to retrieve facts for"
                    }
                }
            }),
        ));

        tools.push(Tool::function(
            "store_entity",
            "Store or update a person, place, event, or thing in the knowledge memory. Call this when you identify a subject in this photo that should be remembered for future insights.",
            serde_json::json!({
                "type": "object",
                "required": ["name", "entity_type"],
                "properties": {
                    "name": {
                        "type": "string",
                        "description": "The canonical name of the entity (e.g. 'John Smith', 'Banff National Park')"
                    },
                    "entity_type": {
                        "type": "string",
                        "enum": ["person", "place", "event", "thing"],
                        "description": "The type of entity"
                    },
                    "description": {
                        "type": "string",
                        "description": "A brief description of the entity"
                    }
                }
            }),
        ));

        tools.push(Tool::function(
            "store_fact",
            "Record a fact about an entity in the knowledge memory. Provide EITHER object_entity_id (when the object is a known entity whose ID you have) OR object_value (for free-text attributes). The fact will be linked to the current photo automatically.",
            serde_json::json!({
                "type": "object",
                "required": ["subject_entity_id", "predicate"],
                "properties": {
                    "subject_entity_id": {
                        "type": "integer",
                        "description": "The ID of the entity this fact is about (returned by store_entity or recall_entities)"
                    },
                    "predicate": {
                        "type": "string",
                        "description": "The relationship or attribute (e.g. 'is_friend_of', 'located_in', 'attended_event', 'is_sibling_of')"
                    },
                    "object_entity_id": {
                        "type": "integer",
                        "description": "Use when the object is a known entity (e.g. Cameron's entity ID for 'is_friend_of Cameron'). Takes precedence over object_value."
                    },
                    "object_value": {
                        "type": "string",
                        "description": "Use for free-text attributes where the object is not a stored entity (e.g. 'Portland, Oregon', 'software engineer')"
                    },
                    "photo_role": {
                        "type": "string",
                        "description": "How this entity appears in the photo (e.g. 'subject', 'background', 'location'). Defaults to 'subject'."
                    }
                }
            }),
        ));

        if has_vision {
            tools.push(Tool::function(
                "describe_photo",
                "Generate a visual description of the photo. Describes people, location, and activity visible in the image.",
                serde_json::json!({
                    "type": "object",
                    "properties": {}
                }),
            ));
        }

        tools
    }

    /// Generate an AI insight for a photo using an agentic tool-calling loop.
    /// The model decides which tools to call to gather context before writing the final insight.
    pub async fn generate_agentic_insight_for_photo(
        &self,
        file_path: &str,
        custom_model: Option<String>,
        custom_system_prompt: Option<String>,
        num_ctx: Option<i32>,
        max_iterations: usize,
    ) -> Result<(Option<i32>, Option<i32>)> {
        let tracer = global_tracer();
        let current_cx = opentelemetry::Context::current();
        let mut span = tracer.start_with_context("ai.insight.generate_agentic", &current_cx);

        let file_path = normalize_path(file_path);
        log::info!("Generating agentic insight for photo: {}", file_path);

        span.set_attribute(KeyValue::new("file_path", file_path.clone()));
        span.set_attribute(KeyValue::new("max_iterations", max_iterations as i64));

        // 1. Create OllamaClient
        let mut ollama_client = if let Some(ref model) = custom_model {
            log::info!("Using custom model for agentic: {}", model);
            span.set_attribute(KeyValue::new("custom_model", model.clone()));
            OllamaClient::new(
                self.ollama.primary_url.clone(),
                self.ollama.fallback_url.clone(),
                model.clone(),
                Some(model.clone()),
            )
        } else {
            span.set_attribute(KeyValue::new("model", self.ollama.primary_model.clone()));
            self.ollama.clone()
        };

        if let Some(ctx) = num_ctx {
            log::info!("Using custom context size: {}", ctx);
            span.set_attribute(KeyValue::new("num_ctx", ctx as i64));
            ollama_client.set_num_ctx(Some(ctx));
        }

        let insight_cx = current_cx.with_span(span);

        // 2a. Verify the model exists on at least one server before checking capabilities
        if let Some(ref model_name) = custom_model {
            let available_on_primary =
                OllamaClient::is_model_available(&ollama_client.primary_url, model_name)
                    .await
                    .unwrap_or(false);

            let available_on_fallback = if let Some(ref fallback_url) = ollama_client.fallback_url {
                OllamaClient::is_model_available(fallback_url, model_name)
                    .await
                    .unwrap_or(false)
            } else {
                false
            };

            if !available_on_primary && !available_on_fallback {
                anyhow::bail!(
                    "model not available: '{}' not found on any configured server",
                    model_name
                );
            }
        }

        // 2b. Check tool calling capability — try primary, fall back to fallback URL
        let model_name_for_caps = &ollama_client.primary_model;
        let capabilities = match OllamaClient::check_model_capabilities(
            &ollama_client.primary_url,
            model_name_for_caps,
        )
        .await
        {
            Ok(caps) => caps,
            Err(_) => {
                // Model may only be on the fallback server
                let fallback_url = ollama_client.fallback_url.as_deref().ok_or_else(|| {
                    anyhow::anyhow!(
                        "Failed to check model capabilities for '{}': model not found on primary server and no fallback configured",
                        model_name_for_caps
                    )
                })?;
                OllamaClient::check_model_capabilities(fallback_url, model_name_for_caps)
                    .await
                    .map_err(|e| {
                        anyhow::anyhow!(
                            "Failed to check model capabilities for '{}': {}",
                            model_name_for_caps,
                            e
                        )
                    })?
            }
        };

        if !capabilities.has_tool_calling {
            return Err(anyhow::anyhow!(
                "tool calling not supported by model '{}'",
                ollama_client.primary_model
            ));
        }

        let has_vision = capabilities.has_vision;
        insight_cx
            .span()
            .set_attribute(KeyValue::new("model_has_vision", has_vision));
        insight_cx
            .span()
            .set_attribute(KeyValue::new("model_has_tool_calling", true));

        // 3. Fetch EXIF
        let exif = {
            let mut exif_dao = self.exif_dao.lock().expect("Unable to lock ExifDao");
            exif_dao
                .get_exif(&insight_cx, &file_path)
                .map_err(|e| anyhow::anyhow!("Failed to get EXIF: {:?}", e))?
        };

        // 4. Extract timestamp and contact
        let timestamp = if let Some(ts) = exif.as_ref().and_then(|e| e.date_taken) {
            ts
        } else {
            log::warn!("No date_taken in EXIF for {}, trying filename", file_path);
            extract_date_from_filename(&file_path)
                .map(|dt| dt.timestamp())
                .or_else(|| {
                    let full_path = std::path::Path::new(&self.base_path).join(&file_path);
                    File::open(&full_path)
                        .and_then(|f| f.metadata())
                        .and_then(|m| m.created().or(m.modified()))
                        .map(|t| DateTime::<Utc>::from(t).timestamp())
                        .inspect_err(|e| {
                            log::warn!(
                                "Failed to get file timestamp for agentic insight {}: {}",
                                file_path,
                                e
                            )
                        })
                        .ok()
                })
                .unwrap_or_else(|| Utc::now().timestamp())
        };

        let date_taken = DateTime::from_timestamp(timestamp, 0)
            .map(|dt| dt.date_naive())
            .unwrap_or_else(|| Utc::now().date_naive());

        let contact = Self::extract_contact_from_path(&file_path);
        log::info!("Agentic: date_taken={}, contact={:?}", date_taken, contact);

        // 5. Fetch tags
        let tag_names: Vec<String> = {
            let mut dao = self.tag_dao.lock().expect("Unable to lock TagDao");
            dao.get_tags_for_path(&insight_cx, &file_path)
                .unwrap_or_else(|e| {
                    log::warn!("Failed to fetch tags for agentic {}: {}", file_path, e);
                    Vec::new()
                })
                .into_iter()
                .map(|t| t.name)
                .collect()
        };

        // 6. Clear existing entity-photo links for this file so the run starts fresh,
        //    and ensure the owner entity (Cameron) exists so the agent can reference it.
        let cameron_entity_id: Option<i32> = {
            let mut kdao = self
                .knowledge_dao
                .lock()
                .expect("Unable to lock KnowledgeDao");

            if let Err(e) = kdao.delete_photo_links_for_file(&insight_cx, &file_path) {
                log::warn!(
                    "Failed to clear entity_photo_links for {}: {:?}",
                    file_path,
                    e
                );
            }

            // Upsert the owner entity so the agent always has a stable entity ID to reference.
            let owner = crate::database::models::InsertEntity {
                name: "Cameron".to_string(),
                entity_type: "person".to_string(),
                description: "The owner of this photo collection. All memories are written from Cameron's perspective.".to_string(),
                embedding: None,
                confidence: 1.0,
                status: "active".to_string(),
                created_at: Utc::now().timestamp(),
                updated_at: Utc::now().timestamp(),
            };
            match kdao.upsert_entity(&insight_cx, owner) {
                Ok(e) => {
                    log::info!("Cameron entity ID: {}", e.id);
                    Some(e.id)
                }
                Err(e) => {
                    log::warn!("Failed to upsert Cameron entity: {:?}", e);
                    None
                }
            }
        };

        // 7. Load image if vision capable
        let image_base64 = if has_vision {
            match self.load_image_as_base64(&file_path) {
                Ok(b64) => {
                    log::info!("Loaded image for vision-capable agentic model");
                    Some(b64)
                }
                Err(e) => {
                    log::warn!("Failed to load image for agentic vision: {}", e);
                    None
                }
            }
        } else {
            None
        };

        // 8. Build system message
        let cameron_id_note = match cameron_entity_id {
            Some(id) => format!(
                "\n\nYour identity in the knowledge store: Cameron (entity ID: {}). \
                When storing facts where you (Cameron) are the object — for example, someone is your friend, \
                sibling, or colleague — use subject_entity_id for the other person and set object_value to \
                \"Cameron\" (or use store_fact with the other person as subject). When storing facts about \
                Cameron directly, use {} as the subject_entity_id.",
                id, id
            ),
            None => String::new(),
        };
        let base_system = format!(
            "You are a personal photo memory assistant helping to reconstruct a memory from a photo. \
            You are writing from the perspective of Cameron, the owner of this photo collection.{cameron_id_note}\n\n\
            IMPORTANT INSTRUCTIONS:\n\
            1. You MUST call multiple tools to gather context BEFORE writing any final insight. Do not produce a final answer after only one or two tool calls.\n\
            2. Always call ALL of the following tools that are relevant: search_rag (search conversation summaries), get_sms_messages (fetch nearby messages), get_calendar_events (check what was happening that day), get_location_history (find where this was taken), get_file_tags (retrieve tags).\n\
            3. Use recall_facts_for_photo to load any previously stored knowledge about subjects in this photo.\n\
            4. Use recall_entities to look up known people, places, or things that appear in this photo.\n\
            5. When you identify people, places, events, or notable things in this photo: use store_entity to record them and store_fact to record key facts (relationships, roles, attributes). This builds a persistent memory for future insights.\n\
            6. Only produce your final insight AFTER you have gathered context from at least 3-4 tools.\n\
            7. If a tool returns no results, that is useful information — continue calling the remaining tools anyway.\n\
            8. Your final insight must be written in first person as Cameron, in a journal/memoir style.",
            cameron_id_note = cameron_id_note
        );
        let system_content = if let Some(ref custom) = custom_system_prompt {
            format!("{}\n\n{}", custom, base_system)
        } else {
            base_system.to_string()
        };

        // 9. Build user message
        let gps_info = exif
            .as_ref()
            .and_then(|e| {
                if let (Some(lat), Some(lon)) = (e.gps_latitude, e.gps_longitude) {
                    Some(format!("GPS: {:.4}, {:.4}", lat, lon))
                } else {
                    None
                }
            })
            .unwrap_or_else(|| "GPS: unknown".to_string());

        let tags_info = if tag_names.is_empty() {
            "Tags: none".to_string()
        } else {
            format!("Tags: {}", tag_names.join(", "))
        };

        let contact_info = contact
            .as_ref()
            .map(|c| format!("Contact/Person: {}", c))
            .unwrap_or_else(|| "Contact/Person: unknown".to_string());

        let user_content = format!(
            "Please analyze this photo and gather context to write a personal journal-style insight.\n\n\
             Photo file path: {}\n\
             Date taken: {}\n\
             {}\n\
             {}\n\
             {}\n\n\
             Use the available tools to gather more context about this moment (messages, calendar events, location history, etc.), \
             then write a detailed personal insight with a title and summary. Write in first person as Cameron.",
            file_path,
            date_taken.format("%B %d, %Y"),
            contact_info,
            gps_info,
            tags_info,
        );

        // 10. Define tools
        let tools = Self::build_tool_definitions(has_vision);

        // 11. Build initial messages
        let system_msg = ChatMessage::system(system_content);
        let mut user_msg = ChatMessage::user(user_content);
        if let Some(ref img) = image_base64 {
            user_msg.images = Some(vec![img.clone()]);
        }

        let mut messages = vec![system_msg, user_msg];

        // 12. Agentic loop
        let loop_span = tracer.start_with_context("ai.agentic.loop", &insight_cx);
        let loop_cx = insight_cx.with_span(loop_span);

        let mut final_content = String::new();
        let mut iterations_used = 0usize;
        let mut last_prompt_eval_count: Option<i32> = None;
        let mut last_eval_count: Option<i32> = None;

        for iteration in 0..max_iterations {
            iterations_used = iteration + 1;
            log::info!("Agentic iteration {}/{}", iteration + 1, max_iterations);

            let (response, prompt_tokens, eval_tokens) = ollama_client
                .chat_with_tools(messages.clone(), tools.clone())
                .await?;

            last_prompt_eval_count = prompt_tokens;
            last_eval_count = eval_tokens;

            // Sanitize tool call arguments before pushing back into history.
            // Some models occasionally return non-object arguments (bool, string, null)
            // which Ollama rejects when they are re-sent in a subsequent request.
            let mut response = response;
            if let Some(ref mut tool_calls) = response.tool_calls {
                for tc in tool_calls.iter_mut() {
                    if !tc.function.arguments.is_object() {
                        log::warn!(
                            "Tool '{}' returned non-object arguments ({:?}), normalising to {{}}",
                            tc.function.name,
                            tc.function.arguments
                        );
                        tc.function.arguments = serde_json::Value::Object(Default::default());
                    }
                }
            }

            messages.push(response.clone());

            if let Some(ref tool_calls) = response.tool_calls
                && !tool_calls.is_empty()
            {
                for tool_call in tool_calls {
                    log::info!(
                        "Agentic tool call [{}]: {} {:?}",
                        iteration,
                        tool_call.function.name,
                        tool_call.function.arguments
                    );
                    let result = self
                        .execute_tool(
                            &tool_call.function.name,
                            &tool_call.function.arguments,
                            &ollama_client,
                            &image_base64,
                            &file_path,
                            &loop_cx,
                        )
                        .await;
                    messages.push(ChatMessage::tool_result(result));
                }
                continue;
            }

            // No tool calls — this is the final answer
            final_content = response.content;
            break;
        }

        // If loop exhausted without final answer, ask for one
        if final_content.is_empty() {
            log::info!(
                "Agentic loop exhausted after {} iterations, requesting final answer",
                iterations_used
            );
            messages.push(ChatMessage::user(
                "Based on the context gathered, please write the final photo insight: a title and a detailed personal summary. Write in first person as Cameron.",
            ));
            let (final_response, prompt_tokens, eval_tokens) =
                ollama_client.chat_with_tools(messages, vec![]).await?;
            last_prompt_eval_count = prompt_tokens;
            last_eval_count = eval_tokens;
            final_content = final_response.content;
        }

        loop_cx
            .span()
            .set_attribute(KeyValue::new("iterations_used", iterations_used as i64));
        loop_cx.span().set_status(Status::Ok);

        // 13. Generate title
        let title = ollama_client
            .generate_photo_title(&final_content, custom_system_prompt.as_deref())
            .await?;

        log::info!("Agentic generated title: {}", title);
        log::info!(
            "Agentic generated summary ({} chars): {}",
            final_content.len(),
            &final_content[..final_content.len().min(200)]
        );

        // 14. Store insight (returns the persisted row including its new id)
        let insight = InsertPhotoInsight {
            file_path: file_path.to_string(),
            title,
            summary: final_content,
            generated_at: Utc::now().timestamp(),
            model_version: ollama_client.primary_model.clone(),
            is_current: true,
        };

        let stored = {
            let mut dao = self.insight_dao.lock().expect("Unable to lock InsightDao");
            dao.store_insight(&insight_cx, insight)
                .map_err(|e| anyhow::anyhow!("Failed to store agentic insight: {:?}", e))
        };

        match &stored {
            Ok(_) => {
                log::info!("Successfully stored agentic insight for {}", file_path);
                insight_cx.span().set_status(Status::Ok);
            }
            Err(e) => {
                log::error!("Failed to store agentic insight: {:?}", e);
                insight_cx.span().set_status(Status::error(e.to_string()));
            }
        }

        let stored_insight = stored?;

        // 15. Backfill source_insight_id on all facts recorded for this photo during the loop
        {
            let mut kdao = self
                .knowledge_dao
                .lock()
                .expect("Unable to lock KnowledgeDao");
            if let Err(e) = kdao.update_facts_insight_id(&insight_cx, &file_path, stored_insight.id)
            {
                log::warn!(
                    "Failed to backfill source_insight_id for {}: {:?}",
                    file_path,
                    e
                );
            }
        }

        Ok((last_prompt_eval_count, last_eval_count))
    }

    /// Reverse geocode GPS coordinates to human-readable place names
    async fn reverse_geocode(&self, lat: f64, lon: f64) -> Option<String> {
        let url = format!(
            "https://nominatim.openstreetmap.org/reverse?format=json&lat={}&lon={}",
            lat, lon
        );

        log::debug!("Reverse geocoding {}, {} via Nominatim", lat, lon);

        let client = reqwest::Client::new();
        let response = match client
            .get(&url)
            .header("User-Agent", "ImageAPI/1.0") // Nominatim requires User-Agent
            .send()
            .await
        {
            Ok(resp) => resp,
            Err(e) => {
                log::warn!("Geocoding network error for {}, {}: {}", lat, lon, e);
                return None;
            }
        };

        if !response.status().is_success() {
            log::warn!(
                "Geocoding HTTP error for {}, {}: {}",
                lat,
                lon,
                response.status()
            );
            return None;
        }

        let data: NominatimResponse = match response.json().await {
            Ok(d) => d,
            Err(e) => {
                log::warn!("Geocoding JSON parse error for {}, {}: {}", lat, lon, e);
                return None;
            }
        };

        // Try to build a concise location name
        if let Some(addr) = data.address {
            let mut parts = Vec::new();

            // Prefer city/town/village
            if let Some(city) = addr.city.or(addr.town).or(addr.village) {
                parts.push(city);
            }

            // Add state if available
            if let Some(state) = addr.state {
                parts.push(state);
            }

            if !parts.is_empty() {
                log::info!("Reverse geocoded {}, {} -> {}", lat, lon, parts.join(", "));
                return Some(parts.join(", "));
            }
        }

        // Fallback to display_name if structured address not available
        if let Some(ref display_name) = data.display_name {
            log::info!(
                "Reverse geocoded {}, {} -> {} (display_name)",
                lat,
                lon,
                display_name
            );
        } else {
            log::warn!("Geocoding returned no address data for {}, {}", lat, lon);
        }
        data.display_name
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn combine_contexts_includes_tags_section_when_tags_present() {
        let result = InsightGenerator::combine_contexts(
            None,
            None,
            None,
            None,
            Some("vacation, hiking, mountains".to_string()),
        );
        assert!(result.contains("## Tags"), "Should include Tags section");
        assert!(
            result.contains("vacation, hiking, mountains"),
            "Should include tag names"
        );
    }

    #[test]
    fn combine_contexts_omits_tags_section_when_no_tags() {
        let result = InsightGenerator::combine_contexts(
            Some("some messages".to_string()),
            None,
            None,
            None,
            None, // no tags
        );
        assert!(
            !result.contains("## Tags"),
            "Should not include Tags section when None"
        );
        assert!(
            result.contains("## Messages"),
            "Should still include Messages"
        );
    }

    #[test]
    fn combine_contexts_returns_no_context_message_when_all_none() {
        let result = InsightGenerator::combine_contexts(None, None, None, None, None);
        assert_eq!(result, "No additional context available");
    }
}