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

use ecs::Sole;

use crate::asset::Id as AssetId;

pub type RawValue = u32;

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

impl Id
{
    pub fn new_sequential() -> Self
    {
        static NEXT_SEQUENTIAL_ID: AtomicU64 = AtomicU64::new(0);

        Self::Sequential(SequentialId(
            NEXT_SEQUENTIAL_ID.fetch_add(1, Ordering::Relaxed),
        ))
    }

    pub fn into_asset_id(self) -> Option<AssetId>
    {
        match self {
            Self::Asset(asset_id) => Some(asset_id),
            Self::Sequential(_) => None,
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct SequentialId(u64);

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

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

    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 get_shader_program_obj(&self, id: &Id) -> Option<&Object>
    {
        let obj = self.get_obj(id)?;

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

        Some(obj)
    }

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

    pub fn contains_non_pending_with_id(&self, id: &Id) -> bool
    {
        self.objects.get(id).and_then(|obj| obj.as_ref()).is_some()
    }

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

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

    pub fn remove(&mut self, id: &Id) -> Option<Option<Object>>
    {
        self.objects.remove(id)
    }
}

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

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

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

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

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