use crate::prelude::*;

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct Number {
    pub value: f64,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct Str {
    pub value: String,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct Identifier {
    pub value: String,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct False;

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct True;

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct Nil;

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct Group {
    pub value: Box<Expression>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct Map {
    pub values: Vec<(Expression, Expression)>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct Block {
    pub statements: Vec<Statement>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct If {
    pub can_be_error: bool,
    /// 0: condition, 1: body
    pub branches: Vec<(Expression, Expression)>,
    pub else_branch: Option<Box<Expression>>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct While {
    pub can_be_error: bool,
    pub condition: Box<Expression>,
    pub body: Box<Expression>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct Import {
    pub value: Box<Expression>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct Function {
    pub can_be_error: bool,
    pub parameters: Vec<crate::Identifier>,
    pub body: Box<Expression>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct Check {
    pub can_be_error: bool,
    pub expression_to_check: Box<Expression>,
    pub alias: Option<crate::Identifier>,
    pub body: Box<Expression>,
    pub else_body: Option<Box<Expression>>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct For {
    pub can_be_error: bool,
    pub identifier: crate::Identifier,
    pub to_loop_over: Box<Expression>,
    pub body: Box<Expression>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct Assignement {
    pub identifier: crate::Identifier,
    pub expression: Box<Expression>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct AdditionAssignement {
    pub identifier: crate::Identifier,
    pub expression: Box<Expression>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct SubtractionAssignement {
    pub identifier: crate::Identifier,
    pub expression: Box<Expression>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct DivisionAssignement {
    pub identifier: crate::Identifier,
    pub expression: Box<Expression>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct MultiplicationAssignement {
    pub identifier: crate::Identifier,
    pub expression: Box<Expression>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct ModuloAssignement {
    pub identifier: crate::Identifier,
    pub expression: Box<Expression>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct And {
    pub lhs: Box<Expression>,
    pub rhs: Box<Expression>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct Or {
    pub lhs: Box<Expression>,
    pub rhs: Box<Expression>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct Equal {
    pub lhs: Box<Expression>,
    pub rhs: Box<Expression>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct NotEqual {
    pub lhs: Box<Expression>,
    pub rhs: Box<Expression>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct Greater {
    pub lhs: Box<Expression>,
    pub rhs: Box<Expression>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct GreaterEqual {
    pub lhs: Box<Expression>,
    pub rhs: Box<Expression>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct Less {
    pub lhs: Box<Expression>,
    pub rhs: Box<Expression>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct LessEqual {
    pub lhs: Box<Expression>,
    pub rhs: Box<Expression>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub enum Range {
    Closed {
        rhs: Box<Expression>,
        lhs: Box<Expression>,
    },
    From {
        lhs: Box<Expression>,
    },
    To {
        rhs: Box<Expression>,
    },
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct Addition {
    pub lhs: Box<Expression>,
    pub rhs: Box<Expression>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct Subtraction {
    pub lhs: Box<Expression>,
    pub rhs: Box<Expression>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct Multiplication {
    pub lhs: Box<Expression>,
    pub rhs: Box<Expression>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct Division {
    pub lhs: Box<Expression>,
    pub rhs: Box<Expression>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct Modulo {
    pub lhs: Box<Expression>,
    pub rhs: Box<Expression>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct Not {
    pub expression: Box<Expression>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct Negate {
    pub expression: Box<Expression>,
}

/// value!
#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct AsError {
    pub expression: Box<Expression>,
}

/// value?
#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct Expect {
    pub expression: Box<Expression>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct FieldAccess {
    pub expression: Box<Expression>,
    pub field: crate::Identifier,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct Index {
    pub expression: Box<Expression>,
    pub index: Box<Expression>,
}

#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
pub struct Call {
    pub expression: Box<Expression>,
    pub arguments: Vec<Expression>,
}