#![allow(clippy::new_without_default)] // annotating structs annotated with #[bitfield] doesn't work

use crate::arena::*;
use crate::atom_table::*;
use crate::forms::PredicateKey;
use crate::machine::copier::*;
use crate::machine::heap::*;
use crate::machine::machine_indices::*;
use crate::machine::machine_state::*;
use crate::types::*;

use std::cell::{Ref, RefCell, RefMut};
use std::collections::VecDeque;
use std::fmt;
use std::hash::{Hash, Hasher};
use std::io::{Error as IOError, ErrorKind};
use std::ops::{Deref, Neg, RangeBounds};
use std::rc::Rc;
use std::sync::Arc;
use std::vec::Vec;

use crate::parser::dashu::{Integer, Rational};

use fxhash::FxBuildHasher;
use indexmap::IndexMap;
use scryer_modular_bitfield::error::OutOfBounds;
use scryer_modular_bitfield::prelude::*;

pub type Specifier = u32;

pub const MAX_ARITY: usize = 1023;

#[allow(clippy::upper_case_acronyms)]
#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub enum OpDeclSpec {
    XFX = 0x0001,
    XFY = 0x0002,
    YFX = 0x0004,
    XF = 0x0010,
    YF = 0x0020,
    FX = 0x0040,
    FY = 0x0080,
}

pub use OpDeclSpec::*;

impl OpDeclSpec {
    pub const fn value(self) -> u32 {
        self as u32
    }

    pub fn get_spec(self) -> Atom {
        match self {
            XFX => atom!("xfx"),
            XFY => atom!("xfy"),
            YFX => atom!("yfx"),
            FX => atom!("fx"),
            FY => atom!("fy"),
            XF => atom!("xf"),
            YF => atom!("yf"),
        }
    }

    pub const fn is_prefix(self) -> bool {
        matches!(self, Self::FX | Self::FY)
    }

    pub const fn is_postfix(self) -> bool {
        matches!(self, Self::XF | Self::YF)
    }

    pub const fn is_infix(self) -> bool {
        matches!(self, Self::XFX | Self::XFY | Self::YFX)
    }

    pub const fn is_strict_left(self) -> bool {
        matches!(self, Self::XFX | Self::XFY | Self::XF)
    }

    pub const fn is_strict_right(self) -> bool {
        matches!(self, Self::XFX | Self::YFX | Self::FX)
    }

    #[inline(always)]
    pub(crate) fn fixity(self) -> Fixity {
        match self {
            XFY | XFX | YFX => Fixity::In,
            XF | YF => Fixity::Post,
            FX | FY => Fixity::Pre,
        }
    }
}

impl From<OpDeclSpec> for u8 {
    fn from(value: OpDeclSpec) -> Self {
        value as u8
    }
}

impl From<OpDeclSpec> for u32 {
    fn from(value: OpDeclSpec) -> Self {
        value as u32
    }
}

impl TryFrom<u8> for OpDeclSpec {
    type Error = ();

    fn try_from(value: u8) -> Result<Self, Self::Error> {
        Ok(match value {
            0x0001 => XFX,
            0x0002 => XFY,
            0x0004 => YFX,
            0x0010 => XF,
            0x0020 => YF,
            0x0040 => FX,
            0x0080 => FY,
            _ => return Err(()),
        })
    }
}

impl TryFrom<Atom> for OpDeclSpec {
    type Error = ();

    fn try_from(value: Atom) -> Result<Self, Self::Error> {
        Ok(match value {
            atom!("xfx") => Self::XFX,
            atom!("xfy") => Self::XFY,
            atom!("yfx") => Self::YFX,
            atom!("fx") => Self::FX,
            atom!("fy") => Self::FY,
            atom!("xf") => Self::XF,
            atom!("yf") => Self::YF,
            _ => return Err(()),
        })
    }
}

pub const DELIMITER: u32 = 0x0100;
pub const TERM: u32 = 0x1000;
pub const LTERM: u32 = 0x3000;
pub const BTERM: u32 = 0x11000;

pub const NEGATIVE_SIGN: u32 = 0x0200;

macro_rules! fixnum {
    ($wrapper:tt, $n:expr, $arena:expr) => {
        Fixnum::build_with_checked($n)
            .map(<$wrapper>::Fixnum)
            .unwrap_or_else(|_| <$wrapper>::Integer(arena_alloc!(Integer::from($n), $arena)))
    };
}

macro_rules! is_term {
    ($x:expr) => {
        ($x as u32 & $crate::parser::ast::TERM) != 0 || is_negate!($x)
    };
}

macro_rules! is_lterm {
    ($x:expr) => {
        ($x as u32 & $crate::parser::ast::LTERM) != 0 || is_negate!($x)
    };
}

macro_rules! is_op {
    ($x:expr) => {
        $x as u32
            & ($crate::parser::ast::XF as u32
                | $crate::parser::ast::YF as u32
                | $crate::parser::ast::FX as u32
                | $crate::parser::ast::FY as u32
                | $crate::parser::ast::XFX as u32
                | $crate::parser::ast::XFY as u32
                | $crate::parser::ast::YFX as u32)
            != 0
    };
}

macro_rules! is_negate {
    ($x:expr) => {
        ($x as u32 & $crate::parser::ast::NEGATIVE_SIGN) != 0
    };
}

macro_rules! is_prefix {
    ($x:expr) => {
        $x as u32 & ($crate::parser::ast::FX as u32 | $crate::parser::ast::FY as u32) != 0
    };
}

macro_rules! is_infix {
    ($x:expr) => {
        ($x as u32
            & ($crate::parser::ast::XFX as u32
                | $crate::parser::ast::XFY as u32
                | $crate::parser::ast::YFX as u32))
            != 0
    };
}

macro_rules! is_xfx {
    ($x:expr) => {
        ($x as u32 & $crate::parser::ast::XFX as u32) != 0
    };
}

macro_rules! is_xfy {
    ($x:expr) => {
        ($x as u32 & $crate::parser::ast::XFY as u32) != 0
    };
}

macro_rules! is_yfx {
    ($x:expr) => {
        ($x as u32 & $crate::parser::ast::YFX as u32) != 0
    };
}
macro_rules! is_yf {
    ($x:expr) => {
        ($x as u32 & $crate::parser::ast::YF as u32) != 0
    };
}

macro_rules! is_xf {
    ($x:expr) => {
        ($x as u32 & $crate::parser::ast::XF as u32) != 0
    };
}

macro_rules! is_fx {
    ($x:expr) => {
        ($x as u32 & $crate::parser::ast::FX as u32) != 0
    };
}

macro_rules! is_fy {
    ($x:expr) => {
        ($x as u32 & $crate::parser::ast::FY as u32) != 0
    };
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum RegType {
    Perm(usize),
    Temp(usize),
}

impl Default for RegType {
    fn default() -> Self {
        RegType::Temp(0)
    }
}

impl RegType {
    pub fn reg_num(self) -> usize {
        match self {
            RegType::Perm(reg_num) | RegType::Temp(reg_num) => reg_num,
        }
    }

    pub fn is_perm(self) -> bool {
        matches!(self, RegType::Perm(_))
    }
}

impl fmt::Display for RegType {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            RegType::Perm(val) => write!(f, "Y{}", val),
            RegType::Temp(val) => write!(f, "X{}", val),
        }
    }
}

#[derive(Debug, PartialEq, Eq, Clone, Copy)]
pub enum VarReg {
    ArgAndNorm(RegType, usize),
    Norm(RegType),
}

impl VarReg {
    pub fn norm(self) -> RegType {
        match self {
            VarReg::ArgAndNorm(reg, _) | VarReg::Norm(reg) => reg,
        }
    }
}

impl fmt::Display for VarReg {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            VarReg::Norm(RegType::Perm(reg)) => write!(f, "Y{}", reg),
            VarReg::Norm(RegType::Temp(reg)) => write!(f, "X{}", reg),
            VarReg::ArgAndNorm(RegType::Perm(reg), arg) => write!(f, "Y{} A{}", reg, arg),
            VarReg::ArgAndNorm(RegType::Temp(reg), arg) => write!(f, "X{} A{}", reg, arg),
        }
    }
}

impl Default for VarReg {
    fn default() -> Self {
        VarReg::Norm(RegType::default())
    }
}

macro_rules! temp_v {
    ($x:expr) => {
        $crate::parser::ast::RegType::Temp($x)
    };
}

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum GenContext {
    Head,
    Mid(usize),
    Last(usize), // Mid & Last: chunk_num
}

impl GenContext {
    #[inline]
    pub fn chunk_num(self) -> usize {
        match self {
            GenContext::Head => 0,
            GenContext::Mid(cn) | GenContext::Last(cn) => cn,
        }
    }

    #[inline]
    pub fn is_last(self) -> bool {
        matches!(self, GenContext::Last(_))
    }
}

#[bitfield]
#[derive(Copy, Clone, Debug, PartialEq, Eq, Ord, PartialOrd, Hash)]
pub struct OpDesc {
    prec: B11,
    spec: B8,
    #[allow(unused)]
    padding: B13,
}

impl OpDesc {
    #[inline]
    pub fn build_with(prec: u16, spec: OpDeclSpec) -> Self {
        OpDesc::new().with_spec(spec as u8).with_prec(prec)
    }

    #[inline]
    pub fn get(self) -> (u16, OpDeclSpec) {
        (self.prec(), self.get_spec())
    }

    pub fn set(&mut self, prec: u16, spec: OpDeclSpec) {
        self.set_prec(prec);
        self.set_spec(spec as u8);
    }

    #[inline]
    pub fn get_prec(self) -> u16 {
        self.prec()
    }

    #[inline]
    pub fn get_spec(self) -> OpDeclSpec {
        OpDeclSpec::try_from(self.spec()).expect("OpDecl always contains a valud OpDeclSpec")
    }

    #[inline]
    pub fn arity(self) -> usize {
        if !self.get_spec().is_infix() {
            1
        } else {
            2
        }
    }
}

// name and fixity -> operator type and precedence.
pub type OpDir = IndexMap<(Atom, Fixity), OpDesc, FxBuildHasher>;

#[derive(Debug, Default, Clone, Copy)]
pub struct MachineFlags {
    pub double_quotes: DoubleQuotes,
    pub unknown: Unknown,
}

#[derive(Debug, Default, Clone, Copy, PartialEq)]
pub enum DoubleQuotes {
    Atom,
    #[default]
    Chars,
    Codes,
}

impl DoubleQuotes {
    pub fn is_chars(self) -> bool {
        matches!(self, DoubleQuotes::Chars)
    }

    pub fn is_codes(self) -> bool {
        matches!(self, DoubleQuotes::Codes)
    }
}

#[derive(Debug, Clone, Copy, Default)]
pub enum Unknown {
    #[default]
    Error,
    Fail,
    Warn,
}

pub fn default_op_dir() -> OpDir {
    let mut op_dir = OpDir::with_hasher(FxBuildHasher::default());

    op_dir.insert((atom!(":-"), Fixity::In), OpDesc::build_with(1200, XFX));
    op_dir.insert((atom!(":-"), Fixity::Pre), OpDesc::build_with(1200, FX));
    op_dir.insert((atom!("?-"), Fixity::Pre), OpDesc::build_with(1200, FX));
    op_dir.insert((atom!(","), Fixity::In), OpDesc::build_with(1000, XFY));

    op_dir
}

#[derive(Debug, Clone)]
pub enum ArithmeticError {
    NonEvaluableFunctor(Literal, usize),
    UninstantiatedVar,
}

#[derive(Debug, Copy, Clone, Default)]
pub struct ParserErrorSrc {
    pub col_num: usize,
    pub line_num: usize,
}

#[derive(Debug)]
pub enum ParserError {
    BackQuotedString(ParserErrorSrc),
    IO(IOError, ParserErrorSrc),
    IncompleteReduction(ParserErrorSrc),
    InfiniteFloat(ParserErrorSrc),
    InvalidSingleQuotedCharacter(char, ParserErrorSrc),
    LexicalError(lexical::Error, ParserErrorSrc),
    MissingQuote(ParserErrorSrc),
    NonPrologChar(ParserErrorSrc),
    ParseBigInt(ParserErrorSrc),
    UnexpectedChar(char, ParserErrorSrc),
    // UnexpectedEOF,
    Utf8Error(ParserErrorSrc),
}

impl ParserError {
    pub fn err_src(&self) -> ParserErrorSrc {
        match self {
            &ParserError::BackQuotedString(err_src)
            | &ParserError::IO(_, err_src)
            | &ParserError::IncompleteReduction(err_src)
            | &ParserError::InfiniteFloat(err_src)
            | &ParserError::InvalidSingleQuotedCharacter(_, err_src)
            | &ParserError::LexicalError(_, err_src)
            | &ParserError::MissingQuote(err_src)
            | &ParserError::NonPrologChar(err_src)
            | &ParserError::ParseBigInt(err_src)
            | &ParserError::UnexpectedChar(_, err_src)
            | &ParserError::Utf8Error(err_src) => err_src,
        }
    }

    pub fn as_atom(&self) -> Atom {
        match self {
            ParserError::BackQuotedString(..) => atom!("back_quoted_string"),
            ParserError::IncompleteReduction(..) => atom!("incomplete_reduction"),
            ParserError::InvalidSingleQuotedCharacter(..) => {
                atom!("invalid_single_quoted_character")
            }
	    ParserError::InfiniteFloat(..) => {
		atom!("infinite_float")
	    }
            ParserError::IO(e, _) if e.kind() == ErrorKind::UnexpectedEof => {
                atom!("unexpected_end_of_file")
            }
            ParserError::IO(e, _) if e.kind() == ErrorKind::InvalidData => {
                atom!("invalid_data")
            }
            ParserError::IO(..) => atom!("input_output_error"),
            ParserError::LexicalError(..) => atom!("lexical_error"),
            ParserError::MissingQuote(..) => atom!("missing_quote"),
            ParserError::NonPrologChar(..) => atom!("non_prolog_character"),
            ParserError::ParseBigInt(..) => atom!("cannot_parse_big_int"),
            ParserError::UnexpectedChar(..) => atom!("unexpected_char"),
            ParserError::Utf8Error(..) => atom!("utf8_conversion_error"),
        }
    }

    #[inline]
    pub fn unexpected_eof(err_src: ParserErrorSrc) -> Self {
        ParserError::IO(std::io::Error::from(ErrorKind::UnexpectedEof), err_src)
    }

    #[inline]
    pub fn is_unexpected_eof(&self) -> bool {
        if let ParserError::IO(e, _) = self {
            e.kind() == ErrorKind::UnexpectedEof
        } else {
            false
        }
    }
}
/*
impl From<lexical::Error> for ParserError {
    fn from((e, err_src): (lexical::Error, ParserErrorSrc)) -> ParserError {
        ParserError::LexicalError(e, err_src)
    }
}

impl From<IOError> for ParserError {
    fn from(e: IOError) -> ParserError {
        ParserError::IO(e)
    }
}

impl From<&IOError> for ParserError {
    fn from(error: &IOError) -> ParserError {
        if error.get_ref().filter(|e| e.is::<BadUtf8Error>()).is_some() {
            ParserError::Utf8Error(0, 0)
        } else {
            ParserError::IO(error.kind().into())
        }
    }
}
*/
#[derive(Debug, Clone, Copy)]
pub struct CompositeOpDir<'a, 'b> {
    pub primary_op_dir: Option<&'b OpDir>,
    pub secondary_op_dir: &'a OpDir,
}

impl<'a, 'b> CompositeOpDir<'a, 'b> {
    #[inline]
    pub fn new(secondary_op_dir: &'a OpDir, primary_op_dir: Option<&'b OpDir>) -> Self {
        CompositeOpDir {
            primary_op_dir,
            secondary_op_dir,
        }
    }

    #[inline]
    pub(crate) fn get(&self, name: Atom, fixity: Fixity) -> Option<OpDesc> {
        let entry = if let Some(primary_op_dir) = &self.primary_op_dir {
            primary_op_dir.get(&(name, fixity))
        } else {
            None
        };

        entry
            .or_else(move || self.secondary_op_dir.get(&(name, fixity)))
            .cloned()
    }
}

#[derive(Debug, Clone, Copy, Eq, Hash, PartialEq, PartialOrd, Ord)]
pub enum Fixity {
    In,
    Post,
    Pre,
}

#[bitfield]
#[repr(u64)]
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
pub struct Fixnum {
    num: B56,
    #[allow(unused)]
    f: bool,
    #[allow(unused)]
    m: bool,
    #[allow(unused)]
    tag: B6,
}

impl Fixnum {
    #[inline]
    pub fn build_with(num: i64) -> Self {
        Fixnum::new()
            .with_num(u64::from_ne_bytes(num.to_ne_bytes()) & ((1 << 56) - 1))
            .with_tag(HeapCellValueTag::Fixnum as u8)
            .with_m(false)
            .with_f(false)
    }

    #[inline]
    pub fn as_cutpoint(num: i64) -> Self {
        Fixnum::new()
            .with_num(u64::from_ne_bytes(num.to_ne_bytes()) & ((1 << 56) - 1))
            .with_tag(HeapCellValueTag::CutPoint as u8)
            .with_m(false)
            .with_f(false)
    }

    #[inline]
    pub fn get_tag(&self) -> HeapCellValueTag {
        use scryer_modular_bitfield::Specifier;
        HeapCellValueTag::from_bytes(self.tag()).unwrap()
    }

    #[inline]
    pub fn build_with_checked(num: i64) -> Result<Self, OutOfBounds> {
        const UPPER_BOUND: i64 = (1 << 55) - 1;
        const LOWER_BOUND: i64 = -(1 << 55);

        if (LOWER_BOUND..=UPPER_BOUND).contains(&num) {
            Ok(Fixnum::new()
                .with_m(false)
                .with_f(false)
                .with_tag(HeapCellValueTag::Fixnum as u8)
                .with_num(u64::from_ne_bytes(num.to_ne_bytes()) & ((1 << 56) - 1)))
        } else {
            Err(OutOfBounds {})
        }
    }

    #[inline]
    pub fn get_num(self) -> i64 {
        let n = self.num() as i64;
        let (n, overflowed) = (n << 8).overflowing_shr(8);
        debug_assert!(!overflowed);
        n
    }
}

impl Neg for Fixnum {
    type Output = Self;

    #[inline]
    fn neg(self) -> Self::Output {
        Fixnum::build_with(-self.get_num())
    }
}

#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum Literal {
    Atom(Atom),
    Char(char),
    CodeIndex(CodeIndex),
    Fixnum(Fixnum),
    Integer(TypedArenaPtr<Integer>),
    Rational(TypedArenaPtr<Rational>),
    Float(F64Offset),
    String(Atom),
}

impl From<F64Ptr> for Literal {
    #[inline(always)]
    fn from(ptr: F64Ptr) -> Literal {
        Literal::Float(ptr.as_offset())
    }
}

impl fmt::Display for Literal {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Literal::Atom(ref atom) => {
                write!(f, "{}", atom.flat_index())
            }
            Literal::Char(c) => write!(f, "'{}'", *c as u32),
            Literal::CodeIndex(i) => write!(f, "{:x}", i.as_ptr() as u64),
            Literal::Fixnum(n) => write!(f, "{}", n.get_num()),
            Literal::Integer(ref n) => write!(f, "{}", n),
            Literal::Rational(ref n) => write!(f, "{}", n),
            Literal::Float(ref n) => write!(f, "{}", *n),
            Literal::String(ref s) => write!(f, "\"{}\"", s.as_str()),
        }
    }
}

impl Literal {
    pub fn as_atom(&self, atom_tbl: &Arc<AtomTable>) -> Option<Atom> {
        match self {
            Literal::Atom(atom) => Some(atom.defrock_brackets(atom_tbl)),
            _ => None,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct VarPtr(Rc<RefCell<Var>>);

impl Hash for VarPtr {
    #[inline(always)]
    fn hash<H: Hasher>(&self, hasher: &mut H) {
        self.borrow().hash(hasher)
    }
}

impl Deref for VarPtr {
    type Target = RefCell<Var>;

    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        self.0.deref()
    }
}

impl VarPtr {
    #[inline]
    pub(crate) fn is_anon(&self) -> bool {
        match *self.borrow() {
            Var::Anon | Var::Generated { is_anon: true, .. } => true,
            _ => false,
        }
    }

    #[inline(always)]
    pub(crate) fn borrow(&self) -> Ref<'_, Var> {
        self.0.borrow()
    }

    #[inline(always)]
    pub(crate) fn borrow_mut(&self) -> RefMut<'_, Var> {
        self.0.borrow_mut()
    }

    pub(crate) fn to_var_num(&self) -> Option<usize> {
        match *self.borrow() {
            Var::Generated { var_num, .. } => Some(var_num),
            _ => None,
        }
    }

    pub(crate) fn set(&self, var: Var) {
        let mut var_ref = self.borrow_mut();
        *var_ref = var;
    }
}

impl From<Var> for VarPtr {
    #[inline(always)]
    fn from(value: Var) -> VarPtr {
        VarPtr(Rc::new(RefCell::new(value)))
    }
}

impl From<String> for VarPtr {
    #[inline(always)]
    fn from(value: String) -> VarPtr {
        VarPtr::from(Var::from(value))
    }
}

impl From<&str> for VarPtr {
    #[inline(always)]
    fn from(value: &str) -> VarPtr {
        VarPtr::from(value.to_owned())
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum Var {
    Anon,
    Generated { is_anon: bool, var_num: usize },
    InSitu(usize),
    Named(String),
}

impl From<String> for Var {
    #[inline(always)]
    fn from(value: String) -> Var {
        Var::Named(value)
    }
}

impl From<&str> for Var {
    #[inline(always)]
    fn from(value: &str) -> Var {
        Var::Named(value.to_owned())
    }
}

impl Var {
    #[allow(clippy::inherent_to_string)]
    #[inline(always)]
    pub fn to_string(&self) -> String {
        match self {
            Var::Anon => "_".to_owned(),
            Var::InSitu(var_num) | Var::Generated { var_num, .. } => format!("_{}", var_num),
            Var::Named(value) => value.to_owned(),
        }
    }
}

pub(crate) fn subterm_index(heap: &[HeapCellValue], subterm_loc: usize) -> (usize, HeapCellValue) {
    let subterm = heap[subterm_loc];

    if subterm.is_ref() {
        let subterm = heap_bound_deref(heap, subterm);
        let subterm_loc = subterm.get_value() as usize;
        let subterm = heap_bound_store(heap, subterm);

        let subterm_loc = if subterm.is_ref() {
            subterm.get_value() as usize
        } else {
            subterm_loc
        };

        (subterm_loc, subterm)
    } else {
        (subterm_loc, subterm)
    }
}

/*
#[derive(Debug, Clone)]
pub enum Term {
    AnonVar,
    Clause(Cell<RegType>, Atom, Vec<Term>),
    Cons(Cell<RegType>, Box<Term>, Box<Term>),
    Literal(Cell<RegType>, Literal),
    // PartialString wraps a String in anticipation of it absorbing
    // other PartialString variants in as_partial_string.
    PartialString(Cell<RegType>, String, Box<Term>),
    CompleteString(Cell<RegType>, Atom),
    Var(Cell<VarReg>, VarPtr),
}

impl Term {
    pub fn first_arg(&self) -> Option<&Term> {
        match self {
            Term::Clause(_, _, ref terms) => terms.first(),
            _ => None,
        }
    }

    pub fn name(&self) -> Option<Atom> {
        match self {
            &Term::Literal(_, Literal::Atom(ref atom)) | &Term::Clause(_, ref atom, ..) => {
                Some(*atom)
            }
            _ => None,
        }
    }

    pub fn arity(&self) -> usize {
        match self {
            Term::Clause(_, _, ref child_terms, ..) => child_terms.len(),
            _ => 0,
        }
    }
}

pub(crate) fn unfold_by_str_once(term: &mut Term, s: Atom) -> Option<(Term, Term)> {
    if let Term::Clause(_, ref name, ref mut subterms) = term {
        if let Some(Term::Literal(_, Literal::CodeIndex(_))) = subterms.last() {
            subterms.pop();
        }

        if name == &s && subterms.len() == 2 {
            let snd = subterms.pop().unwrap();
            let fst = subterms.pop().unwrap();

            return Some((fst, snd));
        }
    }

    None
}

pub fn unfold_by_str(mut term: Term, s: Atom) -> Vec<Term> {
    let mut terms = vec![];

    while let Some((fst, snd)) = unfold_by_str_once(&mut term, s) {
        terms.push(fst);
        term = snd;
    }

    terms.push(term);
    terms
}
 */

pub(crate) fn fetch_index_ptr(
    heap: &[HeapCellValue],
    arity: usize,
    term_loc: usize,
) -> Option<CodeIndex> {
    if term_loc + arity + 1 >= heap.len() {
        return None;
    }

    read_heap_cell!(heap[term_loc + arity + 1],
        (HeapCellValueTag::Cons, c) => {
            match_untyped_arena_ptr!(c,
               (ArenaHeaderTag::IndexPtr, ptr) => {
                   return Some(CodeIndex::from(ptr));
               }
               _ => {}
            );
        }
        _ => {}
    );

    None
}

pub(crate) fn blunt_index_ptr(
    heap: &mut [HeapCellValue],
    key: PredicateKey,
    term_loc: usize,
) -> bool {
    if fetch_index_ptr(heap, key.1, term_loc).is_some() {
        heap[term_loc] = atom_as_cell!(key.0, key.1);
        true
    } else {
        false
    }
}

pub(crate) fn unfold_by_str_once(
    heap: &mut [HeapCellValue],
    start_term: HeapCellValue,
    atom: Atom,
) -> Option<usize> {
    let start_term = heap_bound_store(
        heap,
        heap_bound_deref(heap, start_term),
    );

    if let HeapCellValueTag::Str = start_term.get_tag() {
        let s = start_term.get_value() as usize;

        let (s_atom, s_arity) = cell_as_atom_cell!(heap[s]).get_name_and_arity();
        blunt_index_ptr(heap, (s_atom, s_arity), s);

        if (s_atom, s_arity) == (atom, 2) {
            return Some(s+1);
        }
    }

    None
}

pub fn unfold_by_str(
    heap: &mut [HeapCellValue],
    mut start_term: HeapCellValue,
    atom: Atom,
) -> Vec<HeapCellValue> {
    let mut terms = vec![];
    start_term = heap_bound_store(heap, heap_bound_deref(heap, start_term));

    while let Some(fst_loc) = unfold_by_str_once(heap, start_term, atom) {
        let (_, snd) = subterm_index(heap, fst_loc + 1);
        let (_, fst) = subterm_index(heap, fst_loc);
        terms.push(fst);
        start_term = snd;
    }

    terms
}

/*
pub fn unfold_by_str_locs(
    heap: &mut [HeapCellValue],
    mut term_loc: usize,
    atom: Atom,
) -> Vec<(HeapCellValue, usize)> {
    let mut terms = vec![];
    let mut current_term = heap_bound_store(
        heap,
        heap_bound_deref(heap, heap[term_loc]),
    );

    while let Some(fst_loc) = unfold_by_str_once(heap, current_term, atom) {
        (term_loc, current_term) = subterm_index(heap, fst_loc + 1);
        let (fst_loc, fst) = subterm_index(heap, fst_loc);
        terms.push((fst, fst_loc));
    }

    terms.push((current_term, term_loc));
    terms
}
*/

pub fn unfold_by_str_locs(
    heap: &mut [HeapCellValue],
    mut term_loc: usize,
    atom: Atom,
) -> Vec<(HeapCellValue, usize)> {
    let mut terms = vec![];
    let mut current_term = heap[term_loc];

    while let Some(fst_loc) = unfold_by_str_once(heap, current_term, atom) {
        term_loc = fst_loc+1;
        current_term = heap[term_loc];
        let fst = heap[fst_loc];
        terms.push((fst, fst_loc));
    }

    terms.push((current_term, term_loc));
    terms
}

pub fn term_name(heap: &[HeapCellValue], mut term_loc: usize) -> Option<Atom> {
    loop {
        read_heap_cell!(heap[term_loc],
            (HeapCellValueTag::Atom, (name, _arity)) => {
                return Some(name);
            }
            (HeapCellValueTag::Str, s) => {
                term_loc = s;
            }
            (HeapCellValueTag::AttrVar | HeapCellValueTag::Var, h) => {
                if h != term_loc {
                    term_loc = h;
                } else {
                    return None;
                }
            }
            _ => {
                return None;
            }
        );
    }
}

pub fn term_arity(heap: &[HeapCellValue], mut term_loc: usize) -> usize {
    loop {
        read_heap_cell!(heap[term_loc],
            (HeapCellValueTag::Atom, (_name, arity)) => {
                return arity;
            }
            (HeapCellValueTag::Str, s) => {
                term_loc = s;
            }
            (HeapCellValueTag::Lis) => {
                return 2;
            }
            (HeapCellValueTag::AttrVar | HeapCellValueTag::Var, h) => {
                if h != term_loc {
                    term_loc = h;
                } else {
                    return 0;
                }
            }
            _ => {
                return 0;
            }
        );
    }
}

pub fn var_locs_from_iter<I: Iterator<Item = HeapCellValue>>(iter: I) -> VarLocs {
    let mut occurrence_set: IndexMap<HeapCellValue, usize, FxBuildHasher> =
        IndexMap::with_hasher(FxBuildHasher::default());

    for term in iter {
        if term.is_var() {
            let var_count = occurrence_set.entry(term).or_insert(0);
            *var_count += 1;
        }
    }

    VarLocs(
        occurrence_set
        .into_iter()
        .map(|(var, count)| {
            let key = var.get_value() as usize;
            let queue = if count > 1 {
                (0 .. count).map(|_| VarPtr::from(format!("_{}", key))).collect()
            } else {
                (0 .. count).map(|_| VarPtr::from(Var::Anon)).collect()
            };

            (key, queue)
        })
        .collect()
    )
}

/*
pub fn term_deref(heap: &[HeapCellValue], mut term_loc: usize) -> HeapCellValue {
    loop {
        read_heap_cell!(heap[term_loc],
            (HeapCellValueTag::AttrVar | HeapCellValueTag::Var, h) => {
                if h != term_loc {
                    term_loc = h;
                } else {
                    return heap[h];
                }
            }
            _ => {
                return heap[term_loc];
            }
        )
    }
}
*/

pub fn term_nth_arg(heap: &[HeapCellValue], mut term_loc: usize, n: usize) -> Option<usize> {
    loop {
        read_heap_cell!(heap[term_loc],
            (HeapCellValueTag::Str, s) => {
                return if cell_as_atom_cell!(heap[s]).get_arity() >= n {
                    Some(s+n)
                } else {
                    None
                };
            }
            (HeapCellValueTag::Atom, (_name, arity)) => {
                return if arity >= n {
                    Some(term_loc + n)
                } else {
                    None
                };
            }
            (HeapCellValueTag::Lis, l) => {
                return if 1 <= n && n <= 2 {
                    Some(l+n-1)
                } else if n == 0 {
                    Some(term_loc)
                } else {
                    None
                };
            }
            (HeapCellValueTag::AttrVar | HeapCellValueTag::Var, h) => {
                if h != term_loc {
                    term_loc = h;
                } else {
                    return None;
                }
            }
            _ => {
                return None;
            }
        );
    }
}

pub type VarNamesToLocs = IndexMap<String, HeapCellValue, FxBuildHasher>;

#[derive(Debug, Default)]
pub struct VarLocs(IndexMap<usize, VecDeque<VarPtr>, FxBuildHasher>);

impl VarLocs {
    pub fn get(&self, key: usize) -> Option<&VarPtr> {
        self.0.get(&key)
            .and_then(|queue| {
                queue.front()
            })
    }

    // if a queue of VarPtr's is stored at location key, pop the front
    // if it exists and pass it along to wrapper, returning a value of
    // type R. A return value of None indicates that the key doesn't
    // exist (the map containing a key necessarily means its queue
    // value is non-empty).
    fn rotate_latest_mut<R>(
        &mut self,
        key: usize,
        wrapper: impl FnOnce(&VarPtr) -> R,
    ) -> Option<R> {
        self.0.get_mut(&key)
            .and_then(move |queue| {
                if let Some(var_ptr) = queue.pop_front() {
                    let result = wrapper(&var_ptr);
                    queue.push_back(var_ptr);
                    Some(result)
                } else {
                    None
                }
            })
    }

    pub fn peek_next_var_ptr_at_key(&self, key: usize) -> Option<&VarPtr> {
        self.0.get(&key).and_then(|queue| queue.front())
    }

    pub fn read_next_var_ptr_at_key(&mut self, key: usize) -> Option<VarPtr> {
        self.rotate_latest_mut(key, VarPtr::clone)
    }

    pub fn push_at_key(&mut self, key: usize, var_ptr: VarPtr) {
        let entry = self.0.entry(key).or_default();
        entry.push_back(var_ptr);
    }

    #[inline]
    pub fn iter(&self) -> impl Iterator<Item = (usize, &VecDeque<VarPtr>)> {
        self.0.iter().map(|(&k, v)| (k, v))
    }

    #[inline]
    pub fn is_empty(&self) -> bool {
        self.0.is_empty()
    }

    #[inline]
    pub fn drain<R>(&mut self, range: R) -> indexmap::map::Drain<usize, VecDeque<VarPtr>>
        where R: RangeBounds<usize>
    {
        self.0.drain(range)
    }

    #[inline]
    pub fn insert(&mut self, key: usize, var_ptrs: VecDeque<VarPtr>) {
        self.0.insert(key, var_ptrs);
    }
}

#[derive(Debug)]
pub struct FocusedHeap {
    pub heap: Vec<HeapCellValue>,
    pub focus: usize,
    pub var_locs: VarLocs,
}

impl FocusedHeap {
    pub fn empty() -> Self {
        Self {
            heap: vec![],
            focus: 0,
            var_locs: VarLocs::default(),
        }
    }

    pub fn copy_term_from_machine_heap(
        &mut self,
        machine_st: &mut MachineState,
        cell: HeapCellValue,
    ) {
        let hb = machine_st.heap.len();

        copy_term(
            CopyBallTerm::new(
                &mut machine_st.attr_var_init.attr_var_queue,
                &mut machine_st.stack,
                &mut machine_st.heap,
                &mut self.heap,
            ),
            cell,
            AttrVarPolicy::DeepCopy,
        );

        for cell in self.heap.iter_mut() {
            *cell = *cell - hb;
        }
    }

    pub fn as_ref_mut(&mut self, focus: usize) -> FocusedHeapRefMut {
        FocusedHeapRefMut {
            heap: &mut self.heap,
            focus,
            // var_locs: &self.var_locs,
        }
    }

    pub fn deref_loc(&self, term_loc: usize) -> HeapCellValue {
        use crate::machine::heap::*;

        let cell = self.heap[term_loc];
        heap_bound_store(&self.heap, heap_bound_deref(&self.heap, cell))
    }

    pub fn name(&self, term_loc: usize) -> Option<Atom> {
        term_name(&self.heap, term_loc)
    }

    pub fn arity(&self, term_loc: usize) -> usize {
        term_arity(&self.heap, term_loc)
    }

    pub fn nth_arg(&self, term_loc: usize, n: usize) -> Option<usize> {
        term_nth_arg(&self.heap, term_loc, n)
    }
}

pub struct FocusedHeapRefMut<'a> {
    pub heap: &'a mut Vec<HeapCellValue>,
    pub focus: usize,
}

impl<'a> FocusedHeapRefMut<'a> {
    pub fn name(&self, term_loc: usize) -> Option<Atom> {
        term_name(&self.heap, term_loc)
    }

    pub fn arity(&self, term_loc: usize) -> usize {
        term_arity(&self.heap, term_loc)
    }

    pub fn deref_loc(&self, term_loc: usize) -> HeapCellValue {
        use crate::machine::heap::*;

        let cell = self.heap[term_loc];
        heap_bound_store(&self.heap, heap_bound_deref(&self.heap, cell))
    }

    pub fn nth_arg(&self, term_loc: usize, n: usize) -> Option<usize> {
        term_nth_arg(self.heap, term_loc, n)
    }

    pub fn from_cell(heap: &'a mut Vec<HeapCellValue>, cell: HeapCellValue) -> Self {
        let focus = read_heap_cell!(cell,
            (HeapCellValueTag::AttrVar | HeapCellValueTag::Var, h) => {
                h
            }
            _ => {
                let h = heap.len();
                heap.push(cell);

                h
            }
        );

        Self { heap, focus }
    }
}