//! The symbol table.

//!

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

use crate::bug;

use crate::representation::{Representation, get_repr_rule};

use super::comprehension::Comprehension;

use super::serde::RcRefCellAsId;

use std::cell::RefCell;

use std::collections::BTreeSet;

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

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

use std::hash::{Hash, Hasher};

use std::rc::Rc;

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

use super::declaration::{DeclarationPtr, serde::DeclarationPtrFull};

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

use itertools::{Itertools as _, izip};

use serde::{Deserialize, Serialize};

use serde_with::serde_as;

use uniplate::Tree;

use uniplate::{Biplate, Uniplate};

use super::name::Name;

use super::{DomainPtr, Expression, GroundDomain, Moo, ReturnType, SubModel, Typeable};

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]

#[derive(Serialize, Deserialize)]

pub struct SymbolTable {

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

    table: BTreeMap<Name, DeclarationPtr>,

    /// 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 Hash for SymbolTable {

}

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.

    ///

    /// This method can return domain references: if a ground domain is always required, use

    /// [`SymbolTable::resolve_domain`].

        } else {

        }

    /// Looks up the domain of name, resolving domain references to ground domains.

    ///

    /// See [`SymbolTable::domain`].

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

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

    /// necessary.

            }

    /// Creates a new variable in this symbol table with a unique name, and returns its

    /// declaration.

    /// Gets the parent of this symbol table as a mutable reference.

    ///

    /// This function provides no sanity checks.

    /// Gets the representation `representation` for `name`.

    ///

    /// # Returns

    ///

    /// + `None` if `name` does not exist, is not a decision variable, or does not have that representation.

        // TODO: move representation stuff to declaration / variable to avoid cloning? (we have to

        // move inside of an rc here, so cannot return borrows)

        //

        // Also would prevent constant "does exist" "is var" checks.

        //

        // The reason it is not there now is because I'm getting serde issues...

        //

        // Also might run into issues putting get_or_add into declaration/variable, as that

        // requires us to mutably borrow both the symbol table, and the variable inside the symbol

        // table..

    /// Gets all initialised representations for `name`.

    ///

    /// # Returns

    ///

    /// + `None` if `name` does not exist, or is not a decision variable.

    /// Gets the representation `representation` for `name`, creating it if it does not exist.

    ///

    /// If the representation does not exist, this method initialises the representation in this

    /// symbol table, adding the representation to `name`, and the declarations for the represented

    /// variables to the symbol table.

    ///

    /// # Usage

    ///

    /// Representations for variable references should be selected and created by the

    /// `select_representation` rule. Therefore, this method should not be used in other rules.

    /// Consider using [`get_representation`](`SymbolTable::get_representation`) instead.

    ///

    /// # Returns

    ///

    /// + `None` if `name` does not exist, is not a decision variable, or cannot be given that

    ///   representation.

        // Lookup the declaration reference

        {

        // Representation not found

        // TODO: nested representations logic...

            bug!("nested representations not implemented")

        // Get mutable access to the variable part

        }

}

impl IntoIterator for SymbolTable {

    type Item = (Name, DeclarationPtr);

    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, DeclarationPtr>,

}

impl Iterator for LocalIntoIter {

    type Item = (Name, DeclarationPtr);

}

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

pub struct IntoIter {

    // iterator over the current scopes' btreemap

    inner: std::collections::btree_map::IntoIter<Name, DeclarationPtr>,

    // the parent scope

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

}

impl Iterator for IntoIter {

    type Item = (Name, DeclarationPtr);

        // 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 {

        Self {

        }

}

impl Default for SymbolTable {

}

impl Uniplate for SymbolTable {

        // do not recurse up parents, that would be weird?

}

impl Biplate<Expression> for SymbolTable {

            };

                // update declaration inside the pointer instead of creating a new one, so all

                // things referencing this keep referencing this.

            }

}

impl Biplate<Comprehension> for SymbolTable {

            // 1. turn comprehension tree into a list of expressions

            // 2. turn list of expressions into an expression tree

            // 3. turn expression tree into a symbol table

}

impl Biplate<SubModel> for SymbolTable {

    // walk into expressions

            // 1. turn submodel tree into a list of expressions

            // 2. turn list of expressions into an expression tree

            // 3. turn expression tree into a symbol table

}