//! State
use super::*;
use tokio::{
    sync::{
	watch,
    },
};
use config::Config;

#[derive(Debug, Clone)]
pub struct State
{
    config: Arc<Config>, //to avoid cloning config
    exclude: Arc<(sanitise::filter::Filter, sanitise::filter::Filter)>,
    chain: Arc<RwLock<Chain<String>>>,
    save: Arc<Notify>,

    shutdown: Arc<watch::Sender<bool>>,
    shutdown_recv: watch::Receiver<bool>,
}

impl State
{
    pub fn inbound_filter(&self) -> &sanitise::filter::Filter
    {
	&self.exclude.0
    }
     pub fn outbound_filter(&self) -> &sanitise::filter::Filter
    {
	&self.exclude.1
    }
    
    pub fn new(config: Config, chain: Arc<RwLock<Chain<String>>>, save: Arc<Notify>) -> Self
    {
	let (shutdown, shutdown_recv) = watch::channel(false);
	Self {
	    exclude: Arc::new((config.filter.get_inbound_filter(),
			       config.filter.get_outbound_filter())),
	    config: Arc::new(config),
	    chain,
	    save,
	    shutdown: Arc::new(shutdown),
	    shutdown_recv,
	}
    }

    pub fn config(&self) -> &Config
    {
	self.config.as_ref()
    }

    pub fn notify_save(&self)
    {
	self.save.notify();
    }

    pub fn chain(&self) -> &RwLock<Chain<String>>
    {
	&self.chain.as_ref()
    }

    pub fn when(&self) -> &Arc<Notify>
    {
	&self.save
    }

    pub fn shutdown(self)
    {
	self.shutdown.broadcast(true).expect("Failed to communicate shutdown");
	self.save.notify();
    }

    pub fn has_shutdown(&self) -> bool
    {
	*self.shutdown_recv.borrow()
    }

    pub async fn on_shutdown(&mut self)
    {
	if !self.has_shutdown() {
	    while let Some(false) = self.shutdown_recv.recv().await {
		
	    }
	}
    }
}