//! The symbol table.

//!

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

use crate::bug;

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

use std::any::TypeId;

use std::collections::BTreeSet;

use std::collections::VecDeque;

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

use std::sync::Arc;

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

use super::comprehension::Comprehension;

use super::serde::{AsId, DefaultWithId, HasId, IdPtr, ObjId, PtrAsInner};

use super::{

    DeclarationPtr, DomainPtr, Expression, GroundDomain, Model, Moo, Name, ReturnType, Typeable,

};

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

use parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard};

use serde::{Deserialize, Serialize};

use serde_with::serde_as;

use tracing::trace;

use uniplate::{Biplate, Tree, Uniplate};

use indexmap::IndexMap;

use indexmap::map::Entry;

/// Global counter of symbol tables.

/// Note that the counter is shared between all threads

/// Thus, when running multiple models in parallel, IDs may

/// be different with every run depending on scheduling order

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

#[derive(Debug, Clone, PartialEq, Eq, Hash)]

pub struct SymbolTablePtr

where

    Self: Send + Sync,

{

    inner: Arc<SymbolTablePtrInner>,

}

impl SymbolTablePtr {

    /// Create an empty new [SymbolTable] and return a shared pointer to it

    /// Create an empty new [SymbolTable] with the given parent and return a shared pointer to it

    /// Read the underlying symbol table.

    /// This will block the current thread until a read lock can be acquired.

    ///

    /// # WARNING

    ///

    /// - If the current thread already holds a lock over this table, this may deadlock.

    /// Mutate the underlying symbol table.

    /// This will block the current thread until an exclusive write lock can be acquired.

    ///

    /// # WARNING

    ///

    /// - If the current thread already holds a lock over this table, this may deadlock.

    /// - Trying to acquire any other lock until the write lock is released will cause a deadlock.

    /// - This will mutate the underlying data, which may be shared between other `SymbolTablePtr`s.

    ///   Make sure that this is what you want.

    ///

    /// To create a separate copy of the table, see [SymbolTablePtr::detach].

    ///

    /// Create a new symbol table with the same contents as this one, but a new ID,

    /// and return a pointer to it.

}

impl Default for SymbolTablePtr {

}

impl HasId for SymbolTablePtr {

    const TYPE_NAME: &'static str = "SymbolTable";

}

impl DefaultWithId for SymbolTablePtr {

}

impl IdPtr for SymbolTablePtr {

    type Data = SymbolTable;

}

// TODO: this code is almost exactly copied from [DeclarationPtr].

//       It should be possible to eliminate the duplication...

//       Perhaps by merging SymbolTablePtr and DeclarationPtr together?

//       (Alternatively, a macro?)

impl Uniplate for SymbolTablePtr {

        (

        )

}

impl<To> Biplate<To> for SymbolTablePtr

where

    SymbolTable: Biplate<To>,

    To: Uniplate,

{

            unsafe {

                (

                )

            }

        } else {

            // call biplate on the enclosed declaration

            (

            )

        }

}

#[derive(Debug)]

struct SymbolTablePtrInner {

    id: ObjId,

    value: RwLock<SymbolTable>,

}

impl Hash for SymbolTablePtrInner {

}

impl PartialEq for SymbolTablePtrInner {

}

impl Eq for SymbolTablePtrInner {}

/// 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).

#[serde_as]

#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]

pub struct SymbolTable {

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

    table: IndexMap<Name, DeclarationPtr>,

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

    parent: Option<SymbolTablePtr>,

    next_machine_name: i32,

}

impl SymbolTable {

    /// Creates an empty symbol table.

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

            "new symbol table: id = {id}  parent_id = {}",

        );

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

    /// Iterates over entries in the LOCAL symbol table, by reference.

    /// Iterates over entries in the LOCAL symbol table, by reference.

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

    /// necessary.

            }

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

    /// declaration.

    // Reserves a unique machine name in the symbol table

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

    ///

    /// This function provides no sanity checks.

    /// Gets the parent of this symbol table.

    /// 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 = SymbolTableIter;

    /// Iterates over symbol table entries in scope.

}

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

pub struct SymbolTableIter {

    // iterator over the current scopes' btreemap

    inner: indexmap::map::IntoIter<Name, DeclarationPtr>,

    // the parent scope

    parent: Option<SymbolTablePtr>,

}

impl Iterator for SymbolTableIter {

    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 Default for SymbolTable {

}

// TODO: if we could override `Uniplate` impl but still derive `Biplate` instances,

//       we could remove some of this manual code

impl Uniplate for SymbolTable {

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

}

impl Biplate<SymbolTablePtr> for SymbolTable {

}

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<Model> 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

}