/*
    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>
*/

use jellyobject::Object;

use crate::{
    MultiBehaviour, RowNum, ValueSort,
    kv::{SubtreeNum, binning::Binning},
};

pub struct ValueIndex {
    id: SubtreeNum,
    binning: Binning,
    sort: ValueSort,
}

impl ValueIndex {
    pub fn new(id: SubtreeNum, binning: Binning, sort: ValueSort) -> Self {
        Self { id, binning, sort }
    }
    fn keys(&self, id: RowNum, ob: Object) -> Vec<Vec<u8>> {
        let mut keys = vec![self.id.to_be_bytes().to_vec()];
        self.binning.apply(ob, &mut keys);
        self.sort.apply(ob, &mut keys);
        for k in &mut keys {
            k.extend(id.to_ne_bytes());
        }
        keys
    }
}
// impl Index for ValueIndex {
//     fn add(&self, db: &mut dyn WriteTransaction, id: RowNum, ob: Object) -> Result<()> {
//         for key in self.keys(id, ob) {
//             db.set(&key, &[])?;
//         }
//         Ok(())
//     }
//     fn remove(&self, db: &mut dyn WriteTransaction, id: RowNum, ob: Object) -> Result<()> {
//         for key in self.keys(id, ob) {
//             db.del(&key)?;
//         }
//         Ok(())
//     }
//     fn compare(&self, before: Object, after: Object) -> bool {
//         self.keys(0, before) == self.keys(0, after)
//     }
//     fn query(&self, txn: &mut dyn ReadTransaction, sort: &Sort) -> Result<RowIter> {
//         todo!()
//     }
// }
impl ValueSort {
    fn apply(&self, ob: Object, keys: &mut Vec<Vec<u8>>) {
        match self.multi {
            MultiBehaviour::First => {
                if let Some(val) = self.path.get_matching_value(ob) {
                    for k in keys.iter_mut() {
                        k.extend(val);
                    }
                } else {
                    keys.clear();
                }
            }
            MultiBehaviour::ForEach => {
                let mut keys_out = Vec::new();
                for val in self.path.get_matching_values(ob) {
                    for mut k in keys.clone() {
                        k.extend(val);
                        keys_out.push(k);
                    }
                }
                *keys = keys_out
            }
            MultiBehaviour::Max => todo!(),
            MultiBehaviour::Min => todo!(),
            MultiBehaviour::Count => {
                let count = self.path.get_matching_values(ob).len() as u32;
                for k in keys.iter_mut() {
                    k.extend(count.to_be_bytes());
                }
            }
        }
    }
}