oxirs_core/ai/

temporal_reasoning.rs

//! Temporal Knowledge Graph Reasoning
//!
//! This module provides temporal reasoning capabilities for knowledge graphs,
//! including temporal logic, time-aware inference, and temporal query processing.

use crate::ai::AiConfig;
use anyhow::Result;
use scirs2_core::random::{Random, RngExt};
use serde::{Deserialize, Serialize};
use std::collections::{BTreeMap, HashMap};
use std::time::{SystemTime, UNIX_EPOCH};

/// Temporal reasoning module
pub struct TemporalReasoner {
    /// Configuration
    config: TemporalConfig,

    /// Temporal knowledge base
    temporal_kb: TemporalKnowledgeBase,

    /// Temporal inference engine
    inference_engine: Box<dyn TemporalInferenceEngine>,

    /// Event detection module
    event_detector: Box<dyn EventDetector>,

    /// Temporal constraint solver
    #[allow(dead_code)]
    constraint_solver: Box<dyn TemporalConstraintSolver>,
}

/// Temporal reasoning configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TemporalConfig {
    /// Enable temporal inference
    pub enable_inference: bool,

    /// Enable event detection
    pub enable_event_detection: bool,

    /// Temporal resolution (granularity)
    pub temporal_resolution: TemporalResolution,

    /// Maximum inference depth
    pub max_inference_depth: usize,

    /// Confidence threshold for temporal inferences
    pub inference_confidence_threshold: f32,

    /// Enable temporal constraint solving
    pub enable_constraint_solving: bool,

    /// Supported temporal relations
    pub supported_relations: Vec<TemporalRelation>,
}

impl Default for TemporalConfig {
    fn default() -> Self {
        Self {
            enable_inference: true,
            enable_event_detection: true,
            temporal_resolution: TemporalResolution::Day,
            max_inference_depth: 5,
            inference_confidence_threshold: 0.7,
            enable_constraint_solving: true,
            supported_relations: vec![
                TemporalRelation::Before,
                TemporalRelation::After,
                TemporalRelation::During,
                TemporalRelation::Overlaps,
                TemporalRelation::Meets,
                TemporalRelation::Starts,
                TemporalRelation::Finishes,
                TemporalRelation::Equals,
            ],
        }
    }
}

/// Temporal resolution granularity
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum TemporalResolution {
    Millisecond,
    Second,
    Minute,
    Hour,
    Day,
    Week,
    Month,
    Year,
    Decade,
    Century,
}

/// Temporal relations (Allen's interval algebra)
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum TemporalRelation {
    Before,
    After,
    During,
    Contains,
    Overlaps,
    OverlappedBy,
    Meets,
    MetBy,
    Starts,
    StartedBy,
    Finishes,
    FinishedBy,
    Equals,
}

/// Temporal query
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TemporalQuery {
    /// Query type
    pub query_type: TemporalQueryType,

    /// Target entities
    pub entities: Vec<String>,

    /// Temporal constraints
    pub constraints: Vec<TemporalConstraint>,

    /// Time window
    pub time_window: Option<TimeInterval>,

    /// Include derived facts
    pub include_inferred: bool,
}

/// Temporal query types
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum TemporalQueryType {
    /// Find facts valid at specific time
    ValidAt { time: Timestamp },

    /// Find facts valid during interval
    ValidDuring { interval: TimeInterval },

    /// Find temporal relations between events
    TemporalRelations { entity1: String, entity2: String },

    /// Event sequence queries
    EventSequence { pattern: Vec<EventPattern> },

    /// Temporal aggregation
    Aggregation {
        function: AggregationFunction,
        grouping: TemporalGrouping,
    },

    /// Change detection
    ChangeDetection { entity: String, property: String },
}

/// Temporal query result
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TemporalResult {
    /// Query ID
    pub query_id: String,

    /// Results
    pub results: Vec<TemporalFact>,

    /// Inference trace (if requested)
    pub inference_trace: Option<Vec<InferenceStep>>,

    /// Execution time
    pub execution_time: std::time::Duration,

    /// Result confidence
    pub confidence: f32,
}

/// Temporal fact
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TemporalFact {
    /// Subject
    pub subject: String,

    /// Predicate
    pub predicate: String,

    /// Object
    pub object: String,

    /// Validity interval
    pub validity: TimeInterval,

    /// Confidence score
    pub confidence: f32,

    /// Source information
    pub source: FactSource,

    /// Temporal annotations
    pub annotations: HashMap<String, String>,
}

/// Fact source
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum FactSource {
    /// Asserted fact
    Asserted,

    /// Inferred fact
    Inferred { rule: String, premises: Vec<String> },

    /// Derived from temporal reasoning
    TemporalInference { reasoning_type: String },

    /// Event detection
    EventDetection { detector: String },
}

/// Time interval
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TimeInterval {
    /// Start time
    pub start: Timestamp,

    /// End time
    pub end: Timestamp,

    /// Interval type
    pub interval_type: IntervalType,
}

impl TimeInterval {
    /// Check if this interval contains a timestamp
    pub fn contains(&self, timestamp: Timestamp) -> bool {
        match self.interval_type {
            IntervalType::Closed => timestamp >= self.start && timestamp <= self.end,
            IntervalType::Open => timestamp > self.start && timestamp < self.end,
            IntervalType::LeftOpen => timestamp > self.start && timestamp <= self.end,
            IntervalType::RightOpen => timestamp >= self.start && timestamp < self.end,
        }
    }

    /// Check if this interval overlaps with another
    pub fn overlaps(&self, other: &TimeInterval) -> bool {
        self.start < other.end && other.start < self.end
    }

    /// Get temporal relation with another interval
    pub fn relation_to(&self, other: &TimeInterval) -> TemporalRelation {
        if self.end < other.start {
            TemporalRelation::Before
        } else if self.start > other.end {
            TemporalRelation::After
        } else if self.start == other.start && self.end == other.end {
            TemporalRelation::Equals
        } else if self.start >= other.start && self.end <= other.end {
            TemporalRelation::During
        } else if self.start <= other.start && self.end >= other.end {
            TemporalRelation::Contains
        } else if self.end == other.start {
            TemporalRelation::Meets
        } else if self.start == other.end {
            TemporalRelation::MetBy
        } else if self.start == other.start && self.end < other.end {
            TemporalRelation::Starts
        } else if self.start == other.start && self.end > other.end {
            TemporalRelation::StartedBy
        } else if self.end == other.end && self.start > other.start {
            TemporalRelation::Finishes
        } else if self.end == other.end && self.start < other.start {
            TemporalRelation::FinishedBy
        } else if self.overlaps(other) && self.start < other.start {
            TemporalRelation::Overlaps
        } else {
            TemporalRelation::OverlappedBy
        }
    }
}

/// Interval type
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum IntervalType {
    /// [start, end]
    Closed,

    /// (start, end)
    Open,

    /// (start, end]
    LeftOpen,

    /// [start, end)
    RightOpen,
}

/// Timestamp (Unix timestamp in seconds)
pub type Timestamp = u64;

/// Temporal constraint
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TemporalConstraint {
    /// Constraint type
    pub constraint_type: ConstraintType,

    /// Entity or event involved
    pub entity: String,

    /// Temporal relation
    pub relation: TemporalRelation,

    /// Reference time or interval
    pub reference: TemporalReference,

    /// Constraint strength
    pub strength: ConstraintStrength,
}

/// Constraint types
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ConstraintType {
    /// Hard constraint (must be satisfied)
    Hard,

    /// Soft constraint (preferred)
    Soft { weight: f32 },

    /// Conditional constraint
    Conditional { condition: String },
}

/// Temporal reference
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum TemporalReference {
    /// Absolute timestamp
    Absolute(Timestamp),

    /// Time interval
    Interval(TimeInterval),

    /// Relative to another entity/event
    Relative { entity: String, offset: Option<i64> },

    /// Now (current time)
    Now,
}

/// Constraint strength
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ConstraintStrength {
    Required,
    Strong,
    Medium,
    Weak,
}

/// Event pattern for sequence queries
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EventPattern {
    /// Event type
    pub event_type: String,

    /// Entities involved
    pub entities: Vec<String>,

    /// Temporal constraints
    pub constraints: Vec<TemporalConstraint>,

    /// Optional flag
    pub optional: bool,
}

/// Aggregation functions
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum AggregationFunction {
    Count,
    Sum,
    Average,
    Min,
    Max,
    Duration,
    Frequency,
}

/// Temporal grouping
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum TemporalGrouping {
    ByHour,
    ByDay,
    ByWeek,
    ByMonth,
    ByYear,
    ByInterval { duration: u64 },
}

/// Inference step
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct InferenceStep {
    /// Step number
    pub step: usize,

    /// Rule applied
    pub rule: String,

    /// Input facts
    pub inputs: Vec<TemporalFact>,

    /// Output fact
    pub output: TemporalFact,

    /// Confidence score
    pub confidence: f32,
}

/// Temporal knowledge base
pub struct TemporalKnowledgeBase {
    /// Temporal facts indexed by time
    facts_by_time: BTreeMap<Timestamp, Vec<TemporalFact>>,

    /// Facts indexed by entity
    facts_by_entity: HashMap<String, Vec<TemporalFact>>,

    /// Temporal rules
    #[allow(dead_code)]
    temporal_rules: Vec<TemporalRule>,

    /// Event definitions
    event_definitions: HashMap<String, EventDefinition>,
}

/// Temporal rule
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TemporalRule {
    /// Rule ID
    pub id: String,

    /// Rule name
    pub name: String,

    /// Premises
    pub premises: Vec<TemporalPattern>,

    /// Conclusion
    pub conclusion: TemporalPattern,

    /// Rule confidence
    pub confidence: f32,

    /// Temporal constraints
    pub temporal_constraints: Vec<TemporalConstraint>,
}

/// Temporal pattern in rules
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TemporalPattern {
    /// Pattern variables
    pub variables: HashMap<String, String>,

    /// Temporal conditions
    pub temporal_conditions: Vec<TemporalCondition>,

    /// Pattern confidence
    pub confidence: f32,
}

/// Temporal condition
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TemporalCondition {
    /// Subject variable
    pub subject: String,

    /// Predicate
    pub predicate: String,

    /// Object variable
    pub object: String,

    /// Temporal validity
    pub validity: TemporalValidity,
}

/// Temporal validity specification
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum TemporalValidity {
    /// Always valid
    Always,

    /// Valid during specific interval
    During(TimeInterval),

    /// Valid at specific time
    At(Timestamp),

    /// Valid relative to another fact
    Relative {
        reference: String,
        relation: TemporalRelation,
    },
}

/// Event definition
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EventDefinition {
    /// Event type
    pub event_type: String,

    /// Event patterns to detect
    pub patterns: Vec<EventDetectionPattern>,

    /// Duration constraints
    pub duration_constraints: Option<TimeInterval>,

    /// Participants
    pub participants: Vec<ParticipantRole>,
}

/// Event detection pattern
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EventDetectionPattern {
    /// Pattern conditions
    pub conditions: Vec<TemporalCondition>,

    /// Temporal ordering
    pub ordering: Vec<TemporalOrdering>,

    /// Pattern confidence
    pub confidence: f32,
}

/// Temporal ordering constraint
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TemporalOrdering {
    /// First event
    pub first: String,

    /// Second event
    pub second: String,

    /// Temporal relation
    pub relation: TemporalRelation,

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

/// Participant role in events
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ParticipantRole {
    /// Role name
    pub role: String,

    /// Entity type
    pub entity_type: String,

    /// Required flag
    pub required: bool,
}

/// Temporal inference engine trait
pub trait TemporalInferenceEngine: Send + Sync {
    /// Perform temporal inference
    fn infer(&self, kb: &TemporalKnowledgeBase, query: &TemporalQuery)
        -> Result<Vec<TemporalFact>>;

    /// Apply temporal rules
    fn apply_rules(
        &self,
        facts: &[TemporalFact],
        rules: &[TemporalRule],
    ) -> Result<Vec<TemporalFact>>;
}

/// Event detector trait
pub trait EventDetector: Send + Sync {
    /// Detect events from temporal facts
    fn detect_events(
        &self,
        facts: &[TemporalFact],
        event_definitions: &[EventDefinition],
    ) -> Result<Vec<DetectedEvent>>;

    /// Get event patterns
    fn get_patterns(&self) -> Vec<EventDetectionPattern>;
}

/// Temporal constraint solver trait
pub trait TemporalConstraintSolver: Send + Sync {
    /// Solve temporal constraints
    fn solve_constraints(&self, constraints: &[TemporalConstraint]) -> Result<ConstraintSolution>;

    /// Check constraint satisfaction
    fn check_satisfaction(
        &self,
        constraints: &[TemporalConstraint],
        assignments: &HashMap<String, Timestamp>,
    ) -> Result<bool>;
}

/// Detected event
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DetectedEvent {
    /// Event type
    pub event_type: String,

    /// Event interval
    pub interval: TimeInterval,

    /// Participants
    pub participants: HashMap<String, String>,

    /// Supporting facts
    pub supporting_facts: Vec<TemporalFact>,

    /// Detection confidence
    pub confidence: f32,
}

/// Constraint solution
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ConstraintSolution {
    /// Variable assignments
    pub assignments: HashMap<String, Timestamp>,

    /// Satisfaction score
    pub satisfaction_score: f32,

    /// Unsatisfied constraints
    pub unsatisfied: Vec<String>,
}

impl TemporalReasoner {
    /// Create new temporal reasoner
    pub fn new(_config: &AiConfig) -> Result<Self> {
        let temporal_config = TemporalConfig::default();

        Ok(Self {
            config: temporal_config,
            temporal_kb: TemporalKnowledgeBase::new(),
            inference_engine: Box::new(DefaultTemporalInferenceEngine::new()),
            event_detector: Box::new(DefaultEventDetector::new()),
            constraint_solver: Box::new(DefaultConstraintSolver::new()),
        })
    }

    /// Perform temporal reasoning
    pub async fn reason(&self, query: &TemporalQuery) -> Result<TemporalResult> {
        let start_time = std::time::Instant::now();
        let mut inference_steps = Vec::new();

        // Step 1: Retrieve relevant facts
        let mut facts = self.retrieve_facts(query)?;

        // Step 2: Apply temporal inference if enabled
        if self.config.enable_inference && query.include_inferred {
            let inferred_facts = self.inference_engine.infer(&self.temporal_kb, query)?;

            // Track inference steps for each inferred fact
            for (idx, inferred_fact) in inferred_facts.iter().enumerate() {
                if let FactSource::Inferred { rule, premises } = &inferred_fact.source {
                    let step = InferenceStep {
                        step: idx + 1,
                        rule: rule.clone(),
                        inputs: premises
                            .iter()
                            .filter_map(|premise_id| {
                                facts
                                    .iter()
                                    .find(|f| {
                                        format!("{}:{}:{}", f.subject, f.predicate, f.object)
                                            == *premise_id
                                    })
                                    .cloned()
                            })
                            .collect(),
                        output: inferred_fact.clone(),
                        confidence: inferred_fact.confidence,
                    };
                    inference_steps.push(step);
                }
            }

            facts.extend(inferred_facts);
        }

        // Step 3: Detect events if enabled
        if self.config.enable_event_detection {
            let events = self.event_detector.detect_events(
                &facts,
                &self
                    .temporal_kb
                    .event_definitions
                    .values()
                    .cloned()
                    .collect::<Vec<_>>(),
            )?;

            // Convert events to facts
            for event in events {
                let event_fact = self.event_to_fact(event)?;
                facts.push(event_fact);
            }
        }

        // Step 4: Filter and rank results
        let filtered_facts = self.filter_and_rank_facts(facts, query)?;

        // Compute overall confidence from filtered facts
        let overall_confidence = if filtered_facts.is_empty() {
            0.0
        } else {
            let sum: f32 = filtered_facts.iter().map(|f| f.confidence).sum();
            let count = filtered_facts.len() as f32;
            (sum / count).min(1.0) // Average confidence, capped at 1.0
        };

        let execution_time = start_time.elapsed();

        Ok(TemporalResult {
            query_id: format!("query_{}", {
                let mut rng = Random::default();
                rng.random::<u32>()
            }),
            results: filtered_facts,
            inference_trace: if inference_steps.is_empty() {
                None
            } else {
                Some(inference_steps)
            },
            execution_time,
            confidence: overall_confidence,
        })
    }

    /// Add temporal fact to knowledge base
    pub fn add_fact(&mut self, fact: TemporalFact) -> Result<()> {
        // Add to time index
        self.temporal_kb
            .facts_by_time
            .entry(fact.validity.start)
            .or_default()
            .push(fact.clone());

        // Add to entity index
        self.temporal_kb
            .facts_by_entity
            .entry(fact.subject.clone())
            .or_default()
            .push(fact.clone());

        self.temporal_kb
            .facts_by_entity
            .entry(fact.object.clone())
            .or_default()
            .push(fact);

        Ok(())
    }

    /// Retrieve facts relevant to query
    fn retrieve_facts(&self, query: &TemporalQuery) -> Result<Vec<TemporalFact>> {
        let mut facts = Vec::new();

        // Get facts based on query type
        match &query.query_type {
            TemporalQueryType::ValidAt { time } => {
                for time_facts in self.temporal_kb.facts_by_time.values() {
                    for fact in time_facts {
                        if fact.validity.contains(*time) {
                            facts.push(fact.clone());
                        }
                    }
                }
            }
            TemporalQueryType::ValidDuring { interval } => {
                for time_facts in self.temporal_kb.facts_by_time.values() {
                    for fact in time_facts {
                        if fact.validity.overlaps(interval) {
                            facts.push(fact.clone());
                        }
                    }
                }
            }
            TemporalQueryType::TemporalRelations { entity1, entity2 } => {
                // Retrieve facts that involve either entity (as subject or object).
                // This is the candidate set over which Allen-interval relations
                // between the two entities' facts can be computed downstream.
                for time_facts in self.temporal_kb.facts_by_time.values() {
                    for fact in time_facts {
                        let involves_e1 = &fact.subject == entity1 || &fact.object == entity1;
                        let involves_e2 = &fact.subject == entity2 || &fact.object == entity2;
                        if involves_e1 || involves_e2 {
                            facts.push(fact.clone());
                        }
                    }
                }
            }
            TemporalQueryType::ChangeDetection { entity, property } => {
                // Retrieve facts asserting `property` about `entity`, i.e. the
                // value history whose changes over time we want to detect.
                for time_facts in self.temporal_kb.facts_by_time.values() {
                    for fact in time_facts {
                        if &fact.subject == entity && &fact.predicate == property {
                            facts.push(fact.clone());
                        }
                    }
                }
            }
            TemporalQueryType::EventSequence { pattern } => {
                // Retrieve facts that match at least one event pattern (by event
                // type and/or involved entities). An empty pattern list matches
                // nothing rather than everything.
                for time_facts in self.temporal_kb.facts_by_time.values() {
                    for fact in time_facts {
                        if pattern
                            .iter()
                            .any(|p| Self::fact_matches_event_pattern(fact, p))
                        {
                            facts.push(fact.clone());
                        }
                    }
                }
            }
            TemporalQueryType::Aggregation { function, grouping } => {
                // Aggregation queries require computing grouped aggregate values
                // (e.g. counts per day), which the fact-retrieval/ranking pipeline
                // does not synthesize. Returning the raw underlying facts would
                // misrepresent them as the aggregate result, so fail loudly.
                return Err(anyhow::anyhow!(
                    "Temporal aggregation queries (function {:?}, grouping {:?}) are not \
                     supported by TemporalReasoner::reason; no aggregate result is computed",
                    function,
                    grouping
                ));
            }
        }

        Ok(facts)
    }

    /// Returns true if `fact` matches the given event pattern.
    ///
    /// A fact matches when it is compatible with the pattern's `event_type`
    /// (checked against the fact's object, predicate, or `event:<type>` subject)
    /// and, when the pattern names entities, involves at least one of them.
    fn fact_matches_event_pattern(fact: &TemporalFact, pattern: &EventPattern) -> bool {
        let type_matches = pattern.event_type.is_empty()
            || fact.object == pattern.event_type
            || fact.predicate == pattern.event_type
            || fact.subject == format!("event:{}", pattern.event_type);

        let entity_matches = pattern.entities.is_empty()
            || pattern
                .entities
                .iter()
                .any(|e| e == &fact.subject || e == &fact.object);

        type_matches && entity_matches
    }

    /// Convert detected event to temporal fact
    fn event_to_fact(&self, event: DetectedEvent) -> Result<TemporalFact> {
        Ok(TemporalFact {
            subject: format!("event:{}", event.event_type),
            predicate: "hasEventType".to_string(),
            object: event.event_type,
            validity: event.interval,
            confidence: event.confidence,
            source: FactSource::EventDetection {
                detector: "default".to_string(),
            },
            annotations: HashMap::new(),
        })
    }

    /// Filter and rank facts based on query
    fn filter_and_rank_facts(
        &self,
        mut facts: Vec<TemporalFact>,
        query: &TemporalQuery,
    ) -> Result<Vec<TemporalFact>> {
        // Apply entity filters
        if !query.entities.is_empty() {
            facts.retain(|fact| {
                query.entities.contains(&fact.subject) || query.entities.contains(&fact.object)
            });
        }

        // Apply time window filter
        if let Some(window) = &query.time_window {
            facts.retain(|fact| fact.validity.overlaps(window));
        }

        // Sort by confidence (descending)
        facts.sort_by(|a, b| {
            b.confidence
                .partial_cmp(&a.confidence)
                .unwrap_or(std::cmp::Ordering::Equal)
        });

        Ok(facts)
    }
}

impl TemporalKnowledgeBase {
    fn new() -> Self {
        Self {
            facts_by_time: BTreeMap::new(),
            facts_by_entity: HashMap::new(),
            temporal_rules: Vec::new(),
            event_definitions: HashMap::new(),
        }
    }
}

/// Default temporal inference engine
struct DefaultTemporalInferenceEngine;

impl DefaultTemporalInferenceEngine {
    fn new() -> Self {
        Self
    }
}

impl TemporalInferenceEngine for DefaultTemporalInferenceEngine {
    fn infer(
        &self,
        _kb: &TemporalKnowledgeBase,
        _query: &TemporalQuery,
    ) -> Result<Vec<TemporalFact>> {
        // Placeholder implementation
        Ok(Vec::new())
    }

    fn apply_rules(
        &self,
        _facts: &[TemporalFact],
        _rules: &[TemporalRule],
    ) -> Result<Vec<TemporalFact>> {
        // Placeholder implementation
        Ok(Vec::new())
    }
}

/// Default event detector
struct DefaultEventDetector;

impl DefaultEventDetector {
    fn new() -> Self {
        Self
    }
}

impl EventDetector for DefaultEventDetector {
    fn detect_events(
        &self,
        _facts: &[TemporalFact],
        _event_definitions: &[EventDefinition],
    ) -> Result<Vec<DetectedEvent>> {
        // Placeholder implementation
        Ok(Vec::new())
    }

    fn get_patterns(&self) -> Vec<EventDetectionPattern> {
        Vec::new()
    }
}

/// Default constraint solver
struct DefaultConstraintSolver;

impl DefaultConstraintSolver {
    fn new() -> Self {
        Self
    }
}

impl TemporalConstraintSolver for DefaultConstraintSolver {
    fn solve_constraints(&self, _constraints: &[TemporalConstraint]) -> Result<ConstraintSolution> {
        // Placeholder implementation
        Ok(ConstraintSolution {
            assignments: HashMap::new(),
            satisfaction_score: 1.0,
            unsatisfied: Vec::new(),
        })
    }

    fn check_satisfaction(
        &self,
        _constraints: &[TemporalConstraint],
        _assignments: &HashMap<String, Timestamp>,
    ) -> Result<bool> {
        // Placeholder implementation
        Ok(true)
    }
}

/// Get current timestamp
pub fn current_timestamp() -> Timestamp {
    SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .expect("SystemTime should be after UNIX_EPOCH")
        .as_secs()
}

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

    #[test]
    fn test_temporal_reasoner_creation() {
        let config = AiConfig::default();
        let reasoner = TemporalReasoner::new(&config);
        assert!(reasoner.is_ok());
    }

    #[test]
    fn test_time_interval_operations() {
        let interval1 = TimeInterval {
            start: 100,
            end: 200,
            interval_type: IntervalType::Closed,
        };

        let interval2 = TimeInterval {
            start: 150,
            end: 250,
            interval_type: IntervalType::Closed,
        };

        assert!(interval1.overlaps(&interval2));
        assert_eq!(
            interval1.relation_to(&interval2),
            TemporalRelation::Overlaps
        );
    }

    #[test]
    fn test_temporal_fact_creation() {
        let fact = TemporalFact {
            subject: "http://example.org/person1".to_string(),
            predicate: "worksFor".to_string(),
            object: "http://example.org/company1".to_string(),
            validity: TimeInterval {
                start: 1000,
                end: 2000,
                interval_type: IntervalType::Closed,
            },
            confidence: 0.9,
            source: FactSource::Asserted,
            annotations: HashMap::new(),
        };

        assert_eq!(fact.confidence, 0.9);
        assert!(fact.validity.contains(1500));
        assert!(!fact.validity.contains(2500));
    }

    #[tokio::test]
    async fn test_temporal_query() {
        let config = AiConfig::default();
        let reasoner = TemporalReasoner::new(&config).expect("construction should succeed");

        let query = TemporalQuery {
            query_type: TemporalQueryType::ValidAt {
                time: current_timestamp(),
            },
            entities: vec!["http://example.org/person1".to_string()],
            constraints: Vec::new(),
            time_window: None,
            include_inferred: false,
        };

        let result = reasoner
            .reason(&query)
            .await
            .expect("async operation should succeed");
        assert!(!result.query_id.is_empty());
    }

    fn fact(subject: &str, predicate: &str, object: &str, start: Timestamp) -> TemporalFact {
        TemporalFact {
            subject: subject.to_string(),
            predicate: predicate.to_string(),
            object: object.to_string(),
            validity: TimeInterval {
                start,
                end: start + 1000,
                interval_type: IntervalType::Closed,
            },
            confidence: 0.9,
            source: FactSource::Asserted,
            annotations: HashMap::new(),
        }
    }

    #[tokio::test]
    async fn regression_change_detection_filters_by_entity_and_property() {
        let config = AiConfig::default();
        let mut reasoner = TemporalReasoner::new(&config).expect("construction should succeed");

        reasoner
            .add_fact(fact("ent:a", "prop:title", "Engineer", 1000))
            .expect("add");
        reasoner
            .add_fact(fact("ent:a", "prop:title", "Manager", 2000))
            .expect("add");
        reasoner
            .add_fact(fact("ent:a", "prop:city", "Seattle", 1500))
            .expect("add");
        reasoner
            .add_fact(fact("ent:b", "prop:title", "Director", 1200))
            .expect("add");

        let query = TemporalQuery {
            query_type: TemporalQueryType::ChangeDetection {
                entity: "ent:a".to_string(),
                property: "prop:title".to_string(),
            },
            entities: Vec::new(),
            constraints: Vec::new(),
            time_window: None,
            include_inferred: false,
        };
        let result = reasoner.reason(&query).await.expect("reason");
        // Exactly the two title facts about ent:a, not the city fact nor ent:b.
        assert_eq!(result.results.len(), 2);
        assert!(result
            .results
            .iter()
            .all(|f| f.subject == "ent:a" && f.predicate == "prop:title"));
    }

    #[tokio::test]
    async fn regression_temporal_relations_filters_by_entity_pair() {
        let config = AiConfig::default();
        let mut reasoner = TemporalReasoner::new(&config).expect("construction should succeed");

        reasoner
            .add_fact(fact("ent:a", "p", "ent:x", 1000))
            .expect("add");
        reasoner
            .add_fact(fact("ent:b", "p", "ent:y", 1000))
            .expect("add");
        reasoner
            .add_fact(fact("ent:c", "p", "ent:z", 1000))
            .expect("add");

        let query = TemporalQuery {
            query_type: TemporalQueryType::TemporalRelations {
                entity1: "ent:a".to_string(),
                entity2: "ent:b".to_string(),
            },
            entities: Vec::new(),
            constraints: Vec::new(),
            time_window: None,
            include_inferred: false,
        };
        let result = reasoner.reason(&query).await.expect("reason");
        // Only facts involving ent:a or ent:b, never the ent:c fact.
        assert!(!result.results.is_empty());
        assert!(result
            .results
            .iter()
            .all(|f| f.subject != "ent:c" && f.object != "ent:z"));
    }

    #[tokio::test]
    async fn regression_aggregation_query_fails_loud() {
        let config = AiConfig::default();
        let mut reasoner = TemporalReasoner::new(&config).expect("construction should succeed");
        reasoner
            .add_fact(fact("ent:a", "p", "o", 1000))
            .expect("add");

        let query = TemporalQuery {
            query_type: TemporalQueryType::Aggregation {
                function: AggregationFunction::Count,
                grouping: TemporalGrouping::ByDay,
            },
            entities: Vec::new(),
            constraints: Vec::new(),
            time_window: None,
            include_inferred: false,
        };
        // Must not silently return all facts as a fake aggregate result.
        assert!(reasoner.reason(&query).await.is_err());
    }
}