pub struct MemoryEvent {
    pub id: Uuid,
    pub timestamp: DateTime<Utc>,
    pub author: String,
    pub event_type: MemoryEventType,
    pub content: String,
    pub embedding: Vec<f32>,
    pub metadata: serde_json::Value,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum MemoryEventType {
    Observation,    // External perceptions
    Interaction,    // User interactions
    System,         // System events
}

pub struct MemoryQuery {
    pub embedding: Vec<f32>,
    pub top_k: usize,
    pub score_threshold: Option<f32>,
    pub filter: Option<MemoryFilter>,
}

pub struct MemoryFilter {
    pub event_types: Option<Vec<MemoryEventType>>,
    pub authors: Option<Vec<String>>,
    pub after: Option<DateTime<Utc>>,
    pub before: Option<DateTime<Utc>>,
}

#[async_trait]
pub trait MemoryStore: Send + Sync {
    async fn insert_event(&self, event: &MemoryEvent) -> Result<Uuid>;
    async fn query_embeddings(&self, query: &MemoryQuery) -> Result<QueryResult>;
    async fn get_event(&self, id: &Uuid) -> Result<Option<MemoryEvent>>;
    async fn get_events_since(&self, timestamp: i64, limit: usize) -> Result<Vec<MemoryEvent>>;
    async fn migrate(&self) -> Result<()>;
    async fn compact(&self) -> Result<()>;
}

impl HybridMemoryStore {
    /// Create with SQLite file and optional Qdrant URL
    pub async fn new<P: AsRef<Path>>(
        db_path: P, 
        qdrant_url: Option<&str>
    ) -> Result<Self>
    
    /// Create in-memory store (for testing)
    pub async fn in_memory() -> Result<Self>
}

impl SqliteMemoryStore {
    pub fn new<P: AsRef<Path>>(path: P) -> Result<Self>
    pub fn in_memory() -> Result<Self>
}

#[derive(Error, Debug)]
pub enum StorageError {
    #[error("Database error: {0}")]
    Database(#[from] rusqlite::Error),
    
    #[error("Vector store error: {0}")]
    VectorStore(String),
    
    #[error("Serialization error: {0}")]
    Serialization(#[from] serde_json::Error),
    
    #[error("IO error: {0}")]
    Io(#[from] std::io::Error),
    
    #[error("Not found: {0}")]
    NotFound(String),
    
    #[error("Invalid configuration: {0}")]
    InvalidConfig(String),
    
    #[error("Migration error: {0}")]
    Migration(String),
}

use storage::{HybridMemoryStore, MemoryStore, MemoryEvent, MemoryEventType};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize storage
    let store = HybridMemoryStore::new("memories.db", None).await?;
    store.migrate().await?;
    
    // Create a memory
    let event = MemoryEvent::new(
        "device_1".to_string(),
        MemoryEventType::Observation,
        "Saw a beautiful sunset".to_string(),
        vec![0.1, 0.2, 0.3, 0.4], // Embedding from LLM
    );
    
    // Store it
    let id = store.insert_event(&event).await?;
    println!("Stored memory: {}", id);
    
    Ok(())
}

use storage::{MemoryQuery, MemoryFilter, MemoryEventType};

// Search for similar memories
let query = MemoryQuery {
    embedding: vec![0.15, 0.25, 0.35, 0.45],
    top_k: 5,
    score_threshold: Some(0.7),
    filter: Some(MemoryFilter {
        event_types: Some(vec![MemoryEventType::Observation]),
        authors: None,
        after: None,
        before: None,
    }),
};

let results = store.query_embeddings(&query).await?;
for result in results.events {
    println!("Score: {:.3} - {}", result.score, result.event.content);
}

// Get events for sync
let last_sync = chrono::Utc::now().timestamp() - 3600; // 1 hour ago
let events = store.get_events_since(last_sync, 100).await?;

for event in events {
    // Process for synchronization
    sync_to_cloud(&event).await?;
}

use std::sync::Arc;

let store = Arc::new(HybridMemoryStore::new("memories.db", None).await?);

// Share across tasks
let store_clone = store.clone();
tokio::spawn(async move {
    // Use store_clone safely
});

// Migrations run automatically on first use
store.migrate().await?;