use super::parsed_type_modifier::ParsedTypeModifier;
use crate::defines::{LiteralFloat, LiteralInt};
use crate::modifiers::{FieldModifier, TypeModifier};
use crate::parsing::parser::parser_operators::{BinaryOperator, PreOperator};
use crate::prim_type::PrimitiveType;
use enumflags2::BitFlags;

#[derive(PartialEq, Debug)]
pub enum ParsedStatement {
    Invalid,
    Script {
        statements: Vec<ParsedStatement>,
    },
    Namespace {
        identifier: String,
        script: Box<ParsedStatement>,
    },
    Interface {
        type_mod: BitFlags<TypeModifier>,
        identifier: String,
        inherits: Vec<String>,
        statements: Vec<ParsedStatement>,
    },
    Scope {
        is_global: bool,
        scope: Vec<String>,
        generic_types: Option<Vec<ParsedStatement>>,
    },
    VirtProp {
        field_mod: BitFlags<FieldModifier>,
        property_type: Box<ParsedStatement>,
        identifier: String,
        is_handle: bool,

        has_get: bool,
        is_get_const: bool,
        get_statement: Option<Box<ParsedStatement>>,

        has_set: bool,
        is_set_const: bool,
        set_statement: Option<Box<ParsedStatement>>,
    },
    DataTypeIdentifier {
        identifier: String,
    },
    DataTypeAuto {},
    DataTypePrimType {
        prim_type: PrimitiveType,
    },
    Type {
        is_const: bool,
        scope: Option<Box<ParsedStatement>>,
        datatype: Box<ParsedStatement>,
        modifiers: Vec<ParsedTypeModifier>,
    },
    Var {
        modifier: BitFlags<FieldModifier>,
        var_type: Box<ParsedStatement>,
        identifier: String,
        assignment: Option<Box<ParsedStatement>>,
    },
    ExprTermInitList {
        statement_type: Option<Box<ParsedStatement>>,
        initlist: Box<ParsedStatement>,
    },
    ExprTerm {
        pre_op: Vec<PreOperator>,
        exp_value: Box<ParsedStatement>,
    },
    ExprPreOp {
        operator: PreOperator,
    },
    ExprVoidValue {},
    ConstructCall {
        statement_type: Option<Box<ParsedStatement>>,
        arglist: Box<ParsedStatement>,
    },
    FuncCall {
        scope: Option<Box<ParsedStatement>>,
        identifier: String,
        arglist: Box<ParsedStatement>,
    },
    VarAccess {
        scope: Option<Box<ParsedStatement>>,
        identifier: String,
    },
    Cast {
        cast_type: Box<ParsedStatement>,
        assign: Box<ParsedStatement>,
    },
    IntegerLiteral(LiteralInt),
    FloatLiteral(LiteralFloat),
    BoolLiteral(bool),
    StringLiteral(String),
    BinaryExpr {
        left: Box<ParsedStatement>,
        operator: BinaryOperator,
        right: Box<ParsedStatement>,
    },
}