jelq

//! The live runs. The table is only locked long enough to find a run, and each run has its own

//! lock, so one slow turn never holds up anyone else's. Nothing ever waits on a run's lock while

//! holding the table's, which is what keeps the two from deadlocking.

use std::{

    collections::{HashMap, hash_map::Entry},

    sync::{

        Arc, Mutex, MutexGuard, PoisonError, RwLock, RwLockReadGuard, RwLockWriteGuard,

        TryLockError,

    },

    time::{Duration, Instant},

};

use crate::game::Run;

pub type Slot = Arc<Mutex<Run>>;

#[derive(Default)]

pub struct Registry {

    runs: RwLock<HashMap<String, Slot>>,

}

/// A run's lock as it was found. A panic mid-turn poisons it, and that run cannot be trusted.

pub enum Lock<'a> {

    Held(MutexGuard<'a, Run>),

    Poisoned(MutexGuard<'a, Run>),

}

impl<'a> Lock<'a> {

    pub fn take(slot: &'a Slot) -> Self {

        match slot.lock() {

            Ok(run) => Self::Held(run),

            Err(poisoned) => Self::Poisoned(poisoned.into_inner()),

        }

    }

}

fn peek(slot: &Slot) -> Option<MutexGuard<'_, Run>> {

    match slot.try_lock() {

        Ok(run) => Some(run),

        Err(TryLockError::Poisoned(poisoned)) => Some(poisoned.into_inner()),

        Err(TryLockError::WouldBlock) => None,

    }

}

impl Registry {

    pub fn get(&self, id: &str) -> Option<Slot> {

        self.read().get(id).cloned()

    }

    pub fn len(&self) -> usize {

        self.read().len()

    }

    pub fn contains(&self, id: &str) -> bool {

        self.read().contains_key(id)

    }

    /// Refuses to replace a live run, so a colliding id can never evict one.

    pub fn insert_new(&self, run: Run) -> bool {

        match self.write().entry(run.id().to_owned()) {

            Entry::Occupied(_) => false,

            Entry::Vacant(slot) => {

                slot.insert(Arc::new(Mutex::new(run)));

                true

            }

        }

    }

    pub fn remove(&self, id: &str) {

        self.write().remove(id);

    }

    /// Every live run not mid-turn. A busy run is skipped rather than waited for.

    pub fn each<T>(&self, mut visit: impl FnMut(&Run) -> T) -> Vec<T> {

        let slots: Vec<Slot> = self.read().values().cloned().collect();

        slots

            .iter()

            .filter_map(|slot| peek(slot).map(|run| visit(&run)))

            .collect()

    }

    pub fn evict_idle(&self, now: Instant, ttl: Duration) -> Vec<Slot> {

        let idle: Vec<String> = self

            .read()

            .iter()

            .filter(|(_, slot)| {

                peek(slot).is_some_and(|run| now.duration_since(run.last_seen()) >= ttl)

            })

            .map(|(id, _)| id.clone())

            .collect();

        let mut runs = self.write();

        idle.iter().filter_map(|id| runs.remove(id)).collect()

    }

    fn read(&self) -> RwLockReadGuard<'_, HashMap<String, Slot>> {

        self.runs.read().unwrap_or_else(PoisonError::into_inner)

    }

    fn write(&self) -> RwLockWriteGuard<'_, HashMap<String, Slot>> {

        self.runs.write().unwrap_or_else(PoisonError::into_inner)

    }

}