use std::collections::HashMap;
use std::collections::hash_map::Entry as HashMapEntry;

use ecs::Component;

use crate::asset::Id as AssetId;

/// Renderer object ID.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Id
{
    Asset(AssetId),
    Other(u64),
}

/// Renderer object store.
#[derive(Debug, Default, Component)]
pub struct Store
{
    objects: HashMap<Id, Object>,
}

impl Store
{
    pub fn get_obj(&self, id: &Id) -> Option<&Object>
    {
        self.objects.get(id)
    }

    pub fn get_texture_obj(&self, id: &Id) -> Option<&Object>
    {
        let obj = self.get_obj(id)?;

        if !matches!(obj.kind(), Kind::Texture) {
            return None;
        }

        Some(obj)
    }

    pub fn contains_with_id(&self, id: &Id) -> bool
    {
        self.objects.contains_key(id)
    }

    pub fn insert(&mut self, id: Id, object: Object)
    {
        self.objects.insert(id, object);
    }

    pub fn entry(&mut self, id: Id) -> StoreEntry<'_>
    {
        StoreEntry { inner: self.objects.entry(id) }
    }
}

#[derive(Debug)]
pub struct StoreEntry<'store>
{
    inner: HashMapEntry<'store, Id, Object>,
}

impl<'store> StoreEntry<'store>
{
    pub fn or_insert(self, default_obj: Object) -> &'store mut Object
    {
        self.inner.or_insert(default_obj)
    }

    pub fn or_insert_with(
        self,
        default_func: impl FnOnce() -> Object,
    ) -> &'store mut Object
    {
        self.inner.or_insert_with(default_func)
    }
}

/// Renderer object.
#[derive(Debug, Clone)]
pub struct Object
{
    raw: u32,
    kind: Kind,
}

impl Object
{
    pub fn from_raw(raw: u32, kind: Kind) -> Self
    {
        Self { raw, kind }
    }

    pub fn as_raw(&self) -> u32
    {
        self.raw
    }

    pub fn kind(&self) -> Kind
    {
        self.kind
    }
}

/// Renderer object kind.
#[derive(Debug, Clone, Copy)]
#[non_exhaustive]
pub enum Kind
{
    Texture,
    Mesh,
}