use crate::ast::versioned_cache::VersionedCache;

use crate::ast::{DomainPtr, ReturnType, declaration::declaration_content_generation};

use polyquine::Quine;

use proc_macro2::TokenStream;

use quote::quote;

use serde::{Deserialize, Serialize};

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

use std::hash::Hash;

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

use uniplate::derive_unplateable;

derive_unplateable!(Metadata);

pub const NO_HASH: u64 = 0;

/// Per-expression metadata used for typing, source mapping, and runtime caches.

///

/// Metadata is ignored by expression equality and hashing.

#[derive(Debug, Deserialize, Serialize)]

pub struct Metadata {

    /// Cached or inferred return type for this expression.

    pub etype: Option<ReturnType>,

    /// Optional source span identifier for diagnostics and reporting.

    #[serde(default, skip_serializing_if = "Option::is_none")]

    pub span_id: Option<u32>,

    /// Cached expression content hash used by semantic hashing.

    #[serde(default, skip_serializing)]

    pub cached_content_hash: AtomicU64,

    /// Cached result of `Expression::domain_of()` for this node, stamped internally with the

    /// declaration generation used to compute it.

    ///

    /// The generation records the declaration state used to compute the domain. `domain_of()`

    /// recomputes recursively from scratch on every cache miss, so repeatedly calling it on the

    /// same subtree (as rules that check "is this operand scalar/abstract" tend to, once per rule

    /// attempt) is quadratic in the worst case. Cleared when this expression or a descendant

    /// changes, and ignored after a referenced declaration changes.

    #[serde(skip)]

    domain: VersionedCache<Option<DomainPtr>>,

}

impl Metadata {

    /// Creates empty metadata with no type, source span, or cached rewrite state.

    /// Creates empty metadata associated with a source span identifier.

    /// Clears the cached domain after this expression or a descendant changes.

    /// Returns the cached domain for this expression, computing and caching it via `compute` on

    /// first access.

}

impl Default for Metadata {

}

impl Display for Metadata {

}

impl Hash for Metadata {

        // Dummy method - Metadata is ignored when hashing an Expression

}

impl Clone for Metadata {

            // Deliberately *not* carried over, unlike the other runtime caches above: some

            // callers clone an expression template and then mutate its children directly (e.g.

            // comprehension-body substitution), bypassing the rewriter's zipper-based

            // cached-domain invalidation entirely. A clone always starts uncached so

            // that path can never observe a stale domain.

}

impl PartialEq for Metadata {

}

impl Eq for Metadata {}

impl Quine for Metadata {

            let mut metadata = conjure_cp::ast::Metadata::new();

            metadata.etype = #etype;

            metadata.span_id = #span_id;

            metadata

        }}

}