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

use std::fmt::{Debug, Display};

use std::sync::{Arc, RwLock};

use derivative::Derivative;

use indexmap::IndexSet;

use serde::{Deserialize, Serialize};

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

use crate::context::Context;

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

use super::{DeclarationPtr, Expression, Name, ReturnType, SubModel, SymbolTablePtr, Typeable};

/// An Essence model.

///

/// - This type wraps a [`Submodel`] containing the top-level lexical scope. To manipulate the

///   model's constraints or symbols, first convert it to a [`Submodel`] using

///   [`as_submodel`](Model::as_submodel) / [`as_submodel_mut`](Model::as_submodel_mut).

///

/// - To de/serialise a model using `serde`, see [`SerdeModel`].

#[derive(Derivative, Clone, Debug)]

#[derivative(PartialEq, Eq)]

pub struct Model {

    submodel: SubModel,

    pub search_order: Option<Vec<Name>>,

    pub dominance: Option<Expression>,

    #[derivative(PartialEq = "ignore")]

    pub context: Arc<RwLock<Context<'static>>>,

}

impl Model {

    /// Creates a new model from the given context.

    /// Returns this model as a [`Submodel`].

    /// Returns this model as a mutable [`Submodel`].

    /// Replaces the model contents with `new_submodel`, returning the old contents.

}

impl Default for Model {

}

impl Typeable for Model {

}

// At time of writing (03/02/2025), the Uniplate derive macro doesn't like the lifetimes inside

// context, and we do not yet have a way of ignoring this field.

impl Uniplate for Model {

        // Model contains no sub-models.

}

impl Biplate<Expression> for Model {

        // walk into submodel

        // walk into dominance relation if it exists

        };

                // reconstruct the submodel

                // reconstruct the dominance relation

                };

            }

            _ => {

            }

}

impl Biplate<SubModel> for Model {

            };

}

impl Display for Model {

}

/// A model that is de/serializable using `serde`.

///

/// To turn this into a rewritable model, it needs to be initialised using [`initialise`](SerdeModel::initialise).

///

/// To deserialise a [`Model`], use `.into()` to convert it into a `SerdeModel` first.

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

pub struct SerdeModel {

    #[serde(flatten)]

    submodel: SubModel,

    search_order: Option<Vec<Name>>, // TODO: make this a [expressions]

    dominance: Option<Expression>,

}

impl SerdeModel {

    /// Initialises the model for rewriting.

    ///

    /// This swizzles the pointers to symbol tables and declarations using the stored ids.

        // The definitive versions of each symbol table are stored in the submodels. Parent

        // pointers store dummy values with the correct ids, but nothing else. We need to replace

        // these dummy values with pointers to the actual parent symbol tables, using the ids to

        // know which tables should be equal.

        //

        // See super::serde::RcRefCellToInner, super::serde::RcRefCellToId.

        // Store the definitive versions of all symbol tables by id.

        // Find the definitive versions by traversing the sub-models.

            // ids should be unique!

        }

        // Restore parent pointers using `tables`.

            #[allow(clippy::unwrap_used)]

        }

        // The definitive versions of declarations are stored in the symbol table. References store

        // dummy values with the correct ids, but nothing else.

        // Store the definitive version of all declarations by id.

        }

        // Swizzle declaration pointers in expressions (references, auxdecls) using their ids and `all_declarations`.

}

impl From<Model> for SerdeModel {

}

impl Display for SerdeModel {

}

impl SerdeModel {

    /// Collects all ObjId values from the model using uniplate traversal.

    ///

    /// Traverses the model structure using `universe_bi` to collect IDs from:

    /// - All SubModels (to get SymbolTable IDs via `HasId`)

    /// - All DeclarationPtrs (to get declaration IDs via `HasId`)

    ///

    /// Returns a mapping from original ID to stable sequential ID (0, 1, 2, ...).

    /// IDs are assigned in the order they are encountered during traversal, ensuring

    /// stability across identical model structures.

            // If we have seen this table before, all its local declarations were already handled.

        // Using an IndexSet here, we maintain insertion order while deduplicating IDs.

        // Collect SymbolTable IDs by traversing all SubModels

        // Collect remaining IDs by traversing the expression tree

        // (Some expressions, e.g. AbstractComprehensions, contain SymbolTable's not

        // contained in submodels).

        // Create stable mapping: original_id -> stable_id

}