conjure_cp_core/parse/

parse_model.rs

#![allow(clippy::unwrap_used)]
#![allow(clippy::expect_used)]
use std::sync::{Arc, RwLock};
use ustr::Ustr;

use serde_json::Map as JsonMap;
use serde_json::Value;
use serde_json::Value as JsonValue;

use crate::ast::Moo;
use crate::ast::PartitionAttr;
use crate::ast::PermutationAttr;
use crate::ast::Typeable;
use crate::ast::ac_operators::ACOperatorKind;
use crate::ast::comprehension::ComprehensionBuilder;
use crate::ast::records::Field;
use crate::ast::{
    AbstractLiteral, Atom, BinaryAttr, DeclarationPtr, Domain, Expression, FuncAttr, IntVal,
    JectivityAttr, Literal, MSetAttr, Name, PartialityAttr, Range, RelAttr, ReturnType,
    SequenceAttr, SetAttr, SymbolTable, SymbolTablePtr,
};
use crate::ast::{DomainPtr, Metadata};
use crate::context::Context;
use crate::error::{Error, Result};
use crate::{Model, bug, error, into_matrix_expr, throw_error};

#[allow(unused_macros)]
macro_rules! parser_trace {
    ($($arg:tt)+) => {
        log::trace!(target:"jsonparser",$($arg)+)
    };
}

#[allow(unused_macros)]
macro_rules! parser_debug {
    ($($arg:tt)+) => {
        log::debug!(target:"jsonparser",$($arg)+)
    };
}

pub fn model_from_json(str: &str, context: Arc<RwLock<Context<'static>>>) -> Result<Model> {
    let mut m = Model::new(context);
    let v: JsonValue = serde_json::from_str(str)?;
    let statements = v["mStatements"]
        .as_array()
        .ok_or(error!("mStatements is not an array"))?;

    for statement in statements {
        let entry = statement
            .as_object()
            .ok_or(error!("mStatements contains a non-object"))?
            .iter()
            .next()
            .ok_or(error!("mStatements contains an empty object"))?;

        match entry.0.as_str() {
            "Declaration" => {
                let decl = entry
                    .1
                    .as_object()
                    .ok_or(error!("Declaration is not an object".to_owned()))?;

                // One field in the declaration should tell us what kind it is.
                //
                // Find it, ignoring the other fields.
                //
                // e.g. FindOrGiven,

                let mut valid_decl: bool = false;
                let scope = m.symbols_ptr_unchecked().clone();
                let model = &mut m;
                for (kind, value) in decl {
                    match kind.as_str() {
                        "FindOrGiven" => {
                            parse_variable(value, &mut model.symbols_mut())?;
                            valid_decl = true;
                            break;
                        }
                        "Letting" => {
                            parse_letting(value, &scope)?;
                            valid_decl = true;
                            break;
                        }
                        _ => continue,
                    }
                }

                if !valid_decl {
                    throw_error!("Declaration is not a valid kind")?;
                }
            }
            "SuchThat" => {
                let constraints_arr = match entry.1.as_array() {
                    Some(x) => x,
                    None => bug!("SuchThat is not a vector"),
                };

                let constraints: Vec<Expression> = constraints_arr
                    .iter()
                    .map(|x| parse_expression(x, m.symbols_ptr_unchecked()))
                    .collect::<Result<Vec<_>>>()?;
                m.add_constraints(constraints);
            }
            otherwise => bug!("Unhandled Statement {:#?}", otherwise),
        }
    }
    Ok(m)
}

fn parse_variable(v: &JsonValue, symtab: &mut SymbolTable) -> Result<()> {
    let arr = v.as_array().ok_or(error!("FindOrGiven is not an array"))?;

    let variable_type = arr[0]
        .as_str()
        .ok_or(error!("FindOrGiven[0] is not a string"))?;

    let name = arr[1]
        .as_object()
        .ok_or(error!("FindOrGiven[1] is not an object"))?["Name"]
        .as_str()
        .ok_or(error!("FindOrGiven[1].Name is not a string"))?;

    let name = Name::User(Ustr::from(name));

    let domain = arr[2]
        .as_object()
        .ok_or(error!("FindOrGiven[2] is not an object"))?
        .iter()
        .next()
        .ok_or(error!("FindOrGiven[2] is an empty object"))?;

    let domain = parse_domain(domain.0, domain.1, symtab)?;

    let decl = match variable_type {
        "Find" => DeclarationPtr::new_find(name.clone(), domain),
        "Given" => DeclarationPtr::new_given(name.clone(), domain),
        _ => {
            return Err(error!("FindOrGiven[0] is not 'Find' or 'Given'"));
        }
    };

    symtab.insert(decl).ok_or(Error::Parse(format!(
        "Could not add {name} to symbol table as it already exists"
    )))
}

fn parse_letting(v: &JsonValue, scope: &SymbolTablePtr) -> Result<()> {
    let arr = v.as_array().ok_or(error!("Letting is not an array"))?;
    let name = arr[0]
        .as_object()
        .ok_or(error!("Letting[0] is not an object"))?["Name"]
        .as_str()
        .ok_or(error!("Letting[0].Name is not a string"))?;
    let name = Name::User(Ustr::from(name));
    // value letting
    match parse_expression(&arr[1], scope) {
        Ok(value) => {
            let mut symtab = scope.write();
            symtab
                .insert(DeclarationPtr::new_value_letting(name.clone(), value))
                .ok_or(Error::Parse(format!(
                    "Could not add {name} to symbol table as it already exists"
                )))
        }
        Err(expression_error) => {
            // A letting whose value is not an expression may be a domain letting. Use
            // `get` here rather than indexing so an unsupported value expression is
            // reported as a parse error instead of panicking on a missing `Domain` key.
            let domain = arr[1]
                .as_object()
                .and_then(|value| value.get("Domain"))
                .ok_or(expression_error)?
                .as_object()
                .ok_or(error!("Letting[1].Domain is not an object"))?
                .iter()
                .next()
                .ok_or(error!("Letting[1].Domain is an empty object"))?;

            let mut symtab = scope.write();
            let domain = parse_domain(domain.0, domain.1, &mut symtab)?;

            symtab
                .insert(DeclarationPtr::new_domain_letting(name.clone(), domain))
                .ok_or(Error::Parse(format!(
                    "Could not add {name} to symbol table as it already exists"
                )))
        }
    }
}

fn parse_domain(
    domain_name: &str,
    domain_value: &JsonValue,
    symbols: &mut SymbolTable,
) -> Result<DomainPtr> {
    match domain_name {
        "DomainInt" => Ok(parse_int_domain(domain_value, symbols)?),
        "DomainBool" => Ok(Domain::bool()),
        "DomainReference" => {
            let name = Name::user(
                domain_value
                    .as_array()
                    .ok_or(error!("DomainReference is not an array"))?[0]
                    .as_object()
                    .ok_or(error!("DomainReference[0] is not an object"))?["Name"]
                    .as_str()
                    .ok_or(error!("DomainReference[0].Name is not a string"))?,
            );
            let ptr = symbols
                .lookup(&name)
                .ok_or(error!(format!("Name {name} not found")))?;
            let dom =
                Domain::reference(ptr).ok_or(error!("Could not construct reference domain"))?;
            Ok(dom)
        }
        "DomainSet" => {
            let dom = domain_value.get(2).and_then(|v| v.as_object());
            let domain_obj = dom.ok_or(error!("DomainSet is missing domain object"))?;
            let domain = domain_obj
                .iter()
                .next()
                .ok_or(Error::Parse("DomainSet is an empty object".to_owned()))?;
            let domain = parse_domain(domain.0.as_str(), domain.1, symbols)?;
            let size = domain_value
                .get(1)
                .and_then(|v| v.as_object())
                .ok_or(error!("Set size attributes is not an object"))?;
            let size = parse_size_attr(size, symbols)?;
            let attr: SetAttr<IntVal> = SetAttr::new(size);
            Ok(Domain::set(attr, domain))
        }
        "DomainMSet" => {
            let dom = domain_value
                .get(2)
                .and_then(|v| v.as_object())
                .expect("domain object exists");
            let domain = dom
                .iter()
                .next()
                .ok_or(Error::Parse("DomainMSet is an empty object".to_owned()))?;
            let domain = parse_domain(domain.0.as_str(), domain.1, symbols)?;

            // Parse Attributes
            let attributes = domain_value
                .get(1)
                .and_then(|v| v.as_array())
                .ok_or(error!("MSet attributes is not a json array"))?;

            let size = attributes
                .first()
                .and_then(|v| v.as_object())
                .ok_or(error!("MSet size attributes is not an object"))?;
            let size = parse_size_attr(size, symbols)?;

            let occurrence = attributes
                .get(1)
                .and_then(|v| v.as_object())
                .ok_or(error!("MSet occurrence attributes is not an object"))?;
            let occurrence = parse_occur_attr(occurrence, symbols)?;

            let attr: MSetAttr<IntVal> = MSetAttr {
                size,
                occurrence,
                representation: None,
            };
            Ok(Domain::mset(attr, domain))
        }
        "DomainPartition" => {
            let dom = domain_value
                .get(2)
                .and_then(|v| v.as_object())
                .expect("domain object exists");
            let domain = dom.iter().next().ok_or(Error::Parse(
                "DomainPartition is an empty object".to_owned(),
            ))?;
            let domain = parse_domain(domain.0.as_str(), domain.1, symbols)?;

            let attributes = domain_value
                .get(1)
                .and_then(|v| v.as_object())
                .ok_or(error!("Partition attributes is not an object"))?;

            let mut num_parts = Range::Unbounded;
            let mut part_len = Range::Unbounded;
            let mut is_regular = false;

            if let Some(val) = attributes.get("partsNum") {
                let attr_map = val.as_object().expect("numParts should be an object");
                num_parts = parse_size_attr(attr_map, symbols)?;
            }
            if let Some(val) = attributes.get("partsSize") {
                let attr_map = val.as_object().expect("partsSize should be an object");
                part_len = parse_size_attr(attr_map, symbols)?;
            }
            if let Some(val) = attributes.get("isRegular").and_then(|v| v.as_bool()) {
                is_regular = val;
            }

            let attr: PartitionAttr<IntVal> = PartitionAttr {
                num_parts,
                part_len,
                is_regular,
            };
            Ok(Domain::partition(attr, domain))
        }
        "DomainPermutation" => {
            let dom = domain_value
                .get(2)
                .and_then(|v| v.as_object())
                .expect("domain object exists");
            let domain = dom.iter().next().ok_or(Error::Parse(
                "DomainPermutation is an empty object".to_owned(),
            ))?;
            let domain = parse_domain(domain.0.as_str(), domain.1, symbols)?;

            let attributes = domain_value
                .get(1)
                .and_then(|v| v.as_object())
                .ok_or(error!("Permutation attributes is not an object"))?;

            let mut num_moved = Range::Unbounded;
            if let Some(val) = attributes.get("numMoved") {
                let attr_map = val.as_object().expect("numMoved should be an object");
                num_moved = parse_size_attr(attr_map, symbols)?;
            }

            let attr: PermutationAttr<IntVal> = PermutationAttr { num_moved };
            Ok(Domain::permutation(attr, domain))
        }
        "DomainMatrix" => {
            let domain_value = domain_value
                .as_array()
                .ok_or(error!("Domain matrix is not an array"))?;

            let indexed_by_domain = domain_value[0].clone();
            let (index_domain_name, index_domain_value) = indexed_by_domain
                .as_object()
                .ok_or(error!("DomainMatrix[0] is not an object"))?
                .iter()
                .next()
                .ok_or(error!(""))?;

            let (value_domain_name, value_domain_value) = domain_value[1]
                .as_object()
                .ok_or(error!(""))?
                .iter()
                .next()
                .ok_or(error!(""))?;

            // Conjure stores a 2-d matrix as a matrix of a matrix.
            //
            // Therefore, the index is always a Domain.

            let mut index_domains: Vec<DomainPtr> = vec![];

            index_domains.push(parse_domain(
                index_domain_name,
                index_domain_value,
                symbols,
            )?);

            // We want to store 2-d matrices as a matrix with two index domains, not a matrix in a
            // matrix.
            //
            // Walk through the value domain until it is not a DomainMatrix, adding the index to
            // our list of indices.
            let mut value_domain = parse_domain(value_domain_name, value_domain_value, symbols)?;
            while let Some((new_value_domain, mut indices)) = value_domain.as_matrix() {
                index_domains.append(&mut indices);
                value_domain = new_value_domain.clone()
            }

            Ok(Domain::matrix(value_domain, index_domains))
        }

        "DomainSequence" => {
            let dom = domain_value
                .get(2)
                .and_then(|v| v.as_object())
                .expect("domain object exists");
            let domain = dom
                .iter()
                .next()
                .ok_or(Error::Parse("DomainSequence is an empty object".to_owned()))?;
            let domain = parse_domain(domain.0.as_str(), domain.1, symbols)?;

            // Parse Attributes
            let attributes = domain_value
                .get(1)
                .and_then(|v| v.as_array())
                .ok_or(error!("Sequence attributes is not a json array"))?;

            let size = attributes
                .first()
                .and_then(|v| v.as_object())
                .ok_or(error!("Sequence size attributes is not an object"))?;
            let size = parse_size_attr(size, symbols)?;

            let jectivity = attributes
                .get(1)
                .and_then(|v| v.as_str())
                .ok_or(error!("jectivity is not a string"))?;
            let jectivity = match jectivity {
                "JectivityAttr_Injective" => Some(JectivityAttr::Injective),
                "JectivityAttr_Surjective" => Some(JectivityAttr::Surjective),
                "JectivityAttr_Bijective" => Some(JectivityAttr::Bijective),
                "JectivityAttr_None" => Some(JectivityAttr::None),
                _ => None,
            };
            let jectivity =
                jectivity.ok_or(Error::Parse("Jectivity is an unknown type".to_owned()))?;

            let attr: SequenceAttr<IntVal> = SequenceAttr {
                size,
                jectivity,
                representation: None,
            };
            match attr.size {
                Range::Unbounded | Range::UnboundedR(_) => Err(Error::Parse(
                    "Sequence must have size or maxSize attribute".to_string(),
                )),
                _ => Ok(Domain::sequence(attr, domain)),
            }
        }

        "DomainTuple" => {
            let domain_value = domain_value
                .as_array()
                .ok_or(error!("Domain tuple is not an array"))?;

            //iterate through the array and parse each domain
            let domain = domain_value
                .iter()
                .map(|x| {
                    let domain = x
                        .as_object()
                        .ok_or(error!("DomainTuple[0] is not an object"))?
                        .iter()
                        .next()
                        .ok_or(error!("DomainTuple[0] is an empty object"))?;
                    parse_domain(domain.0, domain.1, symbols)
                })
                .collect::<Result<Vec<DomainPtr>>>()?;

            Ok(Domain::tuple(domain))
        }
        "DomainRecord" | "DomainVariant" => {
            // Records and Variants can be parsed the same way for the most part
            let is_record = domain_name == "DomainRecord";
            // Get the actual string for error message purposes
            let domain_string = match is_record {
                true => "Record",
                false => "Variant",
            };
            let domain_value = domain_value.as_array().ok_or(error!(&format!(
                "Domain {domain_string} is not a json array"
            )))?;

            let mut entries = vec![];

            for item in domain_value {
                //collect the name of the field
                let name = item[0]
                    .as_object()
                    .ok_or(error!("FindOrGiven[1] is not an object"))?["Name"]
                    .as_str()
                    .ok_or(error!("FindOrGiven[1].Name is not a string"))?;

                let name = Name::User(Ustr::from(name));
                // then collect the domain of the field
                let domain = item[1]
                    .as_object()
                    .ok_or(error!("FindOrGiven[2] is not an object"))?
                    .iter()
                    .next()
                    .ok_or(error!("FindOrGiven[2] is an empty object"))?;

                let rec = Field {
                    name,
                    value: parse_domain(domain.0, domain.1, symbols)?,
                };

                entries.push(rec);
            }

            if is_record {
                Ok(Domain::record(entries))
            } else {
                Ok(Domain::variant(entries))
            }
        }
        "DomainFunction" => {
            let domain = domain_value
                .get(2)
                .and_then(|v| v.as_object())
                .ok_or(error!("Function domain is not an object"))?;
            let domain = domain
                .iter()
                .next()
                .ok_or(Error::Parse("DomainSet is an empty object".to_owned()))?;
            let domain = parse_domain(domain.0.as_str(), domain.1, symbols)?;

            let codomain = domain_value
                .get(3)
                .and_then(|v| v.as_object())
                .ok_or(error!("Function codomain is not an object"))?;
            let codomain = codomain
                .iter()
                .next()
                .ok_or(Error::Parse("DomainSet is an empty object".to_owned()))?;
            let codomain = parse_domain(codomain.0.as_str(), codomain.1, symbols)?;

            // Attribute parsing
            let attributes = domain_value
                .get(1)
                .and_then(|v| v.as_array())
                .ok_or(error!("Function attributes is not a json array"))?;
            let size = attributes
                .first()
                .and_then(|v| v.as_object())
                .ok_or(error!("Function size attributes is not an object"))?;
            let size = parse_size_attr(size, symbols)?;
            let partiality = attributes
                .get(1)
                .and_then(|v| v.as_str())
                .ok_or(error!("Function partiality is not a string"))?;
            let partiality = match partiality {
                "PartialityAttr_Partial" => Some(PartialityAttr::Partial),
                "PartialityAttr_Total" => Some(PartialityAttr::Total),
                _ => None,
            };
            let partiality =
                partiality.ok_or(Error::Parse("Partiality is an unknown type".to_owned()))?;
            let jectivity = attributes
                .get(2)
                .and_then(|v| v.as_str())
                .ok_or(error!("Function jectivity is not a string"))?;
            let jectivity = match jectivity {
                "JectivityAttr_Injective" => Some(JectivityAttr::Injective),
                "JectivityAttr_Surjective" => Some(JectivityAttr::Surjective),
                "JectivityAttr_Bijective" => Some(JectivityAttr::Bijective),
                "JectivityAttr_None" => Some(JectivityAttr::None),
                _ => None,
            };
            let jectivity =
                jectivity.ok_or(Error::Parse("Jectivity is an unknown type".to_owned()))?;

            let attr: FuncAttr<IntVal> = FuncAttr {
                size,
                partiality,
                jectivity,
            };

            Ok(Domain::function(attr, domain, codomain))
        }

        "DomainRelation" => {
            let domains = domain_value
                .get(2)
                .and_then(|v| v.as_array())
                .ok_or(Error::Parse(
                    "Relation domains are not a json array".to_owned(),
                ))?;
            let domains = domains
                .iter()
                .map(|x| {
                    let domain = x
                        .as_object()
                        .ok_or(Error::Parse("Relation domain is not an object".to_owned()))?
                        .iter()
                        .next()
                        .ok_or(Error::Parse(
                            "Relation domain is an empty object".to_owned(),
                        ))?;
                    parse_domain(domain.0, domain.1, symbols)
                })
                .collect::<Result<Vec<DomainPtr>>>()?;

            // Attribute parsing
            let attributes = domain_value
                .get(1)
                .and_then(|v| v.as_array())
                .ok_or(Error::Parse(
                    "Relation attributes are not a json array".to_owned(),
                ))?;
            let size = attributes
                .first()
                .and_then(|v| v.as_object())
                .ok_or(Error::Parse(
                    "Relation size attributes are not an object".to_owned(),
                ))?;
            let size = parse_size_attr(size, symbols)?;
            let binary = attributes
                .get(1)
                .and_then(|v| v.as_array())
                .ok_or(Error::Parse(
                    "Relation binary attributes are not a json array".to_owned(),
                ))?;
            let binary = binary
                .iter()
                .map(|x| {
                    let attr = x.as_str().ok_or(Error::Parse(
                        "Relation binary attribute is not a string".to_owned(),
                    ))?;
                    match attr {
                        "BinRelAttr_Reflexive" => Ok(BinaryAttr::Reflexive),
                        "BinRelAttr_Irreflexive" => Ok(BinaryAttr::Irreflexive),
                        "BinRelAttr_Coreflexive" => Ok(BinaryAttr::Coreflexive),
                        "BinRelAttr_Symmetric" => Ok(BinaryAttr::Symmetric),
                        "BinRelAttr_AntiSymmetric" => Ok(BinaryAttr::AntiSymmetric),
                        "BinRelAttr_ASymmetric" => Ok(BinaryAttr::ASymmetric),
                        "BinRelAttr_Transitive" => Ok(BinaryAttr::Transitive),
                        "BinRelAttr_Total" => Ok(BinaryAttr::Total),
                        "BinRelAttr_Connex" => Ok(BinaryAttr::Connex),
                        "BinRelAttr_Euclidean" => Ok(BinaryAttr::Euclidean),
                        "BinRelAttr_Serial" => Ok(BinaryAttr::Serial),
                        "BinRelAttr_Equivalence" => Ok(BinaryAttr::Equivalence),
                        "BinRelAttr_PartialOrder" => Ok(BinaryAttr::PartialOrder),
                        "BinRelAttr_LeftTotal" => Ok(BinaryAttr::LeftTotal),
                        "BinRelAttr_RightTotal" => Ok(BinaryAttr::RightTotal),
                        "BinRelAttr_LinearOrder" => Ok(BinaryAttr::LinearOrder),
                        "BinRelAttr_WeakOrder" => Ok(BinaryAttr::WeakOrder),
                        "BinRelAttr_PreOrder" => Ok(BinaryAttr::PreOrder),
                        "BinRelAttr_StrictPartialOrder" => Ok(BinaryAttr::StrictPartialOrder),
                        _ => Err(Error::Parse(
                            "Relation binary attribute is invalid".to_owned(),
                        )),
                    }
                })
                .collect::<Result<Vec<BinaryAttr>>>()?;

            let attr: RelAttr<IntVal> = RelAttr { size, binary };

            Ok(Domain::relation(attr, domains))
        }
        _ => Err(Error::Parse(
            "FindOrGiven[2] is an unknown object".to_owned(), // consider covered
        )),
    }
}

fn parse_size_attr(
    attr_map: &JsonMap<String, JsonValue>,
    symbols: &mut SymbolTable,
) -> Result<Range<IntVal>> {
    let scope = SymbolTablePtr::new();
    *scope.write() = symbols.clone();

    let attr_obj = attr_map
        .iter()
        .next()
        .ok_or(Error::Parse("SizeAttr is an empty object".to_owned()))?;
    match attr_obj.0.as_str() {
        "SizeAttr_None" => Ok(Range::Unbounded),
        "SizeAttr_MinSize" => {
            let size = parse_expression_to_int_val(attr_obj.1, &scope)?;
            Ok(Range::UnboundedR(size))
        }
        "SizeAttr_MaxSize" => {
            let size = parse_expression_to_int_val(attr_obj.1, &scope)?;
            Ok(Range::UnboundedL(size))
        }
        "SizeAttr_MinMaxSize" => {
            let min_max = attr_obj
                .1
                .as_array()
                .ok_or(error!("SizeAttr MinMaxSize is not a json array"))?;
            let min = min_max
                .first()
                .ok_or(error!("SizeAttr Min is not present"))?;
            let min_int = parse_expression_to_int_val(min, &scope)?;
            let max = min_max
                .get(1)
                .ok_or(error!("SizeAttr Max is not present"))?;
            let max_int = parse_expression_to_int_val(max, &scope)?;
            Ok(Range::Bounded(min_int, max_int))
        }
        "SizeAttr_Size" => {
            let size = parse_expression_to_int_val(attr_obj.1, &scope)?;
            Ok(Range::Single(size))
        }
        _ => Err(Error::Parse("SizeAttr is an unknown type".to_owned())),
    }
}

fn parse_occur_attr(
    attr_map: &JsonMap<String, JsonValue>,
    symbols: &mut SymbolTable,
) -> Result<Range<IntVal>> {
    let scope = SymbolTablePtr::new();
    *scope.write() = symbols.clone();
    let attr_obj = attr_map
        .iter()
        .next()
        .ok_or(Error::Parse("OccurAttr is an empty object".to_owned()))?;
    match attr_obj.0.as_str() {
        "OccurAttr_None" => Ok(Range::Unbounded),
        "OccurAttr_MinOccur" => {
            let size_int = parse_expression_to_int_val(attr_obj.1, &scope)?;
            Ok(Range::UnboundedR(size_int))
        }
        "OccurAttr_MaxOccur" => {
            let size_int = parse_expression_to_int_val(attr_obj.1, &scope)?;
            Ok(Range::UnboundedL(size_int))
        }
        "OccurAttr_MinMaxOccur" => {
            let min_max = attr_obj
                .1
                .as_array()
                .ok_or(error!("OccurAttr MinMaxOccur is not a json array"))?;
            let min = min_max
                .first()
                .ok_or(error!("OccurAttr Min is not present"))?;
            let min_int = parse_expression_to_int_val(min, &scope)?;
            let max = min_max
                .get(1)
                .ok_or(error!("OccurAttr Max is not present"))?;
            let max_int = parse_expression_to_int_val(max, &scope)?;
            Ok(Range::Bounded(min_int, max_int))
        }
        "OccurAttr_Size" => {
            let size_int = parse_expression_to_int_val(attr_obj.1, &scope)?;
            Ok(Range::Single(size_int))
        }
        _ => Err(Error::Parse("OccurAttr is an unknown type".to_owned())),
    }
}

fn parse_int_domain(v: &JsonValue, symbols: &SymbolTable) -> Result<DomainPtr> {
    let scope = SymbolTablePtr::new();
    *scope.write() = symbols.clone();

    let mut ranges = Vec::new();
    let arr = v
        .as_array()
        .ok_or(error!("DomainInt is not an array".to_owned()))?[1]
        .as_array()
        .ok_or(error!("DomainInt[1] is not an array".to_owned()))?;
    if arr.is_empty() {
        return Ok(Domain::int(vec![Range::Bounded(
            crate::ast::OXIDE_INT_MIN,
            crate::ast::OXIDE_INT_MAX,
        )]));
    }
    for range in arr {
        let range = range
            .as_object()
            .ok_or(error!("DomainInt[1] contains a non-object"))?
            .iter()
            .next()
            .ok_or(error!("DomainInt[1] contains an empty object"))?;
        match range.0.as_str() {
            "RangeBounded" => {
                let arr = range
                    .1
                    .as_array()
                    .ok_or(error!("RangeBounded is not an array".to_owned()))?;
                let mut nums = Vec::new();
                for item in arr.iter() {
                    let num = parse_expression_to_int_val(item, &scope)?;
                    nums.push(num);
                }
                let lower = nums
                    .first()
                    .cloned()
                    .ok_or(error!("RangeBounded lower bound missing"))?;
                let upper = nums
                    .get(1)
                    .cloned()
                    .ok_or(error!("RangeBounded upper bound missing"))?;
                ranges.push(Range::Bounded(lower, upper));
            }
            "RangeSingle" => {
                let num = parse_expression_to_int_val(range.1, &scope)?;
                ranges.push(Range::Single(num));
            }
            _ => return throw_error!("DomainInt[1] contains an unknown object"),
        }
    }
    Ok(Domain::int(ranges))
}

fn parse_expression_to_int_val(obj: &JsonValue, scope: &SymbolTablePtr) -> Result<IntVal> {
    parser_trace!("trying to parse domain value as expression: {}", obj);
    let expr = parse_expression(obj, scope)?;

    if let Some(Literal::Int(i)) = expr.clone().into_literal() {
        return Ok(IntVal::Const(i as i64));
    }

    if let Expression::Atomic(_, Atom::Reference(reference)) = &expr
        && let Ok(reference_val) = IntVal::new_ref(reference)
    {
        return Ok(reference_val);
    }

    IntVal::new_expr(Moo::new(expr))
        .map_err(|e| error!(format!("Could not parse integer expression: {e}")))
}

type BinOp = fn(Metadata, Moo<Expression>, Moo<Expression>) -> Expression;
type UnaryOp = fn(Metadata, Moo<Expression>) -> Expression;

fn binary_operator(op_name: &str) -> Option<BinOp> {
    match op_name {
        "MkOpIn" => Some(Expression::In),
        "MkOpUnion" => Some(Expression::Union),
        "MkOpIntersect" => Some(Expression::Intersect),
        "MkOpSupset" => Some(Expression::Supset),
        "MkOpSupsetEq" => Some(Expression::SupsetEq),
        "MkOpSubset" => Some(Expression::Subset),
        "MkOpSubsetEq" => Some(Expression::SubsetEq),
        "MkOpEq" => Some(Expression::Eq),
        "MkOpNeq" => Some(Expression::Neq),
        "MkOpGeq" => Some(Expression::Geq),
        "MkOpLeq" => Some(Expression::Leq),
        "MkOpGt" => Some(Expression::Gt),
        "MkOpLt" => Some(Expression::Lt),
        "MkOpLexLt" => Some(Expression::LexLt),
        "MkOpLexGt" => Some(Expression::LexGt),
        "MkOpLexLeq" => Some(Expression::LexLeq),
        "MkOpLexGeq" => Some(Expression::LexGeq),
        "MkOpDiv" => Some(Expression::UnsafeDiv),
        "MkOpMod" => Some(Expression::UnsafeMod),
        "MkOpMinus" => Some(Expression::Minus),
        "MkOpImply" => Some(Expression::Imply),
        "MkOpIff" => Some(Expression::Iff),
        "MkOpPow" => Some(Expression::UnsafePow),
        "MkOpImage" => Some(Expression::Image),
        "MkOpImageSet" => Some(Expression::ImageSet),
        "MkOpPreImage" => Some(Expression::PreImage),
        "MkOpInverse" => Some(Expression::Inverse),
        "MkOpCompose" => Some(Expression::Compose),
        "MkOpRestrict" => Some(Expression::Restrict),
        "MkOpApart" => Some(Expression::Apart),
        "MkOpTogether" => Some(Expression::Together),
        "MkOpParty" => Some(Expression::Party),
        "MkOpSubstring" => Some(Expression::Substring),
        "MkOpSubsequence" => Some(Expression::Subsequence),
        _ => None,
    }
}

fn unary_operator(op_name: &str, inner: Option<&Expression>) -> Option<UnaryOp> {
    match op_name {
        "MkOpNot" => Some(Expression::Not),
        "MkOpNegate" => Some(Expression::Neg),
        "MkOpTwoBars" => {
            if let Some(inner) = inner {
                match inner.return_type() {
                    ReturnType::Int => Some(Expression::Abs),
                    ReturnType::Matrix(_)
                    | ReturnType::Set(_)
                    | ReturnType::MSet(_)
                    | ReturnType::Function(_, _)
                    | ReturnType::Relation(_) => Some(Expression::Card),
                    _ => None,
                }
            } else {
                // Internal expression cannot be known yet, so we just have to assume
                Some(Expression::Abs)
            }
        }
        "MkOpAnd" => Some(Expression::And),
        "MkOpSum" => Some(Expression::Sum),
        "MkOpProduct" => Some(Expression::Product),
        "MkOpOr" => Some(Expression::Or),
        "MkOpMin" => Some(Expression::Min),
        "MkOpMax" => Some(Expression::Max),
        "MkOpAllDiff" => Some(Expression::AllDiff),
        "MkOpToInt" => Some(Expression::ToInt),
        "MkOpDefined" => Some(Expression::Defined),
        "MkOpPermInverse" => Some(Expression::PermInverse),
        "MkOpRange" => Some(Expression::Range),
        "MkOpFactorial" => Some(Expression::Factorial),
        "MkOpToMSet" => Some(Expression::ToMSet),
        "MkOpToRelation" => Some(Expression::ToRelation),
        "MkOpParticipants" => Some(Expression::Participants),
        "MkOpParts" => Some(Expression::Parts),
        _ => None,
    }
}

fn parse_reference_name(obj: &JsonValue) -> Result<Name> {
    // { Name: "x" } directly
    if let Some(name) = obj.get("Name").and_then(|x| x.as_str()) {
        return Ok(Name::User(Ustr::from(name)));
    }

    // {
    //   Reference: [
    //     { Name: "x" }
    //   ]
    // }
    let ref_arr = obj["Reference"]
        .as_array()
        .ok_or_else(|| error!("Reference.as_array"))?;
    let ref_obj = ref_arr
        .first()
        .and_then(|x| x.as_object())
        .ok_or_else(|| error!("Reference[0].as_object"))?;
    let name = ref_obj
        .get("Name")
        .and_then(|x| x.as_str())
        .ok_or_else(|| error!("Reference[0].Name.as_str"))?;
    Ok(Name::User(Ustr::from(name)))
}

pub fn parse_expression(obj: &JsonValue, scope: &SymbolTablePtr) -> Result<Expression> {
    let fail = |stage: &str| -> Error {
        Error::Parse(format!(
            "Could not parse expression at stage `{stage}` for json `{obj}`"
        ))
    };

    match obj {
        Value::Object(op) if op.contains_key("Op") => {
            let op_obj = op
                .get("Op")
                .and_then(Value::as_object)
                .ok_or_else(|| fail("Op.as_object"))?;
            let (op_name, _) = op_obj.iter().next().ok_or_else(|| fail("Op.iter().next"))?;

            if op_obj.contains_key("MkOpFlatten") {
                parse_flatten_op(op_obj, scope)
            } else if op_obj.contains_key("MkOpTable") {
                parse_table_op(op_obj, scope)
            } else if op_obj.contains_key("MkOpIndexing") || op_obj.contains_key("MkOpSlicing") {
                parse_indexing_slicing_op(op_obj, scope)
            } else if op_obj.contains_key("MkOpActive") {
                parse_active_op(op_obj, scope)
            } else if op_obj.contains_key("MkOpRelationProj") {
                parse_relation_projection(op_obj, scope)
            } else if op_obj.contains_key("MkOpToSet") {
                parse_to_set(op_obj, scope)
            } else if binary_operator(op_name).is_some() {
                parse_bin_op(op_obj, scope)
            } else if unary_operator(op_name, None).is_some() {
                parse_unary_op(op_obj, scope)
            } else {
                Err(fail("Op.unknown"))
            }
        }
        Value::Object(comprehension) if comprehension.contains_key("Comprehension") => {
            parse_comprehension(comprehension, scope.clone())
        }
        Value::Object(refe) if refe.contains_key("Reference") => {
            let user_name = parse_reference_name(obj)?;

            let declaration: DeclarationPtr = scope
                .read()
                .lookup(&user_name)
                .ok_or_else(|| fail("Reference.lookup"))?;

            Ok(Expression::Atomic(
                Metadata::new(),
                Atom::Reference(crate::ast::Reference::new(declaration)),
            ))
        }
        // In the case where refering to fields. This not behind a reference
        Value::Object(refe) if refe.contains_key("Name") => {
            let name = refe
                .get("Name")
                .and_then(|x| x.as_str())
                .ok_or_else(|| fail("Reference[0].Name.as_str"))?;
            let user_name = Name::User(Ustr::from(name));

            let declaration: DeclarationPtr = scope
                .read()
                .lookup(&user_name)
                .ok_or_else(|| fail("Reference.lookup"))?;

            Ok(Expression::Atomic(
                Metadata::new(),
                Atom::Reference(crate::ast::Reference::new(declaration)),
            ))
        }
        Value::Object(abslit) if abslit.contains_key("AbstractLiteral") => {
            let abstract_literal = abslit["AbstractLiteral"]
                .as_object()
                .ok_or_else(|| fail("AbstractLiteral.as_object"))?;

            if abstract_literal.contains_key("AbsLitSet") {
                parse_abs_lit(&abslit["AbstractLiteral"]["AbsLitSet"], scope)
            } else if abstract_literal.contains_key("AbsLitFunction") {
                parse_abs_function(&abslit["AbstractLiteral"]["AbsLitFunction"], scope)
            } else if abstract_literal.contains_key("AbsLitMSet") {
                parse_abs_mset(&abslit["AbstractLiteral"]["AbsLitMSet"], scope)
            } else if abstract_literal.contains_key("AbsLitVariant") {
                parse_abs_variant(&abslit["AbstractLiteral"]["AbsLitVariant"], scope)
            } else if abstract_literal.contains_key("AbsLitRelation") {
                parse_abs_relation(&abslit["AbstractLiteral"]["AbsLitRelation"], scope)
            } else if abstract_literal.contains_key("AbsLitPartition") {
                parse_abs_partition(&abslit["AbstractLiteral"]["AbsLitPartition"], scope)
            } else if abstract_literal.contains_key("AbsLitPermutation") {
                parse_abs_permutation(&abslit["AbstractLiteral"]["AbsLitPermutation"], scope)
            } else if abstract_literal.contains_key("AbsLitSequence") {
                parse_abs_sequence(&abslit["AbstractLiteral"]["AbsLitSequence"], scope)
            } else {
                parse_abstract_matrix_as_expr(obj, scope)
            }
        }

        Value::Object(constant) if constant.contains_key("Constant") => {
            parse_constant(constant, scope).or_else(|_| parse_abstract_matrix_as_expr(obj, scope))
        }

        Value::Object(constant) if constant.contains_key("ConstantAbstract") => {
            let literal = constant
                .get("ConstantAbstract")
                .and_then(Value::as_object)
                .ok_or_else(|| fail("ConstantAbstract.as_object"))?;
            if literal.contains_key("AbsLitMatrix") {
                parse_abstract_matrix_as_expr(obj, scope)
            } else {
                parse_constant_abstract(literal, scope)
            }
        }

        Value::Object(constant) if constant.contains_key("ConstantInt") => {
            parse_constant(constant, scope)
        }
        Value::Object(constant) if constant.contains_key("ConstantBool") => {
            parse_constant(constant, scope)
        }

        _ => Err(fail("no_match")),
    }
}

fn parse_abs_lit(abs_set: &Value, scope: &SymbolTablePtr) -> Result<Expression> {
    let values = abs_set
        .as_array()
        .ok_or(error!("AbsLitSet is not an array"))?;
    let expressions = values
        .iter()
        .map(|values| parse_expression(values, scope))
        .collect::<Result<Vec<_>>>()?;

    Ok(Expression::AbstractLiteral(
        Metadata::new(),
        AbstractLiteral::Set(expressions),
    ))
}

fn parse_constant_abstract(
    literal: &serde_json::Map<String, Value>,
    scope: &SymbolTablePtr,
) -> Result<Expression> {
    if let Some(value) = literal.get("AbsLitSet") {
        parse_abs_lit(value, scope)
    } else if let Some(value) = literal.get("AbsLitMSet") {
        parse_abs_mset(value, scope)
    } else if let Some(value) = literal.get("AbsLitTuple") {
        parse_abs_tuple(value, scope)
    } else if let Some(value) = literal.get("AbsLitRecord") {
        parse_abs_record(value, scope)
    } else if let Some(value) = literal.get("AbsLitPartition") {
        parse_abs_partition(value, scope)
    } else if let Some(value) = literal.get("AbsLitPermutation") {
        parse_abs_permutation(value, scope)
    } else if let Some(value) = literal.get("AbsLitFunction") {
        parse_abs_function(value, scope)
    } else if let Some(value) = literal.get("AbsLitVariant") {
        parse_abs_variant(value, scope)
    } else if let Some(value) = literal.get("AbsLitRelation") {
        parse_abs_relation(value, scope)
    } else if let Some(value) = literal.get("AbsLitSequence") {
        parse_abs_sequence(value, scope)
    } else {
        Err(error!("Unhandled ConstantAbstract literal type"))
    }
}

fn parse_abs_mset(abs_mset: &Value, scope: &SymbolTablePtr) -> Result<Expression> {
    let values = abs_mset
        .as_array()
        .ok_or(error!("AbsLitMSet is not an array"))?;
    let expressions = values
        .iter()
        .map(|values| parse_expression(values, scope))
        .collect::<Result<Vec<_>>>()?;

    Ok(Expression::AbstractLiteral(
        Metadata::new(),
        AbstractLiteral::MSet(expressions),
    ))
}

fn parse_abs_partition(abs_partition: &Value, scope: &SymbolTablePtr) -> Result<Expression> {
    let parts = abs_partition
        .as_array()
        .ok_or(error!("AbsLitPartition is not an array"))?;

    let mut partition: Vec<Vec<_>> = Vec::new();

    for part in parts {
        let vals = part
            .as_array()
            .ok_or(error!("Part in AbsLitPartition is not an array"))?;

        let exprs = vals
            .iter()
            .map(|values| parse_expression(values, scope))
            .collect::<Result<Vec<_>>>()?;

        partition.push(exprs);
    }

    Ok(Expression::AbstractLiteral(
        Metadata::new(),
        AbstractLiteral::Partition(partition),
    ))
}

fn parse_abs_permutation(abs_permutation: &Value, scope: &SymbolTablePtr) -> Result<Expression> {
    let cycles = abs_permutation
        .as_array()
        .ok_or(error!("AbsLitPermutation is not an array"))?;

    let mut permutation: Vec<Vec<_>> = Vec::new();

    for cycle in cycles {
        let vals = cycle
            .as_array()
            .ok_or(error!("Cycle in AbsLitPermutation is not an array"))?;

        let exprs = vals
            .iter()
            .map(|values| parse_expression(values, scope))
            .collect::<Result<Vec<_>>>()?;

        permutation.push(exprs);
    }

    Ok(Expression::AbstractLiteral(
        Metadata::new(),
        AbstractLiteral::Permutation(permutation),
    ))
}

fn parse_abs_sequence(abs_seq: &Value, scope: &SymbolTablePtr) -> Result<Expression> {
    let values = abs_seq
        .as_array()
        .ok_or(error!("AbsLitSequence is not an array"))?;
    let expressions = values
        .iter()
        .map(|values| parse_expression(values, scope))
        .collect::<Result<Vec<_>>>()?;

    Ok(Expression::AbstractLiteral(
        Metadata::new(),
        AbstractLiteral::Sequence(expressions),
    ))
}

fn parse_abs_tuple(abs_tuple: &Value, scope: &SymbolTablePtr) -> Result<Expression> {
    let values = abs_tuple
        .as_array()
        .ok_or(error!("AbsLitTuple is not an array"))?;
    let expressions = values
        .iter()
        .map(|values| parse_expression(values, scope))
        .collect::<Result<Vec<_>>>()?;

    Ok(Expression::AbstractLiteral(
        Metadata::new(),
        AbstractLiteral::Tuple(expressions),
    ))
}

//parses an abstract record as an expression
fn parse_abs_record(abs_record: &Value, scope: &SymbolTablePtr) -> Result<Expression> {
    let entries = abs_record
        .as_array()
        .ok_or(error!("AbsLitRecord is not an array"))?;
    let mut rec = vec![];

    for entry in entries {
        let entry = entry
            .as_array()
            .ok_or(error!("AbsLitRecord entry is not an array"))?;
        let name = entry[0]
            .as_object()
            .ok_or(error!("AbsLitRecord field name is not an object"))?["Name"]
            .as_str()
            .ok_or(error!("AbsLitRecord field name is not a string"))?;

        let value = parse_expression(&entry[1], scope)?;

        let name = Name::User(Ustr::from(name));
        let rec_entry = Field {
            name: name.clone(),
            value,
        };
        rec.push(rec_entry);
    }

    Ok(Expression::AbstractLiteral(
        Metadata::new(),
        AbstractLiteral::Record(rec),
    ))
}

//parses an abstract variant as an expression
fn parse_abs_variant(abs_variant: &Value, scope: &SymbolTablePtr) -> Result<Expression> {
    let entry = abs_variant
        .as_array()
        .ok_or(error!("AbsLitVariant is not an array"))?;
    let name = entry[1]
        .as_object()
        .ok_or(error!("AbsLitVariant field name is not an object"))?["Name"]
        .as_str()
        .ok_or(error!("AbsLitVariant field name is not a string"))?;

    let value = parse_expression(&entry[2], scope)?;

    let name = Name::User(Ustr::from(name));
    let rec_entry = Field { name, value };

    Ok(Expression::AbstractLiteral(
        Metadata::new(),
        AbstractLiteral::Variant(Moo::new(rec_entry)),
    ))
}

//parses an abstract function as an expression
fn parse_abs_function(abs_function: &Value, scope: &SymbolTablePtr) -> Result<Expression> {
    let entries = abs_function
        .as_array()
        .ok_or(error!("AbsLitFunction is not an array"))?;
    let mut assignments = vec![];

    for entry in entries {
        let entry = entry
            .as_array()
            .ok_or(error!("Explicit function assignment is not an array"))?;
        let expression = entry
            .iter()
            .map(|values| parse_expression(values, scope))
            .collect::<Result<Vec<_>>>()?;
        let domain_value = expression
            .first()
            .ok_or(error!("Invalid function domain"))?;
        let codomain_value = expression
            .get(1)
            .ok_or(error!("Invalid function codomain"))?;
        let tuple = (domain_value.clone(), codomain_value.clone());
        assignments.push(tuple);
    }
    Ok(Expression::AbstractLiteral(
        Metadata::new(),
        AbstractLiteral::Function(assignments),
    ))
}

//parses an abstract relation as an expression
fn parse_abs_relation(abs_relation: &Value, scope: &SymbolTablePtr) -> Result<Expression> {
    let entries = abs_relation
        .as_array()
        .ok_or(error!("AbsLitRelation is not an array"))?;
    let mut assignments = vec![];

    for entry in entries {
        let entry = entry
            .as_array()
            .ok_or(error!("Explicit relation assignment is not an array"))?;
        let expression = entry
            .iter()
            .map(|values| parse_expression(values, scope))
            .collect::<Result<Vec<_>>>()?;
        assignments.push(expression);
    }
    Ok(Expression::AbstractLiteral(
        Metadata::new(),
        AbstractLiteral::Relation(assignments),
    ))
}

fn parse_comprehension(
    comprehension: &serde_json::Map<String, Value>,
    scope: SymbolTablePtr,
) -> Result<Expression> {
    let fail = |stage: &str| -> Error {
        Error::Parse(format!("Could not parse comprehension at stage `{stage}`"))
    };

    let value = &comprehension["Comprehension"];
    let mut comprehension = ComprehensionBuilder::new(scope.clone());
    let generator_symboltable = comprehension.generator_symboltable();
    let return_expr_symboltable = comprehension.return_expr_symboltable();

    let generators_and_guards_array = value
        .pointer("/1")
        .and_then(Value::as_array)
        .ok_or_else(|| fail("Comprehension.pointer(/1).as_array"))?;
    let generators_and_guards = generators_and_guards_array.iter();

    for gen_or_guard in generators_and_guards {
        let gen_or_guard_obj = gen_or_guard
            .as_object()
            .ok_or_else(|| fail("generator_or_guard.as_object"))?;
        let (name, inner) = gen_or_guard_obj
            .iter()
            .next()
            .ok_or_else(|| fail("generator_or_guard.iter().next"))?;
        comprehension = match name.as_str() {
            "Generator" => {
                // TODO: more things than GenDomainNoRepr and Single names here?
                let generator_obj = inner
                    .as_object()
                    .ok_or_else(|| fail("Generator.inner.as_object"))?;
                let (name, gen_inner) = generator_obj
                    .iter()
                    .next()
                    .ok_or_else(|| fail("Generator.inner.iter().next"))?;
                match name.as_str() {
                    "GenDomainNoRepr" => {
                        let name = gen_inner
                            .pointer("/0/Single/Name")
                            .and_then(Value::as_str)
                            .ok_or_else(|| {
                                fail("GenDomainNoRepr.pointer(/0/Single/Name).as_str")
                            })?;
                        let domain_obj = gen_inner
                            .pointer("/1")
                            .and_then(Value::as_object)
                            .ok_or_else(|| fail("GenDomainNoRepr.pointer(/1).as_object"))?;
                        let (domain_name, domain_value) = domain_obj
                            .iter()
                            .next()
                            .ok_or_else(|| fail("GenDomainNoRepr.domain.iter().next"))?;
                        let domain = parse_domain(
                            domain_name,
                            domain_value,
                            &mut generator_symboltable.write(),
                        )?;
                        comprehension.generator(DeclarationPtr::new_find(name.into(), domain))
                    }
                    "GenInExpr" => {
                        let name = gen_inner
                            .pointer("/0/Single/Name")
                            .and_then(Value::as_str)
                            .ok_or_else(|| {
                                fail("GenDomainNoRepr.pointer(/0/Single/Name).as_str")
                            })?;
                        let generator_expr = gen_inner
                            .pointer("/1")
                            .ok_or_else(|| fail("GenInExpr.pointer(/1)"))?;
                        let expr = parse_expression(generator_expr, &scope)
                            .map_err(|_| fail("GenInExpr.parse_expression"))?;
                        comprehension.expression_generator(name.into(), expr)
                    }
                    _ => {
                        bug!("unknown generator type inside comprehension {name}");
                    }
                }
            }

            "Condition" => {
                let expr = parse_expression(inner, &generator_symboltable)
                    .map_err(|_| fail("Condition.parse_expression"))?;
                comprehension.guard(expr)
            }

            x => {
                bug!("unknown field inside comprehension {x}");
            }
        }
    }

    let return_expr_value = value
        .pointer("/0")
        .ok_or_else(|| fail("Comprehension.pointer(/0)"))?;
    let expr = parse_expression(return_expr_value, &return_expr_symboltable)
        .map_err(|_| fail("Comprehension.return_expr.parse_expression"))?;

    Ok(Expression::Comprehension(
        Metadata::new(),
        Moo::new(comprehension.with_return_value(expr)),
    ))
}

fn unary_skip_operator(op_name: &str) -> Option<ACOperatorKind> {
    match op_name {
        "MkOpAnd" => Some(ACOperatorKind::And),
        "MkOpOr" => Some(ACOperatorKind::Or),
        "MkOpSum" => Some(ACOperatorKind::Sum),
        "MkOpProduct" => Some(ACOperatorKind::Product),
        // Not true AC operators (no universal identity element), but still need their own
        // skip-operator tag so a symbolic guard lowers correctly instead of silently substituting
        // Sum's identity (0).
        "MkOpMin" => Some(ACOperatorKind::Min),
        "MkOpMax" => Some(ACOperatorKind::Max),
        _ => None,
    }
}

fn set_comprehension_skip_operator(
    expr: Expression,
    skip_operator: Option<ACOperatorKind>,
) -> Expression {
    let Expression::Comprehension(meta, comprehension) = expr else {
        return expr;
    };
    if let Some(skip_operator) = skip_operator {
        let mut comprehension = Moo::unwrap_or_clone(comprehension);
        comprehension.skip_operator = Some(skip_operator);
        Expression::Comprehension(meta, Moo::new(comprehension))
    } else {
        Expression::Comprehension(meta, comprehension)
    }
}

fn parse_bin_op(
    bin_op: &serde_json::Map<String, Value>,
    scope: &SymbolTablePtr,
) -> Result<Expression> {
    // we know there is a single key value pair in this object
    // extract the value, ignore the key
    let (key, value) = bin_op
        .into_iter()
        .next()
        .ok_or(error!("Binary op object is empty"))?;

    let constructor = binary_operator(key.as_str())
        .ok_or(error!(format!("Unknown binary operator `{}`", key)))?;

    match &value {
        Value::Array(bin_op_args) if bin_op_args.len() == 2 => {
            let arg1 = parse_expression(&bin_op_args[0], scope)?;
            let arg2 = parse_expression(&bin_op_args[1], scope)?;

            // Conjure spells set difference with minus, so the operand types decide which of the
            // two it is -- the same choice the Essence parser makes.
            if key == "MkOpMinus"
                && (matches!(arg1.try_return_type(), Some(ReturnType::Set(_)))
                    || matches!(arg2.try_return_type(), Some(ReturnType::Set(_))))
            {
                return Ok(Expression::Difference(
                    Metadata::new(),
                    Moo::new(arg1),
                    Moo::new(arg2),
                ));
            }

            Ok(constructor(Metadata::new(), Moo::new(arg1), Moo::new(arg2)))
        }
        _ => Err(error!("Binary operator arguments are not a 2-array")),
    }
}

fn parse_table_op(
    op: &serde_json::Map<String, Value>,
    scope: &SymbolTablePtr,
) -> Result<Expression> {
    let args = op
        .get("MkOpTable")
        .ok_or(error!("MkOpTable missing"))?
        .as_array()
        .ok_or(error!("MkOpTable is not an array"))?;

    if args.len() != 2 {
        return Err(error!("MkOpTable arguments are not a 2-array"));
    }

    let tuple_expr = parse_expression(&args[0], scope)?;
    let allowed_rows_expr = parse_expression(&args[1], scope)?;

    let (tuple_elems, _) = tuple_expr
        .clone()
        .unwrap_matrix_unchecked()
        .ok_or(error!("MkOpTable first argument is not a matrix"))?;
    let (allowed_rows, _) = allowed_rows_expr
        .clone()
        .unwrap_matrix_unchecked()
        .ok_or(error!("MkOpTable second argument is not a matrix"))?;

    for row_expr in allowed_rows {
        let (row_elems, _) = row_expr
            .unwrap_matrix_unchecked()
            .ok_or(error!("MkOpTable row is not a matrix"))?;

        if row_elems.len() != tuple_elems.len() {
            return Err(error!("MkOpTable row width does not match tuple width"));
        }
    }

    Ok(Expression::Table(
        Metadata::new(),
        Moo::new(tuple_expr),
        Moo::new(allowed_rows_expr),
    ))
}

/// If LHS is a record/variant and RHS is a field name,
/// returns Ok(Some(record_expr, field_name)).
/// If LHS is any other type, return Ok(None).
fn parse_record_field(
    op_args: &[Value],
    scope: &SymbolTablePtr,
) -> Result<Option<(Expression, Name)>> {
    if op_args.len() != 2 {
        return Err(error!("Expected 2 arguments to record indexing operation"));
    }

    let lhs = parse_expression(&op_args[0], scope)?;
    match lhs.return_type() {
        // If indexing into a record, parse string field name
        // and check that such a field exists
        ReturnType::Record(ents) | ReturnType::Variant(ents) => {
            let field_name = parse_reference_name(&op_args[1])?;
            let has_name = ents.iter().any(|x| x.name.eq(&field_name));
            if !has_name {
                return Err(error!(format!(
                    "Unknown field `{field_name}` in record `{lhs}`"
                )));
            }
            Ok(Some((lhs, field_name)))
        }
        _ => Ok(None),
    }
}

fn parse_active_op(
    op: &serde_json::Map<String, Value>,
    scope: &SymbolTablePtr,
) -> Result<Expression> {
    // we know there is a single key value pair in this object
    // extract the value, ignore the key
    let (_, value) = op
        .into_iter()
        .next()
        .ok_or(error!("MkOpActive op object is empty"))?;

    let Value::Array(op_args) = &value else {
        return Err(error!("MkOpActive op array is not an array"));
    };
    let Some((lhs, rhs)) = parse_record_field(op_args, scope)? else {
        return Err(error!("MkOpActive op expected record or variant"));
    };
    Ok(Expression::Active(Metadata::new(), Moo::new(lhs), rhs))
}

fn parse_indexing_slicing_op(
    op: &serde_json::Map<String, Value>,
    scope: &SymbolTablePtr,
) -> Result<Expression> {
    // we know there is a single key value pair in this object
    // extract the value, ignore the key
    let (key, value) = op
        .into_iter()
        .next()
        .ok_or(error!("Indexing/Slicing op object is empty"))?;

    // we know that this is meant to be a mkopindexing, so anything that goes wrong from here is a
    // bug!

    // Conjure does a[1,2,3] as MkOpIndexing(MkOpIndexing(MkOpIndexing(a,3),2),1).
    //
    // And  a[1,..,3] as MkOpIndexing(MkOpSlicing(MkOpIndexing(a,3)),1).
    //
    // However, we want this in a flattened form: Index(a, [1,2,3])
    let mut target: Expression;
    let mut indices: Vec<Option<Expression>> = vec![];

    // true if this has no slicing, false otherwise.
    let mut all_known = true;

    match key.as_str() {
        "MkOpIndexing" => {
            match &value {
                Value::Array(op_args) if op_args.len() == 2 => {
                    target = parse_expression(&op_args[0], scope)?;

                    match parse_record_field(op_args, scope)? {
                        // For record indexing, generate nested RecordField exprs
                        Some((lhs, rhs)) => {
                            target = Expression::RecordField(Metadata::new(), Moo::new(lhs), rhs)
                        }
                        // Append any other indices to the flat list as normal
                        _ => indices.push(Some(parse_expression(&op_args[1], scope)?)),
                    }
                }
                _ => return Err(error!("Unknown object inside MkOpIndexing")),
            };
        }

        "MkOpSlicing" => {
            all_known = false;
            match &value {
                Value::Array(op_args) if op_args.len() == 3 => {
                    // NB: records can't be sliced into so no need to check!
                    target = parse_expression(&op_args[0], scope)?;
                    indices.push(None);
                }
                _ => return Err(error!("Unknown object inside MkOpSlicing")),
            };
        }

        _ => return Err(error!("Unknown indexing/slicing operator")),
    }

    loop {
        match &mut target {
            Expression::UnsafeIndex(_, new_target, new_indices) => {
                indices.extend(new_indices.iter().cloned().rev().map(Some));
                target = Moo::unwrap_or_clone(new_target.clone());
            }

            Expression::UnsafeSlice(_, new_target, new_indices) => {
                all_known = false;
                indices.extend(new_indices.iter().cloned().rev());
                target = Moo::unwrap_or_clone(new_target.clone());
            }

            _ => {
                // not a slice or an index, we have reached the target.
                break;
            }
        }
    }

    // If we had a record field and no other indices, the list will be empty
    if indices.is_empty() {
        return Ok(target);
    }

    indices.reverse();

    if all_known {
        Ok(Expression::UnsafeIndex(
            Metadata::new(),
            Moo::new(target),
            indices
                .into_iter()
                .collect::<Option<Vec<_>>>()
                .ok_or(error!("Missing index in fully-known indexing operation"))?,
        ))
    } else {
        Ok(Expression::UnsafeSlice(
            Metadata::new(),
            Moo::new(target),
            indices,
        ))
    }
}

// Parses relation projection, to get a Vec<Option<Expression>> for the projections
fn parse_relation_projection(
    op: &serde_json::Map<String, Value>,
    scope: &SymbolTablePtr,
) -> Result<Expression> {
    let args = op
        .get("MkOpRelationProj")
        .ok_or(error!("MkOpRelationProj missing"))?
        .as_array()
        .ok_or(error!("MkOpRelationProj is not an array"))?;
    let first = args
        .first()
        .ok_or(error!("MkOpRelationProj missing first argument"))?;
    let second = args
        .get(1)
        .ok_or(error!("MkOpRelationProj missing second argument"))?
        .as_array()
        .ok_or(error!("MkOpRelationProj second argument is not an array"))?;
    let relation = parse_expression(first, scope).ok();
    // We build a vec of option expressions.
    // In the case where a relation domain is not being projected it is None, otherwise it is Some with the expression
    // We parse the 'null' as an error, which is mapped to None after parse_expression()
    let projections = second
        .iter()
        .map(|expr| parse_expression(expr, scope).ok())
        .collect();
    if let Some(relation) = relation {
        Ok(Expression::RelationProj(
            Metadata::new(),
            Moo::new(relation),
            projections,
        ))
    } else {
        Err(error!("MkOpRelationProj does not contain relation"))
    }
}

// The ToSet operator is not truely a unary operator.
// The internal expression is 2nd in the array, with 'false' as the first element
// Therefore it needs separate parsing
fn parse_to_set(op: &serde_json::Map<String, Value>, scope: &SymbolTablePtr) -> Result<Expression> {
    let args = op
        .get("MkOpToSet")
        .ok_or(error!("MkOpToSet missing"))?
        .as_array()
        .ok_or(error!("MkOpToSet is not an array"))?;
    let second = args
        .get(1)
        .ok_or(error!("MkOpToSet missing second argument"))?;
    let inner = parse_expression(second, scope)?;
    Ok(Expression::ToSet(Metadata::new(), Moo::new(inner)))
}

fn parse_flatten_op(
    op: &serde_json::Map<String, Value>,
    scope: &SymbolTablePtr,
) -> Result<Expression> {
    let args = op
        .get("MkOpFlatten")
        .ok_or(error!("MkOpFlatten missing"))?
        .as_array()
        .ok_or(error!("MkOpFlatten is not an array"))?;

    let first = args
        .first()
        .ok_or(error!("MkOpFlatten missing first argument"))?;
    let second = args
        .get(1)
        .ok_or(error!("MkOpFlatten missing second argument"))?;
    let n = parse_expression(first, scope).ok();
    let matrix = parse_expression(second, scope)?;

    if let Some(n) = n {
        Ok(Expression::Flatten(
            Metadata::new(),
            Some(Moo::new(n)),
            Moo::new(matrix),
        ))
    } else {
        Ok(Expression::Flatten(Metadata::new(), None, Moo::new(matrix)))
    }
}

fn parse_unary_op(
    un_op: &serde_json::Map<String, Value>,
    scope: &SymbolTablePtr,
) -> Result<Expression> {
    let fail = |stage: &str| -> Error {
        Error::Parse(format!("Could not parse unary op at stage `{stage}`"))
    };

    let (key, value) = un_op
        .iter()
        .next()
        .ok_or_else(|| fail("un_op.iter().next"))?;

    // unops are the main things that contain comprehensions
    //
    // if the current expr is a quantifier like and/or/sum and it contains a comprehension, let the comprehension know what it is inside.
    let arg = match value {
        Value::Object(comprehension) if comprehension.contains_key("Comprehension") => {
            parse_comprehension(comprehension, scope.clone())
                .map_err(|_| fail("value.Comprehension.parse_comprehension"))
        }
        _ => parse_expression(value, scope).map_err(|_| fail("value.parse_expression")),
    }
    .map_err(|_| fail("arg"))?;

    let skip_operator = unary_skip_operator(key.as_str());
    let arg = set_comprehension_skip_operator(arg, skip_operator);

    let constructor =
        unary_operator(key.as_str(), Some(&arg)).ok_or_else(|| fail("unary_operator"))?;

    Ok(constructor(Metadata::new(), Moo::new(arg)))
}

// Takes in { AbstractLiteral: .... }
fn parse_abstract_matrix_as_expr(
    value: &serde_json::Value,
    scope: &SymbolTablePtr,
) -> Result<Expression> {
    parser_trace!("trying to parse an abstract literal matrix");
    let (values, domain_name, domain_value) =
        if let Some(abs_lit_matrix) = value.pointer("/AbstractLiteral/AbsLitMatrix") {
            parser_trace!(".. found JSON pointer /AbstractLiteral/AbstractLitMatrix");
            let (domain_name, domain_value) = abs_lit_matrix
                .pointer("/0")
                .and_then(Value::as_object)
                .and_then(|x| x.iter().next())
                .ok_or(error!("AbsLitMatrix missing domain"))?;
            let values = abs_lit_matrix
                .pointer("/1")
                .ok_or(error!("AbsLitMatrix missing values"))?;

            Some((values, domain_name, domain_value))
        }
        // the input of this expression is constant - e.g. or([]), or([false]), min([2]), etc.
        else if let Some(const_abs_lit_matrix) =
            value.pointer("/Constant/ConstantAbstract/AbsLitMatrix")
        {
            parser_trace!(".. found JSON pointer /Constant/ConstantAbstract/AbsLitMatrix");
            let (domain_name, domain_value) = const_abs_lit_matrix
                .pointer("/0")
                .and_then(Value::as_object)
                .and_then(|x| x.iter().next())
                .ok_or(error!("ConstantAbstract AbsLitMatrix missing domain"))?;
            let values = const_abs_lit_matrix
                .pointer("/1")
                .ok_or(error!("ConstantAbstract AbsLitMatrix missing values"))?;

            Some((values, domain_name, domain_value))
        } else if let Some(const_abs_lit_matrix) = value.pointer("/ConstantAbstract/AbsLitMatrix") {
            parser_trace!(".. found JSON pointer /ConstantAbstract/AbsLitMatrix");
            let (domain_name, domain_value) = const_abs_lit_matrix
                .pointer("/0")
                .and_then(Value::as_object)
                .and_then(|x| x.iter().next())
                .ok_or(error!("ConstantAbstract/AbsLitMatrix missing domain"))?;
            let values = const_abs_lit_matrix
                .pointer("/1")
                .ok_or(error!("ConstantAbstract/AbsLitMatrix missing values"))?;
            Some((values, domain_name, domain_value))
        } else {
            None
        }
        .ok_or(error!("Could not parse abstract literal matrix"))?;

    parser_trace!(".. found in domain and values in JSON:");
    parser_trace!(".. .. index domain name {domain_name}");
    parser_trace!(".. .. values {value}");

    let args_parsed = values
        .as_array()
        .ok_or(error!("Matrix values are not an array"))?
        .iter()
        .map(|x| parse_expression(x, scope))
        .collect::<Result<Vec<Expression>>>()?;

    if !args_parsed.is_empty() {
        parser_trace!(
            ".. successfully parsed values as expressions: {}, ... ",
            args_parsed[0]
        );
    } else {
        parser_trace!(".. successfully parsed empty values ",);
    }

    let mut symbols = scope.write();
    match parse_domain(domain_name, domain_value, &mut symbols) {
        Ok(domain) => {
            parser_trace!("... sucessfully parsed domain as {domain}");
            Ok(into_matrix_expr![args_parsed;domain])
        }
        Err(_) => {
            parser_trace!("... failed to parse domain, creating a matrix without one.");
            Ok(into_matrix_expr![args_parsed])
        }
    }
}

fn parse_constant(
    constant: &serde_json::Map<String, Value>,
    scope: &SymbolTablePtr,
) -> Result<Expression> {
    match &constant.get("Constant") {
        Some(Value::Object(int)) if int.contains_key("ConstantInt") => {
            let int_32: i32 = match int["ConstantInt"]
                .as_array()
                .ok_or(error!("ConstantInt is not an array"))?[1]
                .as_i64()
                .ok_or(error!("ConstantInt does not contain int"))?
                .try_into()
            {
                Ok(x) => x,
                Err(_) => return Err(error!("ConstantInt cannot be represented as i32")),
            };

            Ok(Expression::Atomic(
                Metadata::new(),
                Atom::Literal(Literal::Int(int_32)),
            ))
        }

        Some(Value::Object(b)) if b.contains_key("ConstantBool") => {
            let b: bool = b["ConstantBool"]
                .as_bool()
                .ok_or(error!("ConstantBool does not contain bool"))?;
            Ok(Expression::Atomic(
                Metadata::new(),
                Atom::Literal(Literal::Bool(b)),
            ))
        }

        Some(Value::Object(int)) if int.contains_key("ConstantAbstract") => {
            if let Some(Value::Object(obj)) = int.get("ConstantAbstract") {
                if let Some(arr) = obj.get("AbsLitSet") {
                    return parse_abs_lit(arr, scope);
                } else if let Some(arr) = obj.get("AbsLitMSet") {
                    return parse_abs_mset(arr, scope);
                } else if let Some(arr) = obj.get("AbsLitMatrix") {
                    return parse_abstract_matrix_as_expr(arr, scope);
                } else if let Some(arr) = obj.get("AbsLitTuple") {
                    return parse_abs_tuple(arr, scope);
                } else if let Some(arr) = obj.get("AbsLitRecord") {
                    return parse_abs_record(arr, scope);
                } else if let Some(arr) = obj.get("AbsLitPartition") {
                    return parse_abs_partition(arr, scope);
                } else if let Some(arr) = obj.get("AbsLitPermutation") {
                    return parse_abs_permutation(arr, scope);
                } else if let Some(arr) = obj.get("AbsLitFunction") {
                    return parse_abs_function(arr, scope);
                } else if let Some(arr) = obj.get("AbsLitVariant") {
                    return parse_abs_variant(arr, scope);
                } else if let Some(arr) = obj.get("AbsLitRelation") {
                    return parse_abs_relation(arr, scope);
                } else if let Some(arr) = obj.get("AbsLitSequence") {
                    return parse_abs_sequence(arr, scope);
                }
            }
            Err(error!("Unhandled ConstantAbstract literal type"))
        }

        // sometimes (e.g. constant matrices) we can have a ConstantInt / Constant bool that is
        // not wrapped in Constant
        None => {
            let int_expr = constant
                .get("ConstantInt")
                .and_then(|x| x.as_array())
                .and_then(|x| x[1].as_i64())
                .and_then(|x| x.try_into().ok())
                .map(|x| Expression::Atomic(Metadata::new(), Atom::Literal(Literal::Int(x))));

            if let Some(expr) = int_expr {
                return Ok(expr);
            }

            let bool_expr = constant
                .get("ConstantBool")
                .and_then(|x| x.as_bool())
                .map(|x| Expression::Atomic(Metadata::new(), Atom::Literal(Literal::Bool(x))));

            if let Some(expr) = bool_expr {
                return Ok(expr);
            }

            Err(error!(format!("Unhandled parse_constant {constant:#?}")))
        }
        otherwise => Err(error!(format!("Unhandled parse_constant {otherwise:#?}"))),
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::ast::HasDomain;
    use crate::{domain_int, range};
    use serde_json::json;

    #[test]
    fn parses_record_index() {
        let scope = SymbolTablePtr::new();
        scope.write().insert(DeclarationPtr::new_find(
            Name::user("x"),
            Domain::record(vec![Field {
                name: Name::user("a"),
                value: Domain::bool(),
            }]),
        ));

        let value = json!({
            "Op": {
                "MkOpIndexing": [
                    {
                        "Reference": [
                            {
                                "Name": "x"
                            },
                            null
                        ]
                    },
                    {
                        "Reference": [
                            {
                                "Name": "a"
                            },
                            null
                        ]
                    }
                ]
            }
        });

        let expr = parse_expression(&value, &scope).expect("record index should parse");
        let Expression::RecordField(_, rec_expr, field_name) = expr else {
            panic!("expected record field access");
        };
        let Expression::Atomic(_, Atom::Reference(re)) = rec_expr.as_ref() else {
            panic!("expected LHS to be a record reference");
        };
        assert_eq!(re.name().clone(), Name::user("x"));
        assert!(re.domain_of().as_record().is_some());
        assert_eq!(field_name, Name::user("a"));
    }

    #[test]
    fn parses_nested_constant_abstract_sets() {
        let scope = SymbolTablePtr::new();
        let value = json!({
            "ConstantAbstract": {
                "AbsLitSet": [
                    {
                        "ConstantAbstract": {
                            "AbsLitSet": [
                                { "ConstantInt": [{ "TagInt": [] }, 1] },
                                { "ConstantInt": [{ "TagInt": [] }, 2] }
                            ]
                        }
                    },
                    {
                        "ConstantAbstract": {
                            "AbsLitSet": [
                                { "ConstantInt": [{ "TagInt": [] }, 3] }
                            ]
                        }
                    }
                ]
            }
        });

        let expr = parse_expression(&value, &scope).expect("nested constant sets should parse");
        let Expression::AbstractLiteral(_, AbstractLiteral::Set(outer_values)) = expr else {
            panic!("expected an outer set literal");
        };
        assert_eq!(outer_values.len(), 2);
        assert!(outer_values.iter().all(|value| matches!(
            value,
            Expression::AbstractLiteral(_, AbstractLiteral::Set(_))
        )));
    }

    #[test]
    fn parses_abstract_literal_wrapped_partition_with_non_constant_elements() {
        // Conjure emits a partition literal under the bare `AbstractLiteral` wrapper (rather
        // than `Constant`/`ConstantAbstract`) whenever one of its elements is not itself a
        // constant, e.g. `partition({x,2},{y,4})` where x, y are decision variables. Captured
        // verbatim (modulo whitespace) from `conjure pretty --output-format=astjson` on such a
        // model.
        let scope = SymbolTablePtr::new();
        scope
            .write()
            .insert(DeclarationPtr::new_find(Name::user("x"), domain_int!(1..4)));
        scope
            .write()
            .insert(DeclarationPtr::new_find(Name::user("y"), domain_int!(1..4)));

        let value = json!({
            "AbstractLiteral": {
                "AbsLitPartition": [
                    [
                        { "Reference": [{ "Name": "x" }, null] },
                        { "Constant": { "ConstantInt": [{ "TagInt": [] }, 2] } }
                    ],
                    [
                        { "Reference": [{ "Name": "y" }, null] },
                        { "Constant": { "ConstantInt": [{ "TagInt": [] }, 4] } }
                    ]
                ]
            }
        });

        let expr = parse_expression(&value, &scope)
            .expect("AbstractLiteral-wrapped partition should parse");
        let Expression::AbstractLiteral(_, AbstractLiteral::Partition(parts)) = expr else {
            panic!("expected a partition literal, got {expr:?}");
        };
        assert_eq!(parts.len(), 2);
        assert_eq!(parts[0].len(), 2);
        assert_eq!(parts[1].len(), 2);
    }
}