sync::{
        atomic::{AtomicUsize, Ordering},
        OnceLock,
    },

use lasso::{Rodeo, Spur};

// NOTE We just use lasso types here
// WARN Because we use "lasso/ahash", these tables are to be used in-memory only!

pub struct SymbolId(usize, usize);
/// A symbol table (that can only grow!)
pub struct SymbolTable(usize, Vec<Box<str>>);
impl Default for SymbolTable {
    fn default() -> Self {
        static SYMBOL_TABLE_COUNTER: OnceLock<AtomicUsize> = OnceLock::new();
        let counter = SYMBOL_TABLE_COUNTER.get_or_init(|| AtomicUsize::new(0));
        let id = counter.fetch_add(1, Ordering::SeqCst);
        // Start off with room for 100 symbols
        Self(id, Vec::with_capacity(100))
    }
}

pub struct SymbolId(Spur);
/// A wrapper around a [`Rodeo`]
#[derive(Default)]
pub struct SymbolTable(Rodeo);

    /// If a valid symbol, get the id, otherwise, create a new id referencing the symbol

    /// If a valid symbol, get the id

        self.1
            .iter()
            .position(|s| s.as_ref() == source.as_ref())
            .map(|pos| SymbolId(self.0, pos))

        self.0.get(source).map(SymbolId)

        self.id(source.as_ref()).unwrap_or_else(|| {
            let new_pos = self.1.len();
            self.1.push(source.as_ref().into());
            SymbolId(self.0, new_pos)
        })

        SymbolId(self.0.get_or_intern(source))

        let SymbolId(tid, idx) = id;
        // Just use a raw access, as we are the only ones who can hand out
        // SymbolIds with the right tid
        // no unsafe version, cuz it is trivially easy to misuse,
        // and the safe version only needs an integer compare, and *possibly* a bounds check
        (tid == self.0).then(|| self.1[idx].as_ref())

        self.0.try_resolve(&id.0)