/*
    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>
*/
pub mod kv;
pub mod query_ser;
#[cfg(test)]
pub mod test_shared;

use anyhow::Result;
use jellyobject::{ObjectBuffer, Path, Tag};

pub type RowNum = u64;
pub type RowIter = Box<dyn Iterator<Item = Result<(RowNum, Vec<u8>)>>>;

pub trait Database: Send + Sync {
    fn transaction(&self, f: &mut dyn FnMut(&mut dyn Transaction) -> Result<()>) -> Result<()>;
}

pub trait Transaction {
    fn insert(&mut self, entry: ObjectBuffer) -> Result<RowNum>;
    fn remove(&mut self, row: RowNum) -> Result<()>;
    fn update(&mut self, row: RowNum, entry: ObjectBuffer) -> Result<()>;
    fn get(&self, row: RowNum) -> Result<Option<ObjectBuffer>>;
    fn query<'a>(
        &'a mut self,
        query: Query,
    ) -> Result<Box<dyn Iterator<Item = Result<(RowNum, Vec<u8>)>> + 'a>>;
    fn query_single(&mut self, query: Query) -> Result<Option<RowNum>>;
    fn count(&mut self, query: Query) -> Result<u64>;
    fn debug_info(&self) -> Result<String>;
}

#[derive(Default, Clone)]
pub struct Query {
    pub filter: Filter,
    pub sort: Sort,
}

#[derive(Default, Clone)]
pub enum Sort {
    #[default]
    None,
    Value(ValueSort),
    TextSearch(Path, String),
}

#[derive(Clone)]
pub struct ValueSort {
    pub order: SortOrder,
    pub path: Path,
    pub multi: MultiBehaviour,
    pub offset: Option<Vec<u8>>,
}

#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
pub enum MultiBehaviour {
    First,
    ForEach,
    Max,
    Min,
    Count,
}

#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
pub enum SortOrder {
    Ascending,
    Descending,
}

#[derive(Debug, Clone, Default)]
pub enum Filter {
    #[default]
    True,
    All(Vec<Filter>),
    Any(Vec<Filter>),
    Match(Path, Value),
    Has(Path),
}

#[derive(Debug, Clone)]
pub enum Value {
    Tag(Tag),
    U32(u32),
    U64(u64),
    I64(i64),
    String(String),
    Binary(Vec<u8>),
}

impl From<&str> for Value {
    fn from(value: &str) -> Self {
        Self::String(value.to_owned())
    }
}
impl From<String> for Value {
    fn from(value: String) -> Self {
        Self::String(value)
    }
}
impl From<u32> for Value {
    fn from(value: u32) -> Self {
        Self::U32(value)
    }
}
impl From<u64> for Value {
    fn from(value: u64) -> Self {
        Self::U64(value)
    }
}
impl From<i64> for Value {
    fn from(value: i64) -> Self {
        Self::I64(value)
    }
}
impl From<Tag> for Value {
    fn from(value: Tag) -> Self {
        Self::Tag(value)
    }
}