backbone-search 3.8.2

//! Search service traits
#![allow(dead_code)]

use async_trait::async_trait;
use crate::{
    SearchResult, SearchDocument, SearchQuery, SearchStats,
    SearchBackend, SearchResults
};
use std::collections::HashMap;

/// Generic search service trait
#[async_trait]
pub trait SearchService: Send + Sync {
    /// Create search index
    async fn create_index(&self, index_name: &str, config: Option<IndexConfig>) -> SearchResult<bool>;

    /// Delete search index
    async fn delete_index(&self, index_name: &str) -> SearchResult<bool>;

    /// List all indices
    async fn list_indices(&self) -> SearchResult<Vec<String>>;

    /// Get index information
    async fn get_index(&self, index_name: &str) -> SearchResult<Option<IndexInfo>>;

    /// Check if index exists
    async fn index_exists(&self, index_name: &str) -> SearchResult<bool>;

    /// Index a single document
    async fn index_document(&self, index_name: &str, document: SearchDocument) -> SearchResult<String>;

    /// Index multiple documents
    async fn index_documents(&self, index_name: &str, documents: Vec<SearchDocument>) -> SearchResult<Vec<IndexResult>>;

    /// Update a document
    async fn update_document(&self, index_name: &str, document_id: &str, updates: HashMap<String, serde_json::Value>) -> SearchResult<bool>;

    /// Delete a document
    async fn delete_document(&self, index_name: &str, document_id: &str) -> SearchResult<bool>;

    /// Get document by ID
    async fn get_document(&self, index_name: &str, document_id: &str) -> SearchResult<Option<SearchDocument>>;

    /// Update document fields
    async fn update_fields(&self, index_name: &str, document_id: &str, fields: HashMap<String, serde_json::Value>) -> SearchResult<bool>;

    /// Search documents
    async fn search(&self, index_name: &str, query: SearchQuery) -> SearchResult<SearchResults>;

    /// Search across multiple indices
    async fn search_multiple(&self, indices: Vec<String>, query: SearchQuery) -> SearchResult<SearchResults>;

    /// Simple text search
    async fn text_search(&self, index_name: &str, text: &str, limit: Option<usize>) -> SearchResult<SearchResults>;

    /// Get search suggestions
    async fn suggestions(&self, index_name: &str, text: &str, limit: usize) -> SearchResult<Vec<String>>;

    /// Get search analytics
    async fn get_analytics(&self, index_name: &str, time_range: TimeRange) -> SearchResult<SearchAnalytics>;

    /// Get search statistics
    async fn get_stats(&self, index_name: &str) -> SearchResult<SearchStats>;

    /// Rebuild index
    async fn rebuild_index(&self, index_name: &str, config: Option<IndexConfig>) -> SearchResult<bool>;

    /// Validate search configuration
    async fn validate_config(&self) -> SearchResult<bool>;

    /// Test search connection
    async fn test_connection(&self) -> SearchResult<bool>;

    /// Get backend type
    fn backend_type(&self) -> SearchBackend;

    /// Optimize index for search performance
    async fn optimize_index(&self, index_name: &str) -> SearchResult<bool>;

    /// Get mapping for index
    async fn get_mapping(&self, index_name: &str) -> SearchResult<IndexMapping>;

    /// Update index mapping
    async fn update_mapping(&self, index_name: &str, mapping: IndexMapping) -> SearchResult<bool>;

    /// Bulk operation (index, update, delete)
    async fn bulk_operation(&self, index_name: &str, operations: Vec<BulkOperation>) -> SearchResult<BulkResult>;
}

/// Search index configuration
#[derive(Debug, Clone)]
pub struct IndexConfig {
    /// Number of primary shards
    pub primary_shards: u32,

    /// Number of replica shards
    pub replica_shards: u32,

    /// Index settings
    pub settings: HashMap<String, serde_json::Value>,

    /// Field mappings
    pub mappings: IndexMapping,

    /// Custom analyzers
    pub analyzers: HashMap<String, Analyzer>,

    /// Index aliases
    pub aliases: Vec<String>,

    /// Index template
    pub template: Option<String>,
}

impl Default for IndexConfig {
    fn default() -> Self {
        Self {
            primary_shards: 1,
            replica_shards: 1,
            settings: HashMap::new(),
            mappings: IndexMapping::default(),
            analyzers: HashMap::new(),
            aliases: Vec::new(),
            template: None,
        }
    }
}

/// Index information
#[derive(Debug, Clone)]
pub struct IndexInfo {
    /// Index name
    pub name: String,

    /// Index status
    pub status: IndexStatus,

    /// Document count
    pub document_count: u64,

    /// Index size in bytes
    pub size_bytes: u64,

    /// Primary shards
    pub primary_shards: u32,

    /// Replica shards
    pub replica_shards: u32,

    /// Creation timestamp
    pub created_at: chrono::DateTime<chrono::Utc>,

    /// Last updated timestamp
    pub updated_at: Option<chrono::DateTime<chrono::Utc>>,

    /// Health status
    pub health: IndexHealth,

    /// Backend-specific info
    pub backend_info: HashMap<String, serde_json::Value>,
}

/// Index status
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum IndexStatus {
    Creating,
    Active,
    Deleting,
    Closed,
    Error,
}

/// Index health
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum IndexHealth {
    Green,
    Yellow,
    Red,
}

/// Index mapping
#[derive(Debug, Clone, Default)]
pub struct IndexMapping {
    /// Field mappings
    pub properties: HashMap<String, FieldMapping>,

    /// Dynamic mapping rules
    pub dynamic: Option<DynamicMapping>,

    /// Date formats
    pub date_formats: Vec<String>,

    /// Custom field types
    pub custom_types: HashMap<String, serde_json::Value>,
}

/// Field mapping
#[derive(Debug, Clone)]
pub struct FieldMapping {
    /// Field type
    pub field_type: FieldType,

    /// Whether field is indexed
    pub indexed: bool,

    /// Whether field is stored
    pub stored: bool,

    /// Whether field is analyzed
    pub analyzed: bool,

    /// Field analyzer
    pub analyzer: Option<String>,

    /// Field format
    pub format: Option<String>,

    /// Field boost
    pub boost: Option<f32>,

    /// Field properties
    pub properties: HashMap<String, serde_json::Value>,
}

/// Field type
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum FieldType {
    Text,
    Keyword,
    Integer,
    Long,
    Float,
    Double,
    Boolean,
    Date,
    Object,
    Array,
    Binary,
    GeoPoint,
    GeoShape,
    Ip,
    Completion,
    Nested,
}

/// Dynamic mapping
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum DynamicMapping {
    True,
    False,
    Strict,
}

/// Text analyzer
#[derive(Debug, Clone)]
pub struct Analyzer {
    /// Tokenizer
    pub tokenizer: String,

    /// Character filters
    pub char_filters: Vec<String>,

    /// Token filters
    pub token_filters: Vec<String>,

    /// Analyzer type
    pub analyzer_type: Option<String>,
}

/// Index operation result
#[derive(Debug, Clone)]
pub struct IndexResult {
    /// Document ID
    pub id: String,

    /// Index name
    pub index: String,

    /// Operation status
    pub success: bool,

    /// Error message (if failed)
    pub error: Option<String>,

    /// Version number
    pub version: Option<u64>,

    /// Operation metadata
    pub metadata: HashMap<String, serde_json::Value>,
}

/// Bulk operation
#[derive(Debug, Clone)]
pub struct BulkOperation {
    /// Operation type
    pub operation_type: BulkOperationType,

    /// Document ID
    pub id: String,

    /// Document data (for index/update operations)
    pub document: Option<SearchDocument>,

    /// Updates (for update operations)
    pub updates: Option<HashMap<String, serde_json::Value>>,

    /// Routing value
    pub routing: Option<String>,

    /// Timestamp
    pub timestamp: Option<chrono::DateTime<chrono::Utc>>,
}

/// Bulk operation type
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum BulkOperationType {
    Index,
    Create,
    Update,
    Delete,
}

/// Bulk operation result
#[derive(Debug, Clone)]
pub struct BulkResult {
    /// Total operations
    pub total: u64,

    /// Successful operations
    pub successful: u64,

    /// Failed operations
    pub failed: u64,

    /// Operation results
    pub results: Vec<BulkOperationResult>,

    /// Errors
    pub errors: Vec<BulkError>,

    /// Processing time in milliseconds
    pub processing_time_ms: u64,
}

/// Bulk operation result
#[derive(Debug, Clone)]
pub struct BulkOperationResult {
    /// Operation index
    pub index: u64,

    /// Operation type
    pub operation_type: BulkOperationType,

    /// Document ID
    pub id: String,

    /// Success status
    pub success: bool,

    /// Error details (if failed)
    pub error: Option<BulkError>,

    /// Version number
    pub version: Option<u64>,

    /// Result metadata
    pub metadata: HashMap<String, serde_json::Value>,
}

/// Bulk error
#[derive(Debug, Clone)]
pub struct BulkError {
    /// Error type
    pub error_type: String,

    /// Error reason
    pub reason: String,

    /// Error details
    pub details: HashMap<String, serde_json::Value>,
}

/// Time range for analytics
#[derive(Debug, Clone)]
pub struct TimeRange {
    /// Start time
    pub start: chrono::DateTime<chrono::Utc>,

    /// End time
    pub end: chrono::DateTime<chrono::Utc>,

    /// Time interval
    pub interval: Option<TimeInterval>,
}

/// Time interval
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TimeInterval {
    Minute,
    Hour,
    Day,
    Week,
    Month,
    Year,
}

/// Search analytics
#[derive(Debug, Clone)]
pub struct SearchAnalytics {
    /// Total number of searches
    pub total_searches: u64,

    /// Average query time in milliseconds
    pub avg_query_time_ms: f64,

    /// Popular search terms
    pub popular_terms: Vec<SearchTerm>,

    /// No-result searches
    pub no_result_terms: Vec<SearchTerm>,

    /// Search frequency by time
    pub search_frequency: HashMap<String, u64>,

    /// Performance metrics
    pub performance_metrics: PerformanceMetrics,

    /// User behavior analytics
    pub user_behavior: UserBehavior,
}

/// Search term
#[derive(Debug, Clone)]
pub struct SearchTerm {
    /// Term text
    pub term: String,

    /// Search count
    pub count: u64,

    /// Average result count
    pub avg_results: f64,

    /// Click-through rate
    pub ctr: f64,
}

/// Performance metrics
#[derive(Debug, Clone)]
pub struct PerformanceMetrics {
    /// Query time statistics
    pub query_time_stats: QueryTimeStats,

    /// Index size over time
    pub index_size_trend: Vec<SizePoint>,

    /// Document count over time
    pub document_count_trend: Vec<CountPoint>,

    /// Cache hit rate
    pub cache_hit_rate: f64,
}

/// Query time statistics
#[derive(Debug, Clone)]
pub struct QueryTimeStats {
    /// Minimum query time
    pub min_ms: u64,

    /// Maximum query time
    pub max_ms: u64,

    /// Average query time
    pub avg_ms: f64,

    /// 95th percentile query time
    pub p95_ms: u64,

    /// 99th percentile query time
    pub p99_ms: u64,
}

/// Size point over time
#[derive(Debug, Clone)]
pub struct SizePoint {
    /// Timestamp
    pub timestamp: chrono::DateTime<chrono::Utc>,

    /// Size in bytes
    pub size_bytes: u64,
}

/// Count point over time
#[derive(Debug, Clone)]
pub struct CountPoint {
    /// Timestamp
    pub timestamp: chrono::DateTime<chrono::Utc>,

    /// Count
    pub count: u64,
}

/// User behavior analytics
#[derive(Debug, Clone)]
pub struct UserBehavior {
    /// Average session duration
    pub avg_session_duration: f64,

    /// Average searches per session
    pub avg_searches_per_session: f64,

    /// Search result click-through rate
    pub search_ctr: f64,

    /// Filter usage statistics
    pub filter_usage: HashMap<String, u64>,

    /// Facet usage statistics
    pub facet_usage: HashMap<String, u64>,
}