use std::{any::Any, sync::{Arc, RwLock}};

use uuid::Uuid;

use crate::ResourceStorage;

#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub enum ResourceState {
    Loading,
    Ready,
}

pub struct ResourceDataRef<'a, T> {
    guard: std::sync::RwLockReadGuard<'a, Resource<T>>,
}

impl<'a, T> std::ops::Deref for ResourceDataRef<'a, T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        // safety: this struct must only be created if the resource is loaded
        self.guard.data.as_ref().unwrap()
    }
}

pub struct Resource<T> {
    path: String,
    pub(crate) data: Option<T>,
    pub(crate) version: usize,
    pub(crate) state: ResourceState,
    uuid: Uuid,
    pub(crate) is_watched: bool,
}

/// A handle to a resource. 
/// 
/// # Note
/// This struct has an inner [`RwLock`] to the resource data, so most methods may be blocking.
/// However, the only times it will be blocking is if another thread is reloading the resource
/// and has a write lock on the data. This means that most of the time, it is not blocking.
pub struct ResHandle<T> {
    pub(crate) data: Arc<RwLock<Resource<T>>>,
}

impl<T> Clone for ResHandle<T> {
    fn clone(&self) -> Self {
        Self { data: self.data.clone() }
    }
}

impl<T> ResHandle<T> {
    /// Create the resource with data, its assumed the state is `Ready`
    pub fn with_data(path: &str, data: T) -> Self {
        let res_version = Resource {
            path: path.to_string(),
            data: Some(data),
            version: 0,
            state: ResourceState::Ready,
            uuid: Uuid::new_v4(),
            is_watched: false,
        };

        Self {
            data: Arc::new(RwLock::new(res_version)),
        }
    }

    /// Returns a boolean indicating if this resource's path is being watched.
    pub fn is_watched(&self) -> bool {
        let d = self.data.read().expect("Resource mutex was poisoned!");
        d.is_watched
    }

    /// Returns a boolean indicating if this resource is loaded
    pub fn is_loaded(&self) -> bool {
        let d = self.data.read().expect("Resource mutex was poisoned!");
        d.state == ResourceState::Ready
    }

    /// Returns the current state of the resource.
    pub fn state(&self) -> ResourceState {
        let d = self.data.read().expect("Resource mutex was poisoned!");
        d.state
    }

    /// Returns the path that the resource was loaded from.
    pub fn path(&self) -> String {
        let d = self.data.read().expect("Resource mutex was poisoned!");
        d.path.to_string()
    }

    /// Returns the uuid of the resource.
    pub fn uuid(&self) -> Uuid {
        let d = self.data.read().expect("Resource mutex was poisoned!");
        d.uuid
    }

    /// Retrieves the current version of the resource. This gets incremented when the resource
    /// is reloaded.
    pub fn version(&self) -> usize {
        let d = self.data.read().expect("Resource mutex was poisoned!");
        d.version
    }

    /// Get a reference to the data in the resource
    ///
    /// # Panics
    /// Panics if the resource was not loaded yet.
    pub fn data_ref<'a>(&'a self) -> ResourceDataRef<'a, T> {
        let d = self.data.read().expect("Resource mutex was poisoned!");
        ResourceDataRef {
            guard: d
        }
    }

    /// Attempt to get a borrow to the resource data. Returns `None` if the resource is not loaded.
    pub fn try_data_ref<'a>(&'a self) -> Option<ResourceDataRef<'a, T>> {
        if self.is_loaded() {
            let d = self.data.read().expect("Resource mutex was poisoned!");
            Some(ResourceDataRef {
                guard: d
            })
        } else {
            None
        }
    }
}

impl<T: Send + Sync + 'static> ResourceStorage for ResHandle<T> {
    fn as_any(&self) -> &dyn Any {
        self
    }

    fn as_any_mut(&mut self) -> &mut dyn Any {
        self
    }

    fn as_arc_any(self: Arc<Self>) -> Arc<dyn Any + Send + Sync> {
        self.clone()
    }

    fn as_box_any(self: Box<Self>) -> Box<dyn Any + Send + Sync> {
        self
    }

    fn set_watched(&self, watched: bool) {
        let mut w = self.data.write().unwrap();
        w.is_watched = watched;
    }

    fn path(&self) -> String {
        self.path()
    }

    fn version(&self) -> usize {
        self.version()
    }

    fn state(&self) -> ResourceState {
        self.state()
    }

    fn uuid(&self) -> Uuid {
        self.uuid()
    }

    fn is_watched(&self) -> bool {
        self.is_watched()
    }

    fn is_loaded(&self) -> bool {
        self.is_loaded()
    }
}