//! The symbol table.

//!

//! See the item documentation for [`SymbolTable`] for more details.

use super::serde::{RcRefCellAsId, RcRefCellAsInner};

use std::cell::RefCell;

use std::collections::btree_map::Entry;

use std::collections::BTreeSet;

use std::collections::{BTreeMap, VecDeque};

use std::rc::Rc;

use std::sync::atomic::{AtomicU32, Ordering};

use super::declaration::Declaration;

use super::serde::{DefaultWithId, HasId, ObjId};

use super::types::Typeable;

use itertools::izip;

use serde::{Deserialize, Serialize};

use serde_with::serde_as;

use uniplate::Tree;

use uniplate::{Biplate, Uniplate};

use super::name::Name;

use super::{Domain, Expression, ReturnType};

use derivative::Derivative;

// Count symbol tables per thread / model.

//

// We run tests in parallel and having the id's be per thread keeps them more deterministic in the

// JSON output. If this were not thread local, ids would be given to symbol tables differently in

// each test run (depending on how the threads were scheduled). These id changes would result in

// all the generated tests "changing" each time `ACCEPT=true cargo test` is ran.

//

// SAFETY: Symbol tables use Rc<RefCell<<>>, so a model is not thread-safe anyways.

thread_local! {

static ID_COUNTER: AtomicU32 = const { AtomicU32::new(0) };

}

/// The global symbol table, mapping names to their definitions.

///

/// Names in the symbol table are unique, including between different types of object stored in the

/// symbol table. For example, you cannot have a letting and decision variable with the same name.

///

/// # Symbol Kinds

///

/// The symbol table tracks the following types of symbol:

///

/// ## Decision Variables

///

/// ```text

/// find NAME: DOMAIN

/// ```

///

/// See [`DecisionVariable`](super::DecisionVariable).

///

/// ## Lettings

///

/// Lettings define constants, of which there are two types:

///

///   + **Constant values**: `letting val be A`, where A is an [`Expression`].

///

///     A can be any integer, boolean, or matrix expression.

///     A can include references to other lettings, model parameters, and, unlike Savile Row,

///     decision variables.

///

///   + **Constant domains**: `letting Domain be domain D`, where D is a [`Domain`].

///

///     D can include references to other lettings and model parameters, and, unlike Savile Row,

///     decision variables.

///

/// Unless otherwise stated, these follow the semantics specified in section 2.2.2 of the Savile

/// Row manual (version 1.9.1 at time of writing).

#[derive(Derivative)]

#[derivative(PartialEq)]

#[derive(Debug, Eq)]

#[serde_as]

pub struct SymbolTable {

    #[serde_as(as = "Vec<(_,RcRefCellAsInner)>")]

    table: BTreeMap<Name, Rc<Declaration>>,

    /// A unique id for this symbol table, for serialisation and debugging.

    #[derivative(PartialEq = "ignore")] // eq by value not id.

    id: ObjId,

    #[serde_as(as = "Option<RcRefCellAsId>")]

    parent: Option<Rc<RefCell<SymbolTable>>>,

    next_machine_name: RefCell<i32>,

}

impl SymbolTable {

    /// Creates an empty symbol table.

    /// Creates an empty symbol table with the given parent.

    /// Looks up the declaration with the given name in the current scope only.

    ///

    /// Returns `None` if there is no declaration with that name in the current scope.

    /// Looks up the declaration with the given name, checking all enclosing scopes.

    ///

    /// Returns `None` if there is no declaration with that name in scope.

    /// Inserts a declaration into the symbol table.

    ///

    /// Returns `None` if there is already a symbol with this name in the local scope.

        } else {

        }

    /// Updates or adds a declaration in the immediate local scope.

    /// Looks up the return type for name if it has one and is in scope.

    /// Looks up the return type for name if has one and is in the local scope.

    /// Looks up the domain of name if it has one and is in scope.

        // TODO: do not clone here: in the future, we might want to wrap all domains in Rc's to get

        // clone-on-write behaviour (saving memory in scenarios such as matrix decomposition where

        // a lot of the domains would be the same).

    /// Iterates over entries in the local symbol table only.

    /// Extends the symbol table with the given symbol table, updating the gensym counter if

    /// necessary.

                    }

                }

            }

    /// Returns an arbitrary variable name that is not in the symbol table.

}

impl IntoIterator for SymbolTable {

    type Item = (Name, Rc<Declaration>);

    type IntoIter = IntoIter;

    /// Iterates over symbol table entries in scope.

}

/// Iterator over symbol table entries in the current scope only.

pub struct LocalIntoIter {

    // iterator over the btreemap

    inner: std::collections::btree_map::IntoIter<Name, Rc<Declaration>>,

}

impl Iterator for LocalIntoIter {

    type Item = (Name, Rc<Declaration>);

}

/// Iterator over all symbol table entries in scope.

pub struct IntoIter {

    // iterator over the current scopes' btreemap

    inner: std::collections::btree_map::IntoIter<Name, Rc<Declaration>>,

    // the parent scope

    parent: Option<Rc<RefCell<SymbolTable>>>,

}

impl Iterator for IntoIter {

    type Item = (Name, Rc<Declaration>);

        // Go up the tree until we find a parent symbol table with declarations to iterate over.

        //

        // Note that the parent symbol table may be empty - this is why this is a loop!

        }

}

impl HasId for SymbolTable {

}

impl DefaultWithId for SymbolTable {

}

impl Clone for SymbolTable {

}

impl Default for SymbolTable {

}

impl Uniplate for SymbolTable {

}

impl Biplate<Expression> for SymbolTable {

            };

}