use std::collections::BTreeMap;

use core::fmt::Debug;

use linkme::distributed_slice;

//TODO: write good documentation on this! ~niklasdewally

use crate::{

    ast::{DeclarationPtr, Expression, Literal, Name, SymbolTable},

    rule_engine::ApplicationError,

};

#[distributed_slice]

#[doc(hidden)]

pub static REPRESENTATION_RULES: [RepresentationRule];

#[doc(hidden)]

pub struct RepresentationRule {

    pub name: &'static str,

    pub init: fn(&Name, &SymbolTable) -> Option<Box<dyn Representation>>,

}

/// Gets the representation rule named `name`.

#[allow(clippy::type_complexity)]

#[macro_export]

macro_rules! register_representation {

    ($ruleType:ident, $ruleName:literal) => {

        paste::paste!{

        #[linkme::distributed_slice($crate::representation::REPRESENTATION_RULES)]

        pub static [<__ $ruleType:snake:upper _REPRESENTATION_RULE>]: $crate::representation::RepresentationRule = $crate::representation::RepresentationRule {

            name: $ruleName,

            init: [<__create_representation_ $ruleType:snake>]

        };

        }

    };

}

// This alongside Representation::box_clone() allows Representation to be a trait-object but still

// cloneable.

impl Clone for Box<dyn Representation> {

}

/// Encodes the two-way relationship between a non-atomic variable and multiple auxiliary variables.

///

/// For example, a 2x2 matrix X might be represented by a variable for each element X1_1 X1_2 X2_1 X2_2.

/// The [`Representation`] for X then allows us to set the value of the matrix, and takes care of

/// assigning the individual variables accordingly. Conversly, we can set the values of the elements, and

/// the [`Representation`] will return an assignment for the matrix as a whole.

pub trait Representation: Send + Sync + Debug {

    /// Creates a representation object for the given name.

    fn init(name: &Name, symtab: &SymbolTable) -> Option<Self>

    where

        Self: Sized;

    /// The variable being represented.

    fn variable_name(&self) -> &Name;

    /// Given an assignment for `self`, creates assignments for its representation variables.

    fn value_down(&self, value: Literal) -> Result<BTreeMap<Name, Literal>, ApplicationError>;

    /// Given assignments for its representation variables, creates an assignment for `self`.

    fn value_up(&self, values: &BTreeMap<Name, Literal>) -> Result<Literal, ApplicationError>;

    /// Returns [`Expression`]s representing each representation variable.

    fn expression_down(

        &self,

        symtab: &SymbolTable,

    ) -> Result<BTreeMap<Name, Expression>, ApplicationError>;

    /// Creates declarations for the representation variables of `self`.

    fn declaration_down(&self) -> Result<Vec<DeclarationPtr>, ApplicationError>;

    /// The rule name for this representaion.

    fn repr_name(&self) -> &str;

    /// Makes a clone of `self` into a `Representation` trait object.

    fn box_clone(&self) -> Box<dyn Representation>;

}