ordinary-storage 0.11.1

use crate::stores::database::DatabaseStore;
use bytes::{BufMut, Bytes, BytesMut};
use flexbuffers::Reader;
use ordinary_config::DatabaseModelConfig;
use ordinary_types::{Kind, TimeUnit};
use rustc_hash::FxHashSet;
use saferlmdb::{WriteTransaction, put};
use thiserror::Error;
use tracing::instrument;

#[derive(Error, Debug)]
pub enum UpdateError {
    #[error("no model for idx {0}")]
    ModelNotFound(u8),
    #[error("primary key not present in database")]
    ItemNotFound,
    #[error("value has already been indexed")]
    IndexCollision,
    #[error("invalid kind for index: {0}")]
    InvalidIndexKind(Kind),
    #[error("invalid kind for query: {0}")]
    InvalidQueryKind(Kind),
    #[error("item size exceeds limits")]
    ExceedsSizeLimits,
    #[error("(FlexBuffers) {0}")]
    FlexBuffersReaderError(#[from] flexbuffers::ReaderError),
    #[error("(LMDB) {0}")]
    LmdbError(#[from] saferlmdb::Error),
    #[error(transparent)]
    Anyhow(#[from] anyhow::Error),
}

#[inline]
#[instrument(skip_all, fields(i = model_config.idx, nm = tracing::field::display(&model_config.name), uuid = tracing::field::display(uuid::Uuid::from_bytes(uuid))))]
pub(crate) fn update(
    database: &DatabaseStore,
    model_config: &DatabaseModelConfig,
    uuid: [u8; 16],
    payload: &[u8],
    txn: Option<WriteTransaction<'_>>,
) -> anyhow::Result<(), UpdateError> {
    let res = inner(database, model_config, uuid, payload, txn);

    if let Err(err) = &res {
        #[allow(clippy::single_match_else)]
        match err {
            UpdateError::ItemNotFound => tracing::warn!("item not found"),
            _ => tracing::error!("{err}"),
        }
    }

    res
}

#[inline]
#[allow(clippy::too_many_lines)]
fn inner(
    database: &DatabaseStore,
    model_config: &DatabaseModelConfig,
    uuid: [u8; 16],
    payload: &[u8],
    txn: Option<WriteTransaction>,
) -> Result<(), UpdateError> {
    let root_vec = Reader::get_root(payload)?.as_vector();

    let mut builder = flexbuffers::Builder::new(&flexbuffers::BuilderOptions::SHARE_NONE);
    let mut item = builder.start_vector();

    item.push(flexbuffers::Blob(uuid.as_slice()));

    let mut model_prefixed_uuid = BytesMut::new();

    model_prefixed_uuid.put_u8(model_config.idx);
    model_prefixed_uuid.put_u8(0);
    model_prefixed_uuid.put(uuid.as_slice());

    let txn = match txn {
        Some(txn) => txn,
        None => WriteTransaction::new(database.env.clone())?,
    };

    {
        let mut access = txn.access();

        let item_key =
            match access.get::<[u8], [u8]>(&database.index_db, model_prefixed_uuid.as_ref()) {
                Ok(ik) => Bytes::copy_from_slice(ik),
                Err(_) => return Err(UpdateError::ItemNotFound),
            };

        let existing_item = access.get::<[u8], [u8]>(&database.item_db, item_key.as_ref())?;
        let existing_item = Bytes::copy_from_slice(existing_item);

        let existing_root_vec = Reader::get_root(existing_item.as_ref())?.as_vector();

        for field in &model_config.fields {
            let reader = root_vec.idx(field.idx as usize - 1);
            let existing_reader = existing_root_vec.idx(field.idx as usize);

            if let Kind::Ref {
                model: _,
                field: _,
                many,
            } = &field.kind
            {
                if let Some((ref_model_idx, ref_field_idx, ref_model_fields, ref_is_many)) =
                    database.cross_refs.get(&(model_config.idx, field.idx))
                {
                    // many-to-many
                    if many == &Some(true) && *ref_is_many {
                        let mut existing_ref_item_ids = FxHashSet::default();
                        let mut seen_ref_item_ids = FxHashSet::default();

                        for ref_reader in &existing_reader.as_vector() {
                            let ref_item_id_bytes = ref_reader.as_blob().0;

                            existing_ref_item_ids.insert(Bytes::copy_from_slice(ref_item_id_bytes));
                        }

                        let mut refs = item.start_vector();
                        let mut seen_uuids = FxHashSet::default();

                        for uuid in &reader.as_vector() {
                            let uuid = uuid.as_blob();
                            let uuid_bytes = uuid.0;
                            let mut lookup = BytesMut::new();

                            lookup.put_u8(*ref_model_idx);
                            lookup.put_u8(0);

                            lookup.put(uuid_bytes);

                            if seen_uuids.contains(uuid_bytes) {
                                continue;
                            }
                            seen_uuids.insert(Bytes::copy_from_slice(uuid_bytes));

                            let ref_item_id =
                                access.get::<[u8], [u8]>(&database.index_db, lookup.as_ref())?;
                            let ref_item_id = Bytes::copy_from_slice(ref_item_id);

                            refs.push(flexbuffers::Blob(ref_item_id.as_ref()));
                            seen_ref_item_ids.insert(ref_item_id.clone());

                            if existing_ref_item_ids.contains(&ref_item_id) {
                                continue;
                            }

                            // update foreign
                            let ref_item = access
                                .get::<[u8], [u8]>(&database.item_db, ref_item_id.as_ref())?;

                            let root_vec = Reader::get_root(ref_item)?.as_vector();
                            let mut builder =
                                flexbuffers::Builder::new(&flexbuffers::BuilderOptions::SHARE_NONE);
                            let mut builder_vec = builder.start_vector();

                            builder_vec.push(uuid);

                            for ref_field in ref_model_fields {
                                if &ref_field.idx == ref_field_idx {
                                    let mut curr_refs = builder_vec.start_vector();

                                    // pushes database ref to front of foreign's refs
                                    curr_refs.push(flexbuffers::Blob(item_key.as_ref()));

                                    for curr_ref in
                                        &root_vec.idx(ref_field.idx as usize).as_vector()
                                    {
                                        let curr_ref = curr_ref.as_blob();
                                        let curr_ref_bytes = curr_ref.0;

                                        if curr_ref_bytes != item_key {
                                            curr_refs.push(curr_ref);
                                        }
                                    }

                                    curr_refs.end_vector();
                                } else {
                                    ref_field.kind.copy_to(
                                        &root_vec.idx(ref_field.idx as usize),
                                        &mut builder_vec,
                                        None,
                                    )?;
                                }
                            }

                            builder_vec.end_vector();
                            let updated_ref_item = builder.view();

                            access.put(
                                &database.item_db,
                                ref_item_id.as_ref(),
                                updated_ref_item,
                                &put::Flags::empty(),
                            )?;
                        }

                        let mut clean_ids = vec![];

                        for existing_id in existing_ref_item_ids {
                            if !seen_ref_item_ids.contains(&existing_id) {
                                clean_ids.push(existing_id);
                            }
                        }

                        for clean_id in clean_ids {
                            // update foreign
                            let ref_item =
                                access.get::<[u8], [u8]>(&database.item_db, clean_id.as_ref())?;

                            let root_vec = Reader::get_root(ref_item)?.as_vector();
                            let mut builder =
                                flexbuffers::Builder::new(&flexbuffers::BuilderOptions::SHARE_NONE);
                            let mut builder_vec = builder.start_vector();

                            builder_vec.push(root_vec.idx(0).as_blob());

                            for ref_field in ref_model_fields {
                                if &ref_field.idx == ref_field_idx {
                                    let mut curr_refs = builder_vec.start_vector();

                                    for curr_ref in
                                        &root_vec.idx(ref_field.idx as usize).as_vector()
                                    {
                                        let curr_ref = curr_ref.as_blob();
                                        let curr_ref_bytes = curr_ref.0;

                                        if curr_ref_bytes != item_key {
                                            curr_refs.push(curr_ref);
                                        }
                                    }

                                    curr_refs.end_vector();
                                } else {
                                    ref_field.kind.copy_to(
                                        &root_vec.idx(ref_field.idx as usize),
                                        &mut builder_vec,
                                        None,
                                    )?;
                                }
                            }

                            builder_vec.end_vector();
                            let updated_ref_item = builder.view();

                            access.put(
                                &database.item_db,
                                clean_id.as_ref(),
                                updated_ref_item,
                                &put::Flags::empty(),
                            )?;
                        }

                        refs.end_vector();

                    // one-of-many (on another record)
                    } else if *ref_is_many {
                        let uuid = reader.as_blob();
                        let uuid_bytes = uuid.0;
                        let mut lookup = BytesMut::new();

                        lookup.put_u8(*ref_model_idx);
                        lookup.put_u8(0);

                        lookup.put(uuid_bytes);

                        let ref_item_id =
                            access.get::<[u8], [u8]>(&database.index_db, lookup.as_ref())?;

                        let existing_ref_item_id = existing_reader.as_blob();
                        let existing_ref_item_id_bytes = existing_ref_item_id.0;

                        if ref_item_id == existing_ref_item_id_bytes {
                            item.push(existing_ref_item_id);
                        } else {
                            let ref_item_id = Bytes::copy_from_slice(ref_item_id);

                            let existing_ref_item = access
                                .get::<[u8], [u8]>(&database.item_db, existing_ref_item_id_bytes)?;
                            let ref_item = access
                                .get::<[u8], [u8]>(&database.item_db, ref_item_id.as_ref())?;

                            let existing_root_vec =
                                Reader::get_root(existing_ref_item)?.as_vector();
                            let mut existing_builder =
                                flexbuffers::Builder::new(&flexbuffers::BuilderOptions::SHARE_NONE);
                            let mut existing_builder_vec = existing_builder.start_vector();
                            existing_builder_vec.push(existing_root_vec.idx(0).as_blob());

                            let root_vec = Reader::get_root(ref_item)?.as_vector();
                            let mut builder =
                                flexbuffers::Builder::new(&flexbuffers::BuilderOptions::SHARE_NONE);
                            let mut builder_vec = builder.start_vector();
                            builder_vec.push(uuid);

                            for ref_field in ref_model_fields {
                                if &ref_field.idx == ref_field_idx {
                                    let mut existing_curr_refs =
                                        existing_builder_vec.start_vector();

                                    for curr_ref in
                                        &existing_root_vec.idx(ref_field.idx as usize).as_vector()
                                    {
                                        let curr_ref = curr_ref.as_blob();
                                        let curr_ref_bytes = curr_ref.0;

                                        if curr_ref_bytes != item_key {
                                            existing_curr_refs.push(curr_ref);
                                        }
                                    }

                                    existing_curr_refs.end_vector();

                                    let mut curr_refs = builder_vec.start_vector();

                                    // pushes database ref to front of foreign's refs
                                    curr_refs.push(flexbuffers::Blob(item_key.as_ref()));

                                    for curr_ref in
                                        &root_vec.idx(ref_field.idx as usize).as_vector()
                                    {
                                        let curr_ref = curr_ref.as_blob();
                                        let curr_ref_bytes = curr_ref.0;

                                        if curr_ref_bytes != item_key {
                                            curr_refs.push(curr_ref);
                                        }
                                    }

                                    curr_refs.end_vector();
                                } else {
                                    ref_field.kind.copy_to(
                                        &root_vec.idx(ref_field.idx as usize),
                                        &mut builder_vec,
                                        None,
                                    )?;
                                    ref_field.kind.copy_to(
                                        &existing_root_vec.idx(ref_field.idx as usize),
                                        &mut existing_builder_vec,
                                        None,
                                    )?;
                                }
                            }

                            builder_vec.end_vector();
                            existing_builder_vec.end_vector();

                            let updated_ref_item = builder.view();
                            let updated_existing_ref_item = existing_builder.view();

                            access.put(
                                &database.item_db,
                                existing_ref_item_id_bytes,
                                updated_existing_ref_item,
                                &put::Flags::empty(),
                            )?;
                            access.put(
                                &database.item_db,
                                ref_item_id.as_ref(),
                                updated_ref_item,
                                &put::Flags::empty(),
                            )?;
                        }

                    // many-to-one
                    } else {
                        // preserve existing as children dictate / database-assign to parent

                        let mut ref_ids = item.start_vector();

                        for ref_id in &existing_reader.as_vector() {
                            let ref_id = ref_id.as_blob();
                            ref_ids.push(ref_id);
                        }

                        ref_ids.end_vector();
                    }
                }
            } else {
                if field.indexed == Some(true) {
                    let mut key = BytesMut::new();
                    key.put_u8(model_config.idx);
                    key.put_u8(field.idx);

                    let mut existing_key = key.clone();

                    match field.kind {
                        Kind::String | Kind::Url => {
                            key.put(reader.as_str().as_bytes());
                            existing_key.put(existing_reader.as_str().as_bytes());
                        }
                        Kind::Uuid => {
                            key.put(reader.as_blob().0);
                            existing_key.put(existing_reader.as_blob().0);
                        }
                        _ => {
                            return Err(UpdateError::InvalidIndexKind(field.kind.clone()));
                        }
                    }

                    if key != existing_key {
                        if access
                            .get::<[u8], [u8]>(&database.index_db, key.as_ref())
                            .is_ok()
                        {
                            return Err(UpdateError::IndexCollision);
                        }

                        access.put(
                            &database.index_db,
                            key.as_ref(),
                            item_key.as_ref(),
                            &put::Flags::empty(),
                        )?;

                        access.del_key(&database.index_db, existing_key.as_ref())?;
                    }
                }

                if field.queryable == Some(true) {
                    let mut key = BytesMut::new();
                    key.put_u8(model_config.idx);
                    key.put_u8(field.idx);

                    let mut existing_key = key.clone();

                    match &field.kind {
                        Kind::Bool => {
                            if reader.as_bool() {
                                key.put_u8(1);
                            } else {
                                key.put_u8(0);
                            }

                            if existing_reader.as_bool() {
                                existing_key.put_u8(1);
                            } else {
                                existing_key.put_u8(0);
                            }
                        }
                        Kind::String | Kind::Url => {
                            key.put(reader.as_str().as_bytes());
                            existing_key.put(existing_reader.as_str().as_bytes());
                        }
                        Kind::Uuid => {
                            key.put(reader.as_blob().0);
                            existing_key.put(existing_reader.as_blob().0);
                        }
                        Kind::Timestamp { unit, .. } => match &unit {
                            TimeUnit::Seconds => {
                                key.put_i64(reader.as_i64());
                                existing_key.put_i64(existing_reader.as_i64());
                            }
                        },
                        Kind::U8 => {
                            key.put_u8(reader.as_u8());
                            existing_key.put_u8(existing_reader.as_u8());
                        }
                        Kind::U16 => {
                            key.put_u16(reader.as_u16());
                            existing_key.put_u16(existing_reader.as_u16());
                        }
                        Kind::U32 => {
                            key.put_u32(reader.as_u32());
                            existing_key.put_u32(existing_reader.as_u32());
                        }
                        Kind::U64 => {
                            key.put_u64(reader.as_u64());
                            existing_key.put_u64(existing_reader.as_u64());
                        }
                        Kind::I8 => {
                            key.put_i8(reader.as_i8());
                            existing_key.put_i8(existing_reader.as_i8());
                        }
                        Kind::I16 => {
                            key.put_i16(reader.as_i16());
                            existing_key.put_i16(existing_reader.as_i16());
                        }
                        Kind::I32 => {
                            key.put_i32(reader.as_i32());
                            existing_key.put_i32(existing_reader.as_i32());
                        }
                        Kind::I64 => {
                            key.put_i64(reader.as_i64());
                            existing_key.put_i64(existing_reader.as_i64());
                        }
                        Kind::F32 => {
                            key.put_f32(reader.as_f32());
                            existing_key.put_f32(existing_reader.as_f32());
                        }
                        Kind::F64 => {
                            key.put_f64(reader.as_f64());
                            existing_key.put_f64(existing_reader.as_f64());
                        }
                        _ => {
                            return Err(UpdateError::InvalidQueryKind(field.kind.clone()));
                        }
                    }

                    if key != existing_key {
                        // remove existing
                        let mut builder =
                            flexbuffers::Builder::new(&flexbuffers::BuilderOptions::SHARE_NONE);
                        let mut builder_vec = builder.start_vector();

                        if let Ok(list) =
                            access.get::<[u8], [u8]>(&database.query_db, existing_key.as_ref())
                        {
                            let root = Reader::get_root(list)?;

                            for val in &root.as_vector() {
                                let key = val.as_blob();
                                let key_bytes = key.0;

                                if key_bytes != item_key {
                                    builder_vec.push(key);
                                }
                            }
                        }

                        builder_vec.end_vector();

                        let updated_list = builder.view();

                        access.put(
                            &database.query_db,
                            existing_key.as_ref(),
                            updated_list,
                            &put::Flags::empty(),
                        )?;

                        // add to new
                        let mut builder =
                            flexbuffers::Builder::new(&flexbuffers::BuilderOptions::SHARE_NONE);
                        let mut builder_vec = builder.start_vector();

                        builder_vec.push(flexbuffers::Blob(item_key.as_ref()));

                        if let Ok(list) = access.get::<[u8], [u8]>(&database.query_db, key.as_ref())
                        {
                            let root = Reader::get_root(list)?;
                            for val in &root.as_vector() {
                                builder_vec.push(val.as_blob());
                            }
                        }

                        builder_vec.end_vector();

                        let updated_list = builder.view();

                        access.put(
                            &database.query_db,
                            key.as_ref(),
                            updated_list,
                            &put::Flags::empty(),
                        )?;
                    }
                }

                database.encrypt_compress_copy_to(field, &reader, &mut item)?;
            }
        }

        item.end_vector();
        let item = builder.view();

        if item.len() as u64 > database.limits.max_item_size {
            return Err(UpdateError::ExceedsSizeLimits);
        }

        access.put(
            &database.item_db,
            item_key.as_ref(),
            item,
            &put::Flags::empty(),
        )?;
    }

    txn.commit()?;

    Ok(())
}