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

use linkme::distributed_slice;

use crate::World;

static NEXT_UID: AtomicU64 = AtomicU64::new(0);

/// Unique entity ID.
#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
pub struct Uid
{
    inner: u64,
}

impl Uid
{
    pub fn new(uid: u64) -> Self
    {
        debug_assert!(
            uid < NEXT_UID.load(Ordering::Relaxed),
            "Invalid entity UID {uid}"
        );

        Self { inner: uid }
    }

    pub fn new_unique() -> Self
    {
        Self {
            inner: NEXT_UID.fetch_add(1, Ordering::Relaxed),
        }
    }
}

#[macro_export]
macro_rules! static_entity {
    ($visibility: vis $ident: ident, $components: expr) => {
        $visibility static $ident: ::std::sync::LazyLock<$crate::entity::Uid> =
            ::std::sync::LazyLock::new(|| $crate::entity::Uid::new_unique());

        $crate::private::paste::paste! {
            mod [<__ecs_ $ident:lower _static_entity_priv>] {
                use super::*;

                #[$crate::private::linkme::distributed_slice(
                    $crate::entity::CREATE_STATIC_ENTITIES
                )]
                #[linkme(crate=$crate::private::linkme)]
                static CREATE_STATIC_ENTITY: fn(&$crate::World) = |world| {
                    world.create_entity_with_uid($components, *$ident);
                };
            }
        }
    }
}

#[distributed_slice]
#[doc(hidden)]
pub static CREATE_STATIC_ENTITIES: [fn(&World)];