/*
    This file is part of jellything (https://codeberg.org/metamuffin/jellything)
    which is licensed under the GNU Affero General Public License (version 3); see /COPYING.
    Copyright (C) 2026 metamuffin <metamuffin.org>
*/
#![feature(iter_array_chunks)]

mod buffer;
mod registry;
#[cfg(test)]
mod tests;
mod value;
pub use buffer::*;
pub use registry::*;
pub use value::*;

use std::marker::PhantomData;

#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub struct Tag(pub u32);
pub struct TypedTag<T>(pub Tag, pub PhantomData<T>);

#[derive(Debug, Clone, Copy)]
pub struct Object<'a> {
    tags: &'a [u32],
    offsets: &'a [u32],
    values: &'a [u32],
}
impl<'a> Object<'a> {
    pub fn load(buf: &'a [u32]) -> Option<Self> {
        let nf = *buf.get(0)? as usize;
        if buf.len() < 1 + nf * 2 {
            return None;
        }
        Some(Self {
            tags: &buf[1..1 + nf],
            offsets: &buf[1 + nf..1 + nf + nf],
            values: &buf[1 + nf + nf..],
        })
    }
    pub fn find_field(&self, tag: Tag) -> Option<usize> {
        // using partition as binary search for the first field (instead of regular binary_search that returns any)
        let first = self.tags.partition_point(|&x| x < tag.0);
        self.tags
            .get(first)
            .is_some_and(|&x| x == tag.0)
            .then_some(first)
    }
    fn get_aligned(&self, index: usize) -> Option<&[u32]> {
        let start_raw = self.offsets[index];
        let end_raw = self
            .offsets
            .get(index + 1)
            .copied()
            .unwrap_or((self.values.len() as u32) << 2);

        let start = start_raw >> 2;
        let end = end_raw >> 2;

        Some(&self.values[start as usize..end as usize])
    }
    fn get_unaligned(&self, index: usize) -> Option<&[u8]> {
        let start_raw = self.offsets[index];
        let end_raw = self
            .offsets
            .get(index + 1)
            .copied()
            .unwrap_or((self.values.len() as u32) << 2);

        let start = (start_raw >> 2) * 4;
        let padding = start_raw & 0b11;
        let end = (end_raw >> 2) * 4 - padding;

        let values_u8: &[u8] = bytemuck::cast_slice(self.values);
        Some(&values_u8[start as usize..end as usize])
    }
    #[inline]
    pub fn get_typed<'b: 'a, T: Value<'b>>(&'b self, index: usize) -> Option<T> {
        if T::ALIGNED {
            T::load_aligned(self.get_aligned(index)?)
        } else {
            T::load_unaligned(self.get_unaligned(index)?)
        }
    }
    pub fn get<'b: 'a, T: Value<'b>>(&'b self, tag: TypedTag<T>) -> Option<T> {
        self.get_typed(self.find_field(tag.0)?)
    }
    pub fn iter<'b: 'a, T>(&'b self, tag: TypedTag<T>) -> FieldIter<'b, T> {
        FieldIter {
            object: self,
            index: self.tags.partition_point(|&x| x < tag.0.0),
            tag: tag.0.0,
            ty: PhantomData,
        }
    }
}

pub struct FieldIter<'a, T> {
    object: &'a Object<'a>,
    index: usize,
    tag: u32,
    ty: PhantomData<T>,
}
impl<'a, T: Value<'a>> Iterator for FieldIter<'a, T> {
    type Item = T;
    fn next(&mut self) -> Option<Self::Item> {
        if self.index >= self.object.tags.len() {
            return None;
        }
        if self.object.tags[self.index] != self.tag {
            return None;
        }
        let val = self.object.get_typed(self.index);
        self.index += 1;
        val
    }
}