use std::{collections::BTreeMap, marker::PhantomData, ops::Deref};

use arc_bytes::serde::Bytes;

use async_trait::async_trait;

use futures::{future::BoxFuture, Future, FutureExt};

use serde::{Deserialize, Serialize};

#[cfg(feature = "multiuser")]

use zeroize::Zeroize;

#[cfg(feature = "multiuser")]

use crate::schema::Nameable;

use crate::{

    document::{

        AnyDocumentId, CollectionDocument, CollectionHeader, Document, HasHeader, OwnedDocument,

    },

    key::Key,

    permissions::Permissions,

    schema::{

        self,

        view::{self, map::MappedDocuments},

        Map, MappedValue, Schema, SchemaName, SerializedCollection,

    },

    transaction::{self, OperationResult, Transaction},

    Error,

};

/// Defines all interactions with a [`schema::Schema`], regardless of whether it

/// is local or remote.

#[async_trait]

pub trait Connection: Send + Sync {

    /// Accesses a collection for the connected [`schema::Schema`].

    /// Inserts a newly created document into the connected [`schema::Schema`]

    /// for the [`Collection`] `C`. If `id` is `None` a unique id will be

    /// generated. If an id is provided and a document already exists with that

    /// id, a conflict error will be returned.

    ///

    /// This is the lower-level API. For better ergonomics, consider using

    /// one of:

    ///

    /// - [`SerializedCollection::push_into()`]

    /// - [`SerializedCollection::insert_into()`]

    /// - [`self.collection::<Collection>().insert()`](Collection::insert)

    /// - [`self.collection::<Collection>().push()`](Collection::push)

            .apply_transaction(Transaction::insert(

        } else {

        }

    /// Updates an existing document in the connected [`schema::Schema`] for the

    /// [`Collection`] `C`. Upon success, `doc.revision` will be updated with

    /// the new revision.

    ///

    /// This is the lower-level API. For better ergonomics, consider using

    /// one of:

    ///

    /// - [`CollectionDocument::update()`]

    /// - [`self.collection::<Collection>().update()`](Collection::update)

            .apply_transaction(Transaction::update(

        } else {

        }

    /// Overwrites an existing document, or inserts a new document. Upon success,

    /// `doc.revision` will be updated with the new revision information.

    ///

    /// This is the lower-level API. For better ergonomics, consider using

    /// one of:

    ///

    /// - [`SerializedCollection::overwrite()`]

    /// - [`SerializedCollection::overwrite_into()`]

    /// - [`self.collection::<Collection>().overwrite()`](Collection::overwrite)

            .apply_transaction(Transaction::overwrite(

        } else {

        }

    /// Retrieves a stored document from [`Collection`] `C` identified by `id`.

    ///

    /// This is the lower-level API. For better ergonomics, consider using

    /// one of:

    ///

    /// - [`SerializedCollection::get()`]

    /// - [`self.collection::<Collection>().get()`](Collection::get)

    async fn get<C, PrimaryKey>(&self, id: PrimaryKey) -> Result<Option<OwnedDocument>, Error>

    where

        C: schema::Collection,

        PrimaryKey: Into<AnyDocumentId<C::PrimaryKey>> + Send;

    /// Retrieves all documents matching `ids`. Documents that are not found

    /// are not returned, but no error will be generated.

    ///

    /// This is the lower-level API. For better ergonomics, consider using

    /// one of:

    ///

    /// - [`SerializedCollection::get_multiple()`]

    /// - [`self.collection::<Collection>().get_multiple()`](Collection::get_multiple)

    async fn get_multiple<C, PrimaryKey, DocumentIds, I>(

        &self,

        ids: DocumentIds,

    ) -> Result<Vec<OwnedDocument>, Error>

    where

        C: schema::Collection,

        DocumentIds: IntoIterator<Item = PrimaryKey, IntoIter = I> + Send + Sync,

        I: Iterator<Item = PrimaryKey> + Send + Sync,

        PrimaryKey: Into<AnyDocumentId<C::PrimaryKey>> + Send + Sync;

    /// Retrieves all documents within the range of `ids`. Documents that are

    /// not found are not returned, but no error will be generated. To retrieve

    /// all documents, pass in `..` for `ids`.

    ///

    /// This is the lower-level API. For better ergonomics, consider using

    /// one of:

    ///

    /// - [`SerializedCollection::all()`]

    /// - [`self.collection::<Collection>().all()`](Collection::all)

    /// - [`SerializedCollection::list()`]

    /// - [`self.collection::<Collection>().list()`](Collection::list)

    async fn list<C, R, PrimaryKey>(

        &self,

        ids: R,

        order: Sort,

        limit: Option<usize>,

    ) -> Result<Vec<OwnedDocument>, Error>

    where

        C: schema::Collection,

        R: Into<Range<PrimaryKey>> + Send,

        PrimaryKey: Into<AnyDocumentId<C::PrimaryKey>> + Send;

    /// Removes a `Document` from the database.

    ///

    /// This is the lower-level API. For better ergonomics, consider using

    /// one of:

    ///

    /// - [`CollectionDocument::delete()`]

    /// - [`self.collection::<Collection>().delete()`](Collection::delete)

        } else {

        }

    /// Initializes [`View`] for [`schema::View`] `V`.

    #[must_use]

    /// Queries for view entries matching [`View`].

    ///

    /// This is the lower-level API. For better ergonomics, consider querying

    /// the view using [`self.view::<View>().query()`](View::query) instead.

    /// The parameters for the query can be customized on the builder returned

    /// from [`Self::view()`].

    #[must_use]

    async fn query<V: schema::SerializedView>(

        &self,

        key: Option<QueryKey<V::Key>>,

        order: Sort,

        limit: Option<usize>,

        access_policy: AccessPolicy,

    ) -> Result<Vec<Map<V::Key, V::Value>>, Error>

    where

        Self: Sized;

    /// Queries for view entries matching [`View`] with their source documents.

    ///

    /// This is the lower-level API. For better ergonomics, consider querying

    /// the view using [`self.view::<View>().query_with_docs()`](View::query_with_docs) instead.

    /// The parameters for the query can be customized on the builder returned

    /// from [`Self::view()`].

    #[must_use]

    async fn query_with_docs<V: schema::SerializedView>(

        &self,

        key: Option<QueryKey<V::Key>>,

        order: Sort,

        limit: Option<usize>,

        access_policy: AccessPolicy,

    ) -> Result<MappedDocuments<OwnedDocument, V>, Error>

    where

        Self: Sized;

    /// Queries for view entries matching [`View`] with their source documents, deserialized.

    ///

    /// This is the lower-level API. For better ergonomics, consider querying

    /// the view using [`self.view::<View>().query_with_collection_docs()`](View::query_with_collection_docs) instead.

    /// The parameters for the query can be customized on the builder returned

    /// from [`Self::view()`].

    #[must_use]

        }

    /// Reduces the view entries matching [`View`].

    ///

    /// This is the lower-level API. For better ergonomics, consider reducing

    /// the view using [`self.view::<View>().reduce()`](View::reduce) instead.

    /// The parameters for the query can be customized on the builder returned

    /// from [`Self::view()`].

    #[must_use]

    async fn reduce<V: schema::SerializedView>(

        &self,

        key: Option<QueryKey<V::Key>>,

        access_policy: AccessPolicy,

    ) -> Result<V::Value, Error>

    where

        Self: Sized;

    /// Reduces the view entries matching [`View`], reducing the values by each

    /// unique key.

    ///

    /// This is the lower-level API. For better ergonomics, consider reducing

    /// the view using

    /// [`self.view::<View>().reduce_grouped()`](View::reduce_grouped) instead.

    /// The parameters for the query can be customized on the builder returned

    /// from [`Self::view()`].

    #[must_use]

    async fn reduce_grouped<V: schema::SerializedView>(

        &self,

        key: Option<QueryKey<V::Key>>,

        access_policy: AccessPolicy,

    ) -> Result<Vec<MappedValue<V::Key, V::Value>>, Error>

    where

        Self: Sized;

    /// Deletes all of the documents associated with this view.

    ///

    /// This is the lower-level API. For better ergonomics, consider querying

    /// the view using [`self.view::<View>().delete_docs()`](View::delete_docs()) instead.

    /// The parameters for the query can be customized on the builder returned

    /// from [`Self::view()`].

    #[must_use]

    async fn delete_docs<V: schema::SerializedView>(

        &self,

        key: Option<QueryKey<V::Key>>,

        access_policy: AccessPolicy,

    ) -> Result<u64, Error>

    where

        Self: Sized;

    /// Applies a [`Transaction`] to the [`schema::Schema`]. If any operation in the

    /// [`Transaction`] fails, none of the operations will be applied to the

    /// [`schema::Schema`].

    async fn apply_transaction(

        &self,

        transaction: Transaction,

    ) -> Result<Vec<OperationResult>, Error>;

    /// Lists executed [`Transaction`]s from this [`schema::Schema`]. By default, a maximum of

    /// 1000 entries will be returned, but that limit can be overridden by

    /// setting `result_limit`. A hard limit of 100,000 results will be

    /// returned. To begin listing after another known `transaction_id`, pass

    /// `transaction_id + 1` into `starting_id`.

    async fn list_executed_transactions(

        &self,

        starting_id: Option<u64>,

        result_limit: Option<usize>,

    ) -> Result<Vec<transaction::Executed>, Error>;

    /// Fetches the last transaction id that has been committed, if any.

    async fn last_transaction_id(&self) -> Result<Option<u64>, Error>;

    /// Compacts the entire database to reclaim unused disk space.

    ///

    /// This process is done by writing data to a new file and swapping the file

    /// once the process completes. This ensures that if a hardware failure,

    /// power outage, or crash occurs that the original collection data is left

    /// untouched.

    ///

    /// ## Errors

    ///

    /// * [`Error::Io`]: an error occurred while compacting the database.

    async fn compact(&self) -> Result<(), crate::Error>;

    /// Compacts the collection to reclaim unused disk space.

    ///

    /// This process is done by writing data to a new file and swapping the file

    /// once the process completes. This ensures that if a hardware failure,

    /// power outage, or crash occurs that the original collection data is left

    /// untouched.

    ///

    /// ## Errors

    ///

    /// * [`Error::CollectionNotFound`]: database `name` does not exist.

    /// * [`Error::Io`]: an error occurred while compacting the database.

    async fn compact_collection<C: schema::Collection>(&self) -> Result<(), crate::Error>;

    /// Compacts the key value store to reclaim unused disk space.

    ///

    /// This process is done by writing data to a new file and swapping the file

    /// once the process completes. This ensures that if a hardware failure,

    /// power outage, or crash occurs that the original collection data is left

    /// untouched.

    ///

    /// ## Errors

    ///

    /// * [`Error::Io`]: an error occurred while compacting the database.

    async fn compact_key_value_store(&self) -> Result<(), crate::Error>;

}

/// Interacts with a collection over a `Connection`.

///

/// These examples in this type use this basic collection definition:

///

/// ```rust

/// use bonsaidb_core::{schema::Collection, Error};

/// use serde::{Deserialize, Serialize};

///

/// #[derive(Debug, Serialize, Deserialize, Default, Collection)]

/// #[collection(name = "MyCollection")]

/// # #[collection(core = bonsaidb_core)]

/// pub struct MyCollection {

///     pub rank: u32,

///     pub score: f32,

/// }

/// ```

pub struct Collection<'a, Cn, Cl> {

    connection: &'a Cn,

    _phantom: PhantomData<Cl>, /* allows for extension traits to be written for collections of specific types */

}

impl<'a, Cn, Cl> Clone for Collection<'a, Cn, Cl> {

}

impl<'a, Cn, Cl> Collection<'a, Cn, Cl>

where

    Cn: Connection,

    Cl: schema::Collection,

{

    /// Creates a new instance using `connection`.

    /// Adds a new `Document<Cl>` with the contents `item`.

    ///

    /// ## Automatic Id Assignment

    ///

    /// This function calls [`SerializedCollection::natural_id()`] to try to

    /// retrieve a primary key value from `item`. If an id is returned, the item

    /// is inserted with that id. If an id is not returned, an id will be

    /// automatically assigned, if possible, by the storage backend, which uses the [`Key`]

    /// trait to assign ids.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: &C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// let inserted_header = db

    ///     .collection::<MyCollection>()

    ///     .push(&MyCollection::default())

    ///     .await?;

    /// println!(

    ///     "Inserted id {} with revision {}",

    ///     inserted_header.id, inserted_header.revision

    /// );

    /// # Ok(())

    /// # })

    /// # }

    /// ```

        } else {

        }

    /// Adds a new `Document<Cl>` with the `contents`.

    ///

    /// ## Automatic Id Assignment

    ///

    /// An id will be automatically assigned, if possible, by the storage backend, which uses

    /// the [`Key`] trait to assign ids.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: &C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// let inserted_header = db.collection::<MyCollection>().push_bytes(vec![]).await?;

    /// println!(

    ///     "Inserted id {} with revision {}",

    ///     inserted_header.id, inserted_header.revision

    /// );

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    /// Adds a new `Document<Cl>` with the given `id` and contents `item`.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: &C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// let inserted_header = db

    ///     .collection::<MyCollection>()

    ///     .insert(42, &MyCollection::default())

    ///     .await?;

    /// println!(

    ///     "Inserted id {} with revision {}",

    ///     inserted_header.id, inserted_header.revision

    /// );

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    /// Adds a new `Document<Cl>` with the the given `id` and `contents`.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: &C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// let inserted_header = db

    ///     .collection::<MyCollection>()

    ///     .insert_bytes(42, vec![])

    ///     .await?;

    /// println!(

    ///     "Inserted id {} with revision {}",

    ///     inserted_header.id, inserted_header.revision

    /// );

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    /// Updates an existing document. Upon success, `doc.revision` will be

    /// updated with the new revision.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: &C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// if let Some(mut document) = db.collection::<MyCollection>().get(42).await? {

    ///     // modify the document

    ///     db.collection::<MyCollection>().update(&mut document);

    ///     println!("Updated revision: {:?}", document.header.revision);

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    /// Overwrites an existing document, or inserts a new document. Upon success,

    /// `doc.revision` will be updated with the new revision information.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: &C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// if let Some(mut document) = db.collection::<MyCollection>().get(42).await? {

    ///     // modify the document

    ///     db.collection::<MyCollection>().overwrite(&mut document);

    ///     println!("Updated revision: {:?}", document.header.revision);

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

        doc.set_collection_header(

        )

    /// Retrieves a `Document<Cl>` with `id` from the connection.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: &C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// if let Some(doc) = db.collection::<MyCollection>().get(42).await? {

    ///     println!(

    ///         "Retrieved bytes {:?} with revision {}",

    ///         doc.contents, doc.header.revision

    ///     );

    ///     let deserialized = MyCollection::document_contents(&doc)?;

    ///     println!("Deserialized contents: {:?}", deserialized);

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    /// Retrieves all documents matching `ids`. Documents that are not found

    /// are not returned, but no error will be generated.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: &C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// for doc in db

    ///     .collection::<MyCollection>()

    ///     .get_multiple([42, 43])

    ///     .await?

    /// {

    ///     println!("Retrieved #{} with bytes {:?}", doc.header.id, doc.contents);

    ///     let deserialized = MyCollection::document_contents(&doc)?;

    ///     println!("Deserialized contents: {:?}", deserialized);

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    /// Retrieves all documents matching the range of `ids`.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: &C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// for doc in db

    ///     .collection::<MyCollection>()

    ///     .list(42..)

    ///     .descending()

    ///     .limit(20)

    ///     .await?

    /// {

    ///     println!("Retrieved #{} with bytes {:?}", doc.header.id, doc.contents);

    ///     let deserialized = MyCollection::document_contents(&doc)?;

    ///     println!("Deserialized contents: {:?}", deserialized);

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    /// Retrieves all documents.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: &C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// for doc in db.collection::<MyCollection>().all().await? {

    ///     println!("Retrieved #{} with bytes {:?}", doc.header.id, doc.contents);

    ///     let deserialized = MyCollection::document_contents(&doc)?;

    ///     println!("Deserialized contents: {:?}", deserialized);

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    /// Removes a `Document` from the database.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: &C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// if let Some(doc) = db.collection::<MyCollection>().get(42).await? {

    ///     db.collection::<MyCollection>().delete(&doc).await?;

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

}

pub(crate) struct ListBuilder<'a, Cn, Cl>

where

    Cl: schema::Collection,

{

    collection: PossiblyOwned<'a, Collection<'a, Cn, Cl>>,

    range: Range<AnyDocumentId<Cl::PrimaryKey>>,

    sort: Sort,

    limit: Option<usize>,

}

pub(crate) enum PossiblyOwned<'a, Cl> {

    Owned(Cl),

    Borrowed(&'a Cl),

}

impl<'a, Cl> Deref for PossiblyOwned<'a, Cl> {

    type Target = Cl;

        }

}

pub(crate) enum ListState<'a, Cn, Cl>

where

    Cl: schema::Collection,

{

    Pending(Option<ListBuilder<'a, Cn, Cl>>),

    Executing(BoxFuture<'a, Result<Vec<OwnedDocument>, Error>>),

}

/// Executes [`Connection::list()`] when awaited. Also offers methods to

/// customize the options for the operation.

#[must_use]

pub struct List<'a, Cn, Cl>

where

    Cl: schema::Collection,

{

    state: ListState<'a, Cn, Cl>,

}

impl<'a, Cn, Cl> List<'a, Cn, Cl>

where

    Cl: schema::Collection,

{

        } else {

        }

    /// Lists documents by id in ascending order.

    /// Lists documents by id in descending order.

    /// Sets the maximum number of results to return.

}

impl<'a, Cn, Cl> Future for List<'a, Cn, Cl>

where

    Cn: Connection,

    Cl: schema::Collection + Unpin,

    Cl::PrimaryKey: Unpin,

{

    type Output = Result<Vec<OwnedDocument>, Error>;

            }

        }

}

/// Parameters to query a [`schema::View`].

///

/// The examples for this type use this view definition:

///

/// ```rust

/// # mod collection {

/// # bonsaidb_core::__doctest_prelude!();

/// # }

/// # use collection::MyCollection;

/// use bonsaidb_core::{

///     define_basic_unique_mapped_view,

///     document::{CollectionDocument, Emit},

///     schema::{

///         CollectionViewSchema, DefaultViewSerialization, Name, ReduceResult, View,

///         ViewMapResult, ViewMappedValue,

///     },

/// };

///

/// #[derive(Debug, Clone, View)]

/// #[view(collection = MyCollection, key = u32, value = f32, name = "scores-by-rank")]

/// # #[view(core = bonsaidb_core)]

/// pub struct ScoresByRank;

///

/// impl CollectionViewSchema for ScoresByRank {

///     type View = Self;

///     fn map(

///         &self,

///         document: CollectionDocument<<Self::View as View>::Collection>,

///     ) -> ViewMapResult<Self::View> {

///         document

///             .header

///             .emit_key_and_value(document.contents.rank, document.contents.score)

///     }

///

///     fn reduce(

///         &self,

///         mappings: &[ViewMappedValue<Self::View>],

///         rereduce: bool,

///     ) -> ReduceResult<Self::View> {

///         if mappings.is_empty() {

///             Ok(0.)

///         } else {

///             Ok(mappings.iter().map(|map| map.value).sum::<f32>() / mappings.len() as f32)

///         }

///     }

/// }

/// ```

pub struct View<'a, Cn, V: schema::SerializedView> {

    connection: &'a Cn,

    /// Key filtering criteria.

    pub key: Option<QueryKey<V::Key>>,

    /// The view's data access policy. The default value is [`AccessPolicy::UpdateBefore`].

    pub access_policy: AccessPolicy,

    /// The sort order of the query.

    pub sort: Sort,

    /// The maximum number of results to return.

    pub limit: Option<usize>,

}

impl<'a, Cn, V> View<'a, Cn, V>

where

    V: schema::SerializedView,

    Cn: Connection,

{

    /// Filters for entries in the view with `key`.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// // score is an f32 in this example

    /// for mapping in db.view::<ScoresByRank>().with_key(42).query().await? {

    ///     assert_eq!(mapping.key, 42);

    ///     println!("Rank {} has a score of {:3}", mapping.key, mapping.value);

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    #[must_use]

    /// Filters for entries in the view with `keys`.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// // score is an f32 in this example

    /// for mapping in db

    ///     .view::<ScoresByRank>()

    ///     .with_keys([42, 43])

    ///     .query()

    ///     .await?

    /// {

    ///     println!("Rank {} has a score of {:3}", mapping.key, mapping.value);

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    #[must_use]

    /// Filters for entries in the view with the range `keys`.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// // score is an f32 in this example

    /// for mapping in db

    ///     .view::<ScoresByRank>()

    ///     .with_key_range(42..)

    ///     .query()

    ///     .await?

    /// {

    ///     assert!(mapping.key >= 42);

    ///     println!("Rank {} has a score of {:3}", mapping.key, mapping.value);

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    #[must_use]

    /// Sets the access policy for queries.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// // score is an f32 in this example

    /// for mapping in db

    ///     .view::<ScoresByRank>()

    ///     .with_access_policy(AccessPolicy::UpdateAfter)

    ///     .query()

    ///     .await?

    /// {

    ///     println!("Rank {} has a score of {:3}", mapping.key, mapping.value);

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    /// Queries the view in ascending order. This is the default sorting

    /// behavior.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// // score is an f32 in this example

    /// for mapping in db.view::<ScoresByRank>().ascending().query().await? {

    ///     println!("Rank {} has a score of {:3}", mapping.key, mapping.value);

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    /// Queries the view in descending order.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// // score is an f32 in this example

    /// for mapping in db.view::<ScoresByRank>().descending().query().await? {

    ///     println!("Rank {} has a score of {:3}", mapping.key, mapping.value);

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    /// Sets the maximum number of results to return.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// // score is an f32 in this example

    /// let mappings = db.view::<ScoresByRank>().limit(10).query().await?;

    /// assert!(mappings.len() <= 10);

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    /// Executes the query and retrieves the results.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// // score is an f32 in this example

    /// for mapping in db.view::<ScoresByRank>().query().await? {

    ///     println!("Rank {} has a score of {:3}", mapping.key, mapping.value);

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    /// Executes the query and retrieves the results with the associated [`Document`s](crate::document::OwnedDocument).

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// for mapping in &db

    ///     .view::<ScoresByRank>()

    ///     .with_key_range(42..=44)

    ///     .query_with_docs()

    ///     .await?

    /// {

    ///     println!(

    ///         "Mapping from #{} with rank: {} and score: {}. Document bytes: {:?}",

    ///         mapping.document.header.id, mapping.key, mapping.value, mapping.document.contents

    ///     );

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    /// Executes the query and retrieves the results with the associated [`CollectionDocument`s](crate::document::CollectionDocument).

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// for mapping in &db

    ///     .view::<ScoresByRank>()

    ///     .with_key_range(42..=44)

    ///     .query_with_collection_docs()

    ///     .await?

    /// {

    ///     println!(

    ///         "Mapping from #{} with rank: {} and score: {}. Deserialized Contents: {:?}",

    ///         mapping.document.header.id, mapping.key, mapping.value, mapping.document.contents

    ///     );

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    /// Executes a reduce over the results of the query

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// // score is an f32 in this example

    /// let score = db.view::<ScoresByRank>().reduce().await?;

    /// println!("Average score: {:3}", score);

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    /// Executes a reduce over the results of the query, grouping by key.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// // score is an f32 in this example

    /// for mapping in db.view::<ScoresByRank>().reduce_grouped().await? {

    ///     println!(

    ///         "Rank {} has an average score of {:3}",

    ///         mapping.key, mapping.value

    ///     );

    /// }

    /// # Ok(())

    /// # })

    /// # }

    /// ```

    /// Deletes all of the associated documents that match this view query.

    ///

    /// ```rust

    /// # bonsaidb_core::__doctest_prelude!();

    /// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

    /// # tokio::runtime::Runtime::new().unwrap().block_on(async {

    /// db.view::<ScoresByRank>().delete_docs().await?;

    /// # Ok(())

    /// # })

    /// # }

    /// ```

}

/// A sort order.

pub enum Sort {

    /// Sort ascending (A -> Z).

    Ascending,

    /// Sort descending (Z -> A).

    Descending,

}

/// Filters a [`View`] by key.

pub enum QueryKey<K> {

    /// Matches all entries with the key provided.

    Matches(K),

    /// Matches all entires with keys in the range provided.

    Range(Range<K>),

    /// Matches all entries that have keys that are included in the set provided.

    Multiple(Vec<K>),

}

#[allow(clippy::use_self)] // clippy is wrong, Self is different because of generic parameters

impl<K: for<'a> Key<'a>> QueryKey<K> {

    /// Converts this key to a serialized format using the [`Key`] trait.

            }

        }

}

#[allow(clippy::use_self)] // clippy is wrong, Self is different because of generic parameters

impl<'a, T> QueryKey<T>

where

    T: AsRef<[u8]>,

{

    /// Deserializes the bytes into `K` via the [`Key`] trait.

            }

        }

}

/// A range type that can represent all std range types and be serialized.

pub struct Range<T> {

    /// The start of the range.

    pub start: Bound<T>,

    /// The end of the range.

    pub end: Bound<T>,

}