//! Native generation-tagged handle table. See os-handles/generation/CONTRACT.md.
//! A caller must bind `P` to a live kernel process ID before invoking this
//! table. `Object` IDs are kernel-owned names, never user pointers.

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Handle(u64);

impl Handle {
    pub const fn from_raw(raw: u64) -> Self { Self(raw) }
    pub const fn raw(self) -> u64 { self.0 }
    pub const fn slot(self) -> u32 { self.0 as u32 }
    pub const fn generation(self) -> u32 { (self.0 >> 32) as u32 }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Object {
    File(u64),
    Channel(u64),
    Task(u64),
}

impl Object {
    const fn id(self) -> u64 {
        match self {
            Self::File(id) | Self::Channel(id) | Self::Task(id) => id,
        }
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Error {
    BadFd,
    InvalidObject,
    Full,
    IdExhausted,
}

impl Error {
    pub const fn errno(self) -> u64 {
        match self {
            Self::BadFd => 9,
            Self::InvalidObject => 22,
            Self::Full => 24,
            Self::IdExhausted => 75,
        }
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
struct Entry<P> {
    handle: Handle,
    owner: P,
    object: Object,
}

/// Complete scalar audit state. It does not expose a mutable table entry.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Snapshot<P, const N: usize> {
    pub generations: [u32; N],
    pub entries: [Option<(u64, P, Object)>; N],
}

pub struct Table<P: Copy + Eq, const N: usize> {
    entries: [Option<Entry<P>>; N],
    generations: [u32; N],
}

impl<P: Copy + Eq, const N: usize> Table<P, N> {
    pub const fn new() -> Self {
        Self { entries: [None; N], generations: [0; N] }
    }

    /// Kernel-only deterministic seed for an isolated overflow probe. A user
    /// syscall adapter must never take the seed from caller input.
    pub const fn with_generation_seed(generations: [u32; N]) -> Self {
        Self { entries: [None; N], generations }
    }

    pub fn len(&self) -> usize {
        self.entries.iter().filter(|entry| entry.is_some()).count()
    }

    pub fn owned(&self, owner: P) -> usize {
        self.entries.iter().flatten().filter(|entry| entry.owner == owner).count()
    }

    /// Validate all fallible conditions before publishing the entry.
    pub fn open(&mut self, owner: P, object: Object) -> Result<Handle, Error> {
        if object.id() == 0 { return Err(Error::InvalidObject); }
        let slot = self.entries.iter().position(Option::is_none).ok_or(Error::Full)?;
        let slot_id = u32::try_from(slot).ok()
            .and_then(|value| value.checked_add(1)).ok_or(Error::IdExhausted)?;
        let generation = self.generations[slot]
            .checked_add(1).ok_or(Error::IdExhausted)?;
        let handle = Handle((u64::from(generation) << 32) | u64::from(slot_id));
        self.entries[slot] = Some(Entry { handle, owner, object });
        self.generations[slot] = generation;
        Ok(handle)
    }

    fn object(&self, owner: P, handle: Handle) -> Result<Object, Error> {
        let slot = handle.slot().checked_sub(1)
            .and_then(|value| usize::try_from(value).ok()).ok_or(Error::BadFd)?;
        self.entries.get(slot).copied().flatten()
            .filter(|entry| entry.owner == owner && entry.handle == handle)
            .map(|entry| entry.object).ok_or(Error::BadFd)
    }

    /// A File handle cannot be used through the Channel or Task API.
    pub fn file_read(&self, owner: P, handle: Handle) -> Result<u64, Error> {
        match self.object(owner, handle)? {
            Object::File(id) => Ok(id),
            _ => Err(Error::BadFd),
        }
    }

    pub fn channel_send(&self, owner: P, handle: Handle) -> Result<u64, Error> {
        match self.object(owner, handle)? {
            Object::Channel(id) => Ok(id),
            _ => Err(Error::BadFd),
        }
    }

    pub fn task_inspect(&self, owner: P, handle: Handle) -> Result<u64, Error> {
        match self.object(owner, handle)? {
            Object::Task(id) => Ok(id),
            _ => Err(Error::BadFd),
        }
    }

    pub fn close(&mut self, owner: P, handle: Handle) -> Result<(), Error> {
        let slot = self.entries.iter().position(|entry| entry.is_some_and(
            |entry| entry.owner == owner && entry.handle == handle))
            .ok_or(Error::BadFd)?;
        self.entries[slot] = None;
        Ok(())
    }

    pub fn close_owner(&mut self, owner: P) -> usize {
        let mut closed = 0;
        for entry in &mut self.entries {
            if entry.is_some_and(|entry| entry.owner == owner) {
                *entry = None;
                closed += 1;
            }
        }
        closed
    }

    pub fn snapshot(&self) -> Snapshot<P, N> {
        Snapshot { generations: self.generations,
            entries: self.entries.map(|entry| entry.map(
            |entry| (entry.handle.raw(), entry.owner, entry.object))) }
    }
}

impl<P: Copy + Eq, const N: usize> Default for Table<P, N> {
    fn default() -> Self { Self::new() }
}