oxirs-fuseki 0.3.2

//! Type definitions for federated SPARQL query optimization.
//!
//! Contains the data types and trait definitions used across the federated
//! query optimizer's planner, executor, and merger components.

use crate::error::FusekiResult;
use async_trait::async_trait;
use dashmap::DashMap;
use reqwest::Client;
use serde::{Deserialize, Serialize};
use std::{
    collections::{HashMap, HashSet},
    sync::Arc,
    time::{Duration, Instant},
};
use tokio::sync::{RwLock, Semaphore};

/// Type alias for query decomposition function
pub type QueryDecomposeFn = Box<dyn Fn(&str) -> Vec<QueryFragment> + Send + Sync>;

/// Registry for managing remote SPARQL endpoints
pub struct EndpointRegistry {
    /// Registered endpoints with metadata
    pub(crate) endpoints: HashMap<String, EndpointInfo>,
    /// Health status cache
    pub(crate) health_cache: DashMap<String, HealthStatus>,
    /// Discovery service
    pub(crate) discovery: Arc<EndpointDiscovery>,
}

/// Information about a remote SPARQL endpoint
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EndpointInfo {
    pub url: String,
    pub name: String,
    pub description: Option<String>,
    pub capabilities: EndpointCapabilities,
    pub authentication: Option<EndpointAuth>,
    pub timeout_ms: u64,
    pub max_retries: u32,
    pub priority: u32,
}

/// Capabilities of a remote endpoint
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EndpointCapabilities {
    pub sparql_version: String,
    pub supports_update: bool,
    pub supports_graph_store: bool,
    pub supports_service_description: bool,
    pub max_query_size: Option<usize>,
    pub rate_limit: Option<RateLimit>,
    pub features: HashSet<String>,
}

/// Rate limiting configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RateLimit {
    pub requests_per_second: u32,
    pub burst_size: u32,
}

/// Authentication configuration for endpoints
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum EndpointAuth {
    Basic {
        username: String,
        password: String,
    },
    Bearer {
        token: String,
    },
    ApiKey {
        key: String,
        header_name: String,
    },
    OAuth2 {
        client_id: String,
        client_secret: String,
        token_url: String,
    },
}

/// Health status of an endpoint
#[derive(Debug, Clone)]
pub struct HealthStatus {
    pub is_healthy: bool,
    pub last_check: Instant,
    pub response_time_ms: u64,
    pub error_count: u32,
    pub success_count: u32,
}

/// Endpoint discovery service
pub struct EndpointDiscovery {
    /// HTTP client for discovery
    #[allow(dead_code)]
    pub(crate) client: Client,
    /// Known endpoint catalogs
    #[allow(dead_code)]
    pub(crate) catalogs: Vec<String>,
}

/// Query planner for federated execution
pub struct QueryPlanner {
    /// Query decomposition rules
    pub(crate) decomposition_rules: Vec<DecompositionRule>,
    /// Join order optimizer
    pub(crate) join_optimizer: Arc<JoinOrderOptimizer>,
    /// Statistics cache
    #[allow(dead_code)]
    pub(crate) statistics: Arc<RwLock<FederationStatistics>>,
}

/// Rule for decomposing queries
pub struct DecompositionRule {
    pub name: String,
    pub pattern: String,
    pub applicability_check: Box<dyn Fn(&str) -> bool + Send + Sync>,
    pub decompose: QueryDecomposeFn,
}

/// Fragment of a decomposed query
#[derive(Debug, Clone)]
pub struct QueryFragment {
    pub fragment_id: String,
    pub sparql: String,
    pub target_endpoints: Vec<String>,
    pub dependencies: Vec<String>,
    pub estimated_cost: f64,
    pub is_optional: bool,
}

/// Join order optimizer for distributed queries
pub struct JoinOrderOptimizer {
    /// Cost model for joins
    #[allow(dead_code)]
    pub(crate) cost_model: Arc<JoinCostModel>,
    /// Dynamic programming cache
    pub(crate) dp_cache: DashMap<String, JoinPlan>,
}

/// Cost model for distributed joins
pub struct JoinCostModel {
    /// Network latency estimates
    #[allow(dead_code)]
    pub(crate) latency_map: DashMap<(String, String), Duration>,
    /// Bandwidth estimates
    #[allow(dead_code)]
    pub(crate) bandwidth_map: DashMap<String, f64>,
}

/// Optimized join plan
#[derive(Debug, Clone)]
pub struct JoinPlan {
    pub steps: Vec<JoinStep>,
    pub estimated_cost: f64,
    pub estimated_time_ms: u64,
}

/// Single step in a join plan
#[derive(Debug, Clone)]
pub struct JoinStep {
    pub operation: JoinOperation,
    pub left_source: String,
    pub right_source: String,
    pub output_destination: String,
}

/// Join operation type
#[derive(Debug, Clone)]
pub enum JoinOperation {
    HashJoin,
    SortMergeJoin,
    NestedLoopJoin,
    BroadcastJoin,
    IndexJoin,
}

/// Cost estimator for federated queries
pub struct CostEstimator {
    /// Historical query statistics
    pub(crate) history: Arc<RwLock<QueryHistory>>,
    /// Machine learning model for cost prediction
    #[allow(dead_code)]
    pub(crate) ml_model: Option<Arc<CostPredictionModel>>,
    /// Cardinality estimator
    pub(crate) cardinality: Arc<CardinalityEstimator>,
}

/// Historical query execution data
pub struct QueryHistory {
    /// Past query executions
    #[allow(dead_code)]
    pub(crate) executions: Vec<QueryExecution>,
    /// Pattern statistics
    pub(crate) patterns: HashMap<String, PatternStats>,
}

/// Single query execution record
#[derive(Debug, Clone)]
pub struct QueryExecution {
    pub query_hash: String,
    pub fragments: Vec<String>,
    pub endpoints: Vec<String>,
    pub execution_time_ms: u64,
    pub result_count: usize,
    pub timestamp: Instant,
}

/// Statistics for query patterns
#[derive(Debug, Clone)]
pub struct PatternStats {
    pub pattern: String,
    pub avg_execution_time: f64,
    pub avg_result_count: f64,
    pub execution_count: u32,
}

/// Machine learning model for cost prediction
pub struct CostPredictionModel {
    // Placeholder for ML model implementation
    #[allow(dead_code)]
    pub(crate) _model_data: Vec<u8>,
}

/// Cardinality estimator for distributed queries
pub struct CardinalityEstimator {
    /// Endpoint statistics
    #[allow(dead_code)]
    pub(crate) endpoint_stats: DashMap<String, EndpointStatistics>,
    /// Histogram cache
    #[allow(dead_code)]
    pub(crate) histograms: DashMap<String, Histogram>,
}

/// Statistics for an endpoint
#[derive(Debug, Clone)]
pub struct EndpointStatistics {
    pub triple_count: u64,
    pub distinct_subjects: u64,
    pub distinct_predicates: u64,
    pub distinct_objects: u64,
    pub last_updated: Instant,
}

impl Default for EndpointStatistics {
    fn default() -> Self {
        Self {
            triple_count: 0,
            distinct_subjects: 0,
            distinct_predicates: 0,
            distinct_objects: 0,
            last_updated: Instant::now(),
        }
    }
}

/// Histogram for selectivity estimation
#[derive(Debug, Clone)]
pub struct Histogram {
    pub buckets: Vec<HistogramBucket>,
    pub total_count: u64,
}

/// Single histogram bucket
#[derive(Debug, Clone)]
pub struct HistogramBucket {
    pub min_value: String,
    pub max_value: String,
    pub count: u64,
}

/// Federation statistics
pub struct FederationStatistics {
    /// Query execution stats
    #[allow(dead_code)]
    pub(crate) query_stats: HashMap<String, QueryStats>,
    /// Endpoint performance stats
    #[allow(dead_code)]
    pub(crate) endpoint_stats: HashMap<String, EndpointPerformance>,
}

/// Query execution statistics
#[derive(Debug, Clone)]
pub struct QueryStats {
    pub total_executions: u64,
    pub avg_execution_time: f64,
    pub success_rate: f64,
}

/// Endpoint performance metrics
#[derive(Debug, Clone)]
pub struct EndpointPerformance {
    pub avg_response_time: f64,
    pub availability: f64,
    pub throughput: f64,
}

/// Federated query executor
pub struct FederatedExecutor {
    /// HTTP client pool
    pub(crate) client_pool: Arc<ClientPool>,
    /// Execution strategies
    pub(crate) strategies: Vec<Arc<dyn ExecutionStrategy>>,
    /// Parallel execution limiter
    pub(crate) semaphore: Arc<Semaphore>,
    /// Retry policy
    pub(crate) retry_policy: Arc<RetryPolicy>,
}

/// HTTP client pool for endpoint connections
pub struct ClientPool {
    /// Clients per endpoint
    pub(crate) clients: DashMap<String, Client>,
    /// Connection limits
    pub(crate) max_connections_per_endpoint: usize,
}

/// Execution strategy trait
#[async_trait]
pub trait ExecutionStrategy: Send + Sync {
    fn name(&self) -> &str;
    fn applicable(&self, plan: &ExecutionPlan) -> bool;
    async fn execute(
        &self,
        plan: &ExecutionPlan,
        executor: &FederatedExecutor,
    ) -> FusekiResult<QueryResults>;
}

/// Execution plan for federated query
#[derive(Debug, Clone)]
pub struct ExecutionPlan {
    pub query_id: String,
    pub fragments: Vec<QueryFragment>,
    pub join_plan: JoinPlan,
    pub timeout_ms: u64,
    pub optimization_hints: HashMap<String, String>,
    /// Execution steps for performance testing
    pub execution_steps: Vec<String>,
    /// Estimated cost of execution
    pub estimated_cost: f64,
    /// Resource requirements for the execution plan
    pub resource_requirements: ResourceRequirements,
}

/// Resource requirements for execution plan
#[derive(Debug, Clone)]
pub struct ResourceRequirements {
    /// Required service endpoints
    pub required_endpoints: Vec<String>,
    /// Estimated memory requirements in MB
    pub estimated_memory_mb: f64,
    /// Estimated CPU requirements
    pub estimated_cpu_cores: f64,
}

/// Results from federated query execution
#[derive(Debug, Clone)]
pub struct QueryResults {
    pub bindings: Vec<HashMap<String, serde_json::Value>>,
    pub metadata: ResultMetadata,
}

/// Metadata about query results
#[derive(Debug, Clone)]
pub struct ResultMetadata {
    pub total_execution_time_ms: u64,
    pub endpoint_times: HashMap<String, u64>,
    pub result_count: usize,
    pub partial_results: bool,
}

/// Retry policy for failed requests
pub struct RetryPolicy {
    pub max_retries: u32,
    pub initial_backoff_ms: u64,
    pub max_backoff_ms: u64,
    pub exponential_base: f64,
}

/// Service pattern extracted from SPARQL query
#[derive(Debug, Clone)]
pub struct ServicePattern {
    pub service_url: String,
    pub pattern: String,
    pub is_silent: bool,
    pub is_optional: bool,
}

/// Merge strategy trait for combining results
#[async_trait]
pub trait MergeStrategy: Send + Sync {
    fn name(&self) -> &str;
    async fn merge(&self, results: Vec<QueryResults>) -> FusekiResult<QueryResults>;
}

/// Result merger for combining distributed results
pub struct ResultMerger {
    /// Merge strategies
    pub strategies: HashMap<String, Arc<dyn MergeStrategy>>,
    /// Deduplication cache
    #[allow(dead_code)]
    pub(crate) dedup_cache: Arc<RwLock<HashSet<u64>>>,
}