use std::sync::Arc;

use crate::error::RuntimeError;
use crate::resource::Resource;
use crate::symbol::SymbolRef;

pub use serde_yaml::Value as DriverParams;

pub trait DriverRoot: Send + Sync {
    fn get(&self, symbol: SymbolRef<'_>) -> Result<ArcDriver, RuntimeError>;
}

pub type ArcDriver = Arc<dyn Driver>;

pub trait Driver
where
    Self: Send + Sync,
{
    #[allow(unused_variables)]
    fn call(&self, func: &str, value: &Resource) -> Result<(), RuntimeError> {
        RuntimeError::unimplemented()
    }

    #[allow(unused_variables)]
    fn with(&self, value: &Resource) -> Result<Option<ArcDriver>, RuntimeError> {
        Ok(None)
    }

    /// Load the driver's current state.
    ///
    /// If there is a shortage of physical resources, hibernate drivers that are not needed.
    fn status(&self) -> Result<DriverState, RuntimeError>;

    /// Hibernate the driver.
    ///
    /// The hibernating driver must unload the heavy data from memory and be able to reload it in the wake.
    fn hibernate(&self) -> Result<(), RuntimeError> {
        Ok(())
    }

    /// Wake the hibernating driver.
    ///
    /// note: This function will **never** be called if it is already awake.
    fn wake_up(&self) -> Result<(), RuntimeError> {
        Ok(())
    }

    /// Inform the driver that a work will use it.
    fn enter(&self) -> Result<(), RuntimeError> {
        Ok(())
    }

    /// Inform the driver that the work is completed.
    fn exit(&self) -> Result<(), RuntimeError> {
        Ok(())
    }
}

pub enum DriverState {
    /// Doing nothing
    Idle,
    /// Doing something
    Running(DriverRunningState),
    /// Doing nothing but not available immediately
    Hibernated,
}

pub enum DriverRunningState {
    /// Doing something, but not critical
    Lazy,
    /// Doing something, OS interference is not a burden.
    Normal,
    /// Doing something, OS interference is burdensome
    Busy,
}

impl Default for DriverRunningState {
    fn default() -> Self {
        Self::Normal
    }
}