use std::collections::VecDeque;

use conjure_cp::ast::{Domain, Expression as Expr, IntVal, Range, SymbolTable};

use conjure_cp::into_matrix_expr;

use conjure_cp::rule_engine::{

    ApplicationError::RuleNotApplicable, ApplicationResult, Reduction, register_rule,

};

use uniplate::Uniplate;

/// Converts a matrix to a list if possible.

///

/// A list is a matrix with the unbounded domain `int(1..)`. Unlike matrices in general, lists can

/// be resized; consequently, a lot more rules apply to them.

///

/// A matrix can be converted to a list if:

///

///  1. It has some contiguous domain `int(1..n)`.

///

///  2. It is a matrix literal (i.e. not a reference to a decision variable).

///

///  3. Its direct parent is a constraint, not another matrix or `AbstractLiteral`.

///

///    This prevents the conversion of rows in a 2d matrix from being turned into lists. If were

///    to happen, the rows of the matrix might become different lengths, which is invalid!

///

///  4. The matrix is stored as `Expression` type inside (i.e. not as an `Atom` inside a Minion

///     constraint)

///

/// Because of condition 4, and this rules low priority, this rule will not run post-flattening, so

/// matrices that do not need to be converted to lists in order to get them ready for Minion will

/// be left alone.

#[register_rule(("Base", 2000))]

    // match on the parent: do not apply this rule to things descended from abstract literal, or

    // special language constructs like bubble.

    //

    // As Minion/ flat constraints do not have expression children, they are automatically

    // excluded.

        Expr::AbstractLiteral(_, _)

            | Expr::Bubble(_, _, _)

            | Expr::Atomic(_, _)

             // not sure if this needs to be excluded, being cautious.

            | Expr::DominanceRelation(_, _)

    ) {

        // already a list => no change

        // not a matrix => no change

        };

        };

        // must be domain int(1..n)

        };

    }

    } else {

    }