graph_d 1.3.2

//! Abstract Syntax Tree (AST) structures for GQL.

use serde_json::Value;
use std::collections::HashMap;

/// Root GQL statement.
#[derive(Debug, Clone)]
pub enum GqlStatement {
    /// A linear query that operates on the default graph
    LinearQuery(LinearQuery),
    /// A query that operates on a named graph
    GraphQuery {
        /// Name of the graph to query
        graph_name: String,
        /// The query to execute on the graph
        query: LinearQuery,
    },
}

/// A linear query statement that can be chained with NEXT.
#[derive(Debug, Clone)]
pub struct LinearQuery {
    /// The sequence of clauses that make up this query
    pub clauses: Vec<QueryClause>,
}

/// Individual clauses in a linear query.
#[derive(Debug, Clone)]
pub enum QueryClause {
    /// MATCH clause for pattern matching
    Match(MatchClause),
    /// FILTER clause for filtering results  
    Filter(FilterClause),
    /// RETURN clause for specifying output
    Return(ReturnClause),
    /// WITH clause for passing data between query parts
    With(WithClause),
    /// ORDER BY clause for sorting results
    OrderBy(OrderByClause),
    /// LIMIT clause for limiting result count
    Limit(LimitClause),
    /// OFFSET clause for skipping results
    Offset(OffsetClause),
    /// INSERT clause for creating new graph elements
    Insert(InsertClause),
    /// UPDATE clause for modifying existing elements
    Update(UpdateClause),
    /// DELETE clause for removing graph elements
    Delete(DeleteClause),
    /// SET clause for setting property values
    Set(SetClause),
    /// REMOVE clause for removing properties or labels
    Remove(RemoveClause),
}

/// MATCH clause for pattern matching.
#[derive(Debug, Clone)]
pub struct MatchClause {
    /// Whether this is an OPTIONAL MATCH
    pub optional: bool,
    /// The graph patterns to match
    pub patterns: Vec<GraphPattern>,
}

/// Graph pattern in MATCH clauses.
#[derive(Debug, Clone)]
pub enum GraphPattern {
    /// A node pattern (n:Label {prop: value})
    Node(NodePattern),
    /// A path pattern (sequence of nodes and relationships)
    Path(PathPattern),
    /// A relationship pattern -\[:TYPE\]->
    Relationship(RelationshipPattern),
}

/// Node pattern: (variable:Label1|Label2 {prop: value})
#[derive(Debug, Clone)]
pub struct NodePattern {
    /// Optional variable name for binding
    pub variable: Option<String>,
    /// Node labels to match
    pub labels: Vec<String>,
    /// Property patterns to match
    pub properties: Option<PropertyPattern>,
    /// Optional WHERE clause for additional filtering
    pub where_clause: Option<Box<Expression>>,
}

/// Relationship pattern: [variable:TYPE {prop: value}]
#[derive(Debug, Clone)]
pub struct RelationshipPattern {
    /// Optional variable name for binding
    pub variable: Option<String>,
    /// Relationship type to match
    pub rel_type: Option<String>,
    /// Property patterns to match
    pub properties: Option<PropertyPattern>,
    /// Direction of the relationship
    pub direction: RelationshipDirection,
    /// Optional path length specification
    pub length: Option<PathLength>,
}

/// Path pattern: (start)-\[rel\]->(end)
#[derive(Debug, Clone)]
pub struct PathPattern {
    /// Starting node pattern
    pub start: Box<NodePattern>,
    /// Sequence of relationship and node patterns
    pub relationships: Vec<(RelationshipPattern, Box<NodePattern>)>,
}

/// Property pattern: {key: value, key2: $param}
#[derive(Debug, Clone)]
pub struct PropertyPattern {
    /// Property key-value pairs to match
    pub properties: HashMap<String, Expression>,
}

/// Relationship direction.
#[derive(Debug, Clone, PartialEq, Copy)]
pub enum RelationshipDirection {
    /// Outgoing relationship (->)
    Outgoing,
    /// Incoming relationship (<-)
    Incoming,
    /// Undirected relationship (--)
    Undirected,
}

/// Path length specification.
#[derive(Debug, Clone)]
pub enum PathLength {
    /// Exact path length (e.g., *5)
    Exact(usize),
    /// Range of path lengths (e.g., *2..5, *..3, *2..)
    Range(Option<usize>, Option<usize>),
    /// Variable length path (*)
    Variable,
}

/// WHERE/FILTER clause.
#[derive(Debug, Clone)]
pub struct FilterClause {
    /// The boolean condition to evaluate
    pub condition: Expression,
}

/// RETURN clause.
#[derive(Debug, Clone)]
pub struct ReturnClause {
    /// Whether to return distinct results only
    pub distinct: bool,
    /// Items to return
    pub items: Vec<ReturnItem>,
}

/// Item in RETURN clause.
#[derive(Debug, Clone)]
pub struct ReturnItem {
    /// Expression to evaluate and return
    pub expression: Expression,
    /// Optional alias for the returned value
    pub alias: Option<String>,
}

/// WITH clause for piping data.
#[derive(Debug, Clone)]
pub struct WithClause {
    /// Items to pass to the next query part
    pub items: Vec<ReturnItem>,
}

/// ORDER BY clause.
#[derive(Debug, Clone)]
pub struct OrderByClause {
    /// Items to sort by
    pub items: Vec<OrderByItem>,
}

/// Item in ORDER BY clause.
#[derive(Debug, Clone)]
pub struct OrderByItem {
    /// Expression to sort by
    pub expression: Expression,
    /// Sort direction (ascending or descending)
    pub direction: SortDirection,
}

/// Sort direction.
#[derive(Debug, Clone)]
pub enum SortDirection {
    /// Ascending sort order
    Asc,
    /// Descending sort order
    Desc,
}

/// LIMIT clause.
#[derive(Debug, Clone)]
pub struct LimitClause {
    /// Maximum number of results to return
    pub count: Expression,
}

/// OFFSET clause.
#[derive(Debug, Clone)]
pub struct OffsetClause {
    /// Number of results to skip
    pub count: Expression,
}

/// INSERT clause.
#[derive(Debug, Clone)]
pub struct InsertClause {
    /// Graph patterns to insert
    pub patterns: Vec<GraphPattern>,
}

/// UPDATE clause.
#[derive(Debug, Clone)]
pub struct UpdateClause {
    /// Pattern to match for updating
    pub pattern: GraphPattern,
    /// Items to set during update
    pub set_items: Vec<SetItem>,
}

/// DELETE clause.
#[derive(Debug, Clone)]
pub struct DeleteClause {
    /// Whether to detach relationships before deleting
    pub detach: bool,
    /// Expressions identifying what to delete
    pub expressions: Vec<Expression>,
}

/// SET clause.
#[derive(Debug, Clone)]
pub struct SetClause {
    /// Items to set
    pub items: Vec<SetItem>,
}

/// Item in SET clause.
#[derive(Debug, Clone)]
pub struct SetItem {
    /// Target to set (property or variable)
    pub target: Expression,
    /// Value to assign
    pub value: Expression,
}

/// REMOVE clause.
#[derive(Debug, Clone)]
pub struct RemoveClause {
    /// Items to remove
    pub items: Vec<RemoveItem>,
}

/// Item in REMOVE clause.
#[derive(Debug, Clone)]
pub enum RemoveItem {
    /// Remove a property from a node or relationship
    Property(Expression),
    /// Remove a label from a node
    Label(Expression, String),
}

/// Expressions in GQL.
#[derive(Debug, Clone)]
pub enum Expression {
    /// Literal value (string, number, boolean, null)
    Literal(Value),
    /// Parameter reference ($param)
    Parameter(String),

    /// Variable reference
    Variable(String),
    /// Property access (object.property)
    Property {
        /// Object being accessed
        object: Box<Expression>,
        /// Property name
        property: String,
    },

    /// Binary operation (left op right)
    Binary {
        /// Left operand
        left: Box<Expression>,
        /// Binary operator
        operator: BinaryOperator,
        /// Right operand
        right: Box<Expression>,
    },

    /// Unary operation (op operand)
    Unary {
        /// Unary operator
        operator: UnaryOperator,
        /// Operand
        operand: Box<Expression>,
    },

    /// Function call
    FunctionCall {
        /// Function name
        name: String,
        /// Function arguments
        args: Vec<Expression>,
    },

    /// List literal \[expr1, expr2, ...\]
    List(Vec<Expression>),
    /// List element access list\[index\]
    ListAccess {
        /// List expression
        list: Box<Expression>,
        /// Index expression
        index: Box<Expression>,
    },
    /// List slice list\[start..end\]
    ListSlice {
        /// List expression
        list: Box<Expression>,
        /// Start index (optional)
        start: Option<Box<Expression>>,
        /// End index (optional)
        end: Option<Box<Expression>>,
    },

    /// Path expression for graph patterns
    PathExpression(Box<PathPattern>),

    /// CASE expression for conditional logic
    Case {
        /// WHEN clauses (condition, result)
        when_clauses: Vec<(Expression, Expression)>,
        /// ELSE clause
        else_clause: Option<Box<Expression>>,
    },

    /// Aggregate function call
    Aggregate {
        /// Aggregate function type
        function: AggregateFunction,
        /// Expression to aggregate (None for COUNT(*))
        expression: Option<Box<Expression>>,
        /// Whether to use DISTINCT
        distinct: bool,
    },
}

/// Binary operators.
#[derive(Debug, Clone)]
pub enum BinaryOperator {
    /// Addition (+)
    Add,
    /// Subtraction (-)
    Subtract,
    /// Multiplication (*)
    Multiply,
    /// Division (/)
    Divide,
    /// Modulo (%)
    Modulo,

    /// Equality (=, ==)
    Equal,
    /// Inequality (<>, !=)
    NotEqual,
    /// Less than (<)
    LessThan,
    /// Less than or equal (<=)
    LessEqual,
    /// Greater than (>)
    GreaterThan,
    /// Greater than or equal (>=)
    GreaterEqual,

    /// Logical AND
    And,
    /// Logical OR
    Or,

    /// String contains operation
    Contains,
    /// String starts with operation
    StartsWith,
    /// String ends with operation
    EndsWith,

    /// Collection membership (IN)
    In,
}

/// Unary operators.
#[derive(Debug, Clone)]
pub enum UnaryOperator {
    /// Logical NOT
    Not,
    /// Arithmetic negation (-)
    Minus,
    /// Arithmetic positive (+)
    Plus,
}

/// Aggregate functions.
#[derive(Debug, Clone)]
pub enum AggregateFunction {
    /// Count of elements
    Count,
    /// Sum of numeric values
    Sum,
    /// Average of numeric values
    Avg,
    /// Minimum value
    Min,
    /// Maximum value
    Max,
    /// Collect values into a list
    Collect,
}

impl LinearQuery {
    /// Create a new empty linear query.
    pub fn new() -> Self {
        Self {
            clauses: Vec::new(),
        }
    }

    /// Add a clause to the query.
    pub fn add_clause(&mut self, clause: QueryClause) {
        self.clauses.push(clause);
    }

    /// Get all MATCH clauses.
    pub fn match_clauses(&self) -> Vec<&MatchClause> {
        self.clauses
            .iter()
            .filter_map(|c| {
                if let QueryClause::Match(m) = c {
                    Some(m)
                } else {
                    None
                }
            })
            .collect()
    }

    /// Get the RETURN clause if present.
    pub fn return_clause(&self) -> Option<&ReturnClause> {
        self.clauses.iter().find_map(|c| {
            if let QueryClause::Return(r) = c {
                Some(r)
            } else {
                None
            }
        })
    }

    /// Get all WHERE/FILTER clauses.
    pub fn filter_clauses(&self) -> Vec<&FilterClause> {
        self.clauses
            .iter()
            .filter_map(|c| {
                if let QueryClause::Filter(f) = c {
                    Some(f)
                } else {
                    None
                }
            })
            .collect()
    }
}

impl NodePattern {
    /// Create a new node pattern.
    pub fn new(variable: Option<String>) -> Self {
        Self {
            variable,
            labels: Vec::new(),
            properties: None,
            where_clause: None,
        }
    }

    /// Add a label to the node pattern.
    pub fn with_label(mut self, label: String) -> Self {
        self.labels.push(label);
        self
    }

    /// Add properties to the node pattern.
    pub fn with_properties(mut self, properties: PropertyPattern) -> Self {
        self.properties = Some(properties);
        self
    }
}

impl RelationshipPattern {
    /// Create a new relationship pattern.
    pub fn new(direction: RelationshipDirection) -> Self {
        Self {
            variable: None,
            rel_type: None,
            properties: None,
            direction,
            length: None,
        }
    }

    /// Set the relationship type.
    pub fn with_type(mut self, rel_type: String) -> Self {
        self.rel_type = Some(rel_type);
        self
    }

    /// Set the variable name.
    pub fn with_variable(mut self, variable: String) -> Self {
        self.variable = Some(variable);
        self
    }
}

impl Expression {
    /// Create a literal expression.
    pub fn literal(value: Value) -> Self {
        Expression::Literal(value)
    }

    /// Create a variable expression.
    pub fn variable(name: String) -> Self {
        Expression::Variable(name)
    }

    /// Create a property access expression.
    pub fn property(object: Expression, property: String) -> Self {
        Expression::Property {
            object: Box::new(object),
            property,
        }
    }

    /// Create a binary expression.
    pub fn binary(left: Expression, operator: BinaryOperator, right: Expression) -> Self {
        Expression::Binary {
            left: Box::new(left),
            operator,
            right: Box::new(right),
        }
    }
}

impl Default for LinearQuery {
    fn default() -> Self {
        Self::new()
    }
}