use sage::prelude::*;
use tempfile::TempDir;

fn main() -> Result<()> {
    // Create a temporary directory for the index
    let temp_dir = TempDir::new().unwrap();
    
    // Define a schema
    let mut schema = Schema::new();
    schema.add_field("title", Box::new(TextField::new().stored(true).indexed(true)))?;
    schema.add_field("content", Box::new(TextField::new().indexed(true)))?;
    
    // Create a search engine
    let mut engine = SearchEngine::create_in_dir(
        temp_dir.path(), 
        schema, 
        IndexConfig::default()
    )?;
    
    // Add documents
    let documents = vec![
        Document::builder()
            .add_text("title", "Rust Programming")
            .add_text("content", "Rust is a systems programming language")
            .build(),
        Document::builder()
            .add_text("title", "Python Guide") 
            .add_text("content", "Python is a versatile programming language")
            .build(),
    ];
    
    engine.add_documents(documents)?;
    engine.commit()?;
    
    // Search documents
    let query = TermQuery::new("content".to_string(), "programming".to_string());
    let results = engine.search(&query, 10)?;
    
    println!("Found {} matches", results.total_hits);
    for hit in results.hits {
        println!("Score: {:.2}, Document: {:?}", hit.score, hit.document);
    }
    
    Ok(())
}

// Text field for full-text search
TextField::new().stored(true).indexed(true)

// Numeric field for range queries
NumericField::new().indexed(true)

// Boolean field for filtering
BooleanField::new().indexed(true)

// ID field for exact matches
IdField::new()

// Geographic field for spatial queries  
GeoField::new().indexed(true)

// Vector field for similarity search
VectorField::new(128).indexed(true) // 128-dimensional vectors

// Term query
TermQuery::new("field".to_string(), "term".to_string())

// Phrase query
PhraseQuery::new("field".to_string(), vec!["hello".to_string(), "world".to_string()])

// Range query
RangeQuery::new("price".to_string(), Some(100.0), Some(500.0))

// Boolean query
BooleanQuery::new()
    .add_must(TermQuery::new("category".to_string(), "book".to_string()))
    .add_should(TermQuery::new("author".to_string(), "tolkien".to_string()))

// Fuzzy query
FuzzyQuery::new("title".to_string(), "progamming".to_string(), 2) // max edit distance: 2

// Wildcard query  
WildcardQuery::new("filename".to_string(), "*.pdf".to_string())

// Geographic query
GeoQuery::within_radius("location".to_string(), 40.7128, -74.0060, 10.0) // NYC, 10km radius

use sage::embedding::{CandleTextEmbedder, TextEmbedder};
use sage::vector::*;

// Initialize embedder with a sentence-transformers model
let embedder = CandleTextEmbedder::new("sentence-transformers/all-MiniLM-L6-v2")?;

// Generate embeddings for documents
let documents = vec![
    "Rust is a systems programming language",
    "Python is great for data science",
    "Machine learning with neural networks",
];

let vectors = embedder.embed_batch(&documents).await?;

// Build vector index
let config = VectorIndexBuildConfig {
    dimension: embedder.dimension(),
    distance_metric: DistanceMetric::Cosine,
    index_type: VectorIndexType::Flat,
    normalize_vectors: true,
    ..Default::default()
};

let mut builder = VectorIndexBuilderFactory::create_builder(config)?;
let doc_vectors: Vec<(u64, Vector)> = documents
    .iter()
    .enumerate()
    .zip(vectors.iter())
    .map(|((idx, _), vec)| (idx as u64, vec.clone()))
    .collect();

builder.add_vectors(doc_vectors)?;
builder.finalize()?;

// Search with query embedding
let query_vector = embedder.embed("programming languages").await?;
// Perform similarity search...

use sage::embedding::{OpenAIEmbedder, TextEmbedder};

// Initialize with API key
let embedder = OpenAIEmbedder::new(
    "your-api-key",
    "text-embedding-3-small"
)?;

// Generate embeddings
let vector = embedder.embed("your text here").await?;

use sage::embedding::{CandleMultimodalEmbedder, TextEmbedder, ImageEmbedder};
use sage::vector::index::{VectorIndexBuildConfig, VectorIndexBuilderFactory};

// Initialize CLIP embedder (automatically downloads model from HuggingFace)
let embedder = CandleMultimodalEmbedder::new("openai/clip-vit-base-patch32")?;

// Create vector index with CLIP's embedding dimension (512)
let config = VectorIndexBuildConfig {
    dimension: embedder.dimension(), // 512 for CLIP ViT-Base-Patch32
7440

    distance_metric: DistanceMetric::Cosine,
    index_type: VectorIndexType::HNSW,
    ..Default::default()
};
let mut builder = VectorIndexBuilderFactory::create_builder(config)?;

// Index your image collection
let mut image_vectors = Vec::new();
for (id, image_path) in image_paths.iter().enumerate() {
    let vector = embedder.embed_image(image_path).await?;
    image_vectors.push((id as u64, vector));
}
builder.add_vectors(image_vectors)?;
let index = builder.finalize()?;

// Search images using natural language
let query_vector = embedder.embed("a photo of a cat playing").await?;
let results = index.search(&query_vector, 10)?;

// Find visually similar images using an image as query
let query_image_vector = embedder.embed_image("query.jpg").await?;
let similar_images = index.search(&query_image_vector, 5)?;

use sage::search::facet::*;

// Configure faceted search
let mut search_request = SearchRequest::new(query)
    .add_facet("category".to_string(), FacetRequest::terms(10))
    .add_facet("price".to_string(), FacetRequest::range(vec![
        (0.0, 50.0),
        (50.0, 100.0), 
        (100.0, f64::INFINITY)
    ]));

let results = engine.search_with_facets(&search_request)?;

// Access facet results
for facet in results.facets {
    println!("Facet: {}", facet.field);
    for bucket in facet.buckets {
        println!("  {}: {} documents", bucket.label, bucket.count);
    }
}

use sage::spelling::*;

// Create spell corrector
let corrector = SpellCorrector::new()
    .max_edit_distance(2)
    .min_word_frequency(5);

// Check and suggest corrections
if let Some(suggestion) = corrector.suggest("progamming")? {
    println!("Did you mean: '{}'?", suggestion.suggestion);
}

use sage::analysis::*;

// Create custom analyzer
let analyzer = Analyzer::new()
    .tokenizer(Box::new(RegexTokenizer::new(r"\w+")?))
    .add_filter(Box::new(LowercaseFilter::new()))
    .add_filter(Box::new(StopWordFilter::english()))
    .add_filter(Box::new(PorterStemmer::new()));

// Use in field definition
let field = TextField::new()
    .analyzer(analyzer)
    .stored(true)
    .indexed(true);