use std::rc::Rc;

use crate::ast::{Declaration, SymbolTable};

use tracing::instrument;

use uniplate::{Biplate, Uniplate};

use crate::{

    ast::{Atom, Domain, Expression as Expr, Name},

    metadata::Metadata,

};

/// True iff `expr` is an `Atom`.

/// True if `expr` is flat; i.e. it only contains atoms.

    }

/// True if the entire AST is constants.

            _ => {

            }

        }

    }

/// Converts a vector of expressions to a vector of atoms.

///

/// # Returns

///

/// `Some(Vec<Atom>)` if the vectors direct children expressions are all atomic, otherwise `None`.

#[allow(dead_code)]

        };

    }

/// Creates a new auxiliary variable using the given expression.

///

/// # Returns

///

/// * `None` if `Expr` is a `Atom`, or `Expr` does not have a domain (for example, if it is a `Bubble`).

///

/// * `Some(ToAuxVarOutput)` if successful, containing:

///     

///     + A new symbol table, modified to include the auxiliary variable.

///     + A new top level expression, containing the declaration of the auxiliary variable.

///     + A reference to the auxiliary variable to replace the existing expression with.

///

#[instrument]

pub fn to_aux_var(expr: &Expr, symbols: &SymbolTable) -> Option<ToAuxVarOutput> {

    let mut symbols = symbols.clone();

    // No need to put an atom in an aux_var

    if is_atom(expr) {

        return None;

    }

    // Anything that should be bubbled, bubble

    if !expr.is_safe() {

        return None;

    }

    let name = symbols.gensym();

    let Some(domain) = expr.domain_of(&symbols) else {

        tracing::trace!("could not find domain of {}", expr);

        return None;

    };

    symbols.insert(Rc::new(Declaration::new_var(name.clone(), domain.clone())))?;

    Some(ToAuxVarOutput {

        aux_name: name.clone(),

        aux_decl: Expr::AuxDeclaration(Metadata::new(), name, Box::new(expr.clone())),

        aux_domain: domain,

        symbols,

        _unconstructable: (),

    })

}

/// Output data of `to_aux_var`.

pub struct ToAuxVarOutput {

    aux_name: Name,

    aux_decl: Expr,

    #[allow(dead_code)] // TODO: aux_domain should be used soon, try removing this pragma

    aux_domain: Domain,

    symbols: SymbolTable,

    _unconstructable: (),

}

impl ToAuxVarOutput {

    /// Returns the new auxiliary variable as an `Atom`.

    /// Returns the new auxiliary variable as an `Expression`.

    ///

    /// This expression will have default `Metadata`.

    /// Returns the top level `Expression` to add to the model.

    /// Returns the new `SymbolTable`, modified to contain this auxiliary variable in the symbol table.

    /// Returns the name of the auxiliary variable.

}