use arc_bytes::serde::Bytes;

use serde::{Deserialize, Serialize};

use crate::{

    connection::{AsyncLowLevelConnection, LowLevelConnection},

    document::{CollectionHeader, DocumentId, Header},

    schema::{CollectionName, SerializedCollection},

    Error,

};

/// A list of operations to execute as a single unit. If any operation fails,

/// all changes are aborted. Transactions are ACID-compliant. ACID stands for:

///

/// - Atomic: All transactions are atomically applied. Readers outside of the

///   active transaction will never be able to read partially written data. In

///   BonsaiDb, readers are not blocked while writes are happening -- reads will

///   continue to read the existing value until the transaction is fully

///   executed. Once the transaction is fully executed, all future queries will

///   reflect the updated state immediately.

///

/// - Consistent: All transactions will be applied only if the data model is

///   able to remain fully consistent. This means that all constraints, such as

///   unique view keys, are validated before a transaction is allowed to be

///   committed.

///

/// - Isolated: Each transaction is executed in an isolated environment.

///   Currently, BonsaiDb does not offer interactive transactions, so this is

///   easily guaranteed. When BonsaiDb eventually has interactive transactions,

///   the transaction will have a fully isolated state until it is committed. No

///   two transactions can be affected by each other's changes.

///

///   In the event of a transaction being aborted or a power outage occurs while

///   a transaction is being applied, this isolation ensures that once BonsaiDb

///   opens the database again, the database will reflect the most recently

///   committed.

///

/// - Durable: When the transaction apply function has finished exectuing,

///   BonsaiDb guarantees that all data has been confirmed by the operating

///   system as being fully written to disk. This ensures that in the event of a

///   power outage, no data that has been confirmed will be lost.

///

/// When using one of the high-level functions to push/insert/update/delete

/// documents, behind the scenes single-[`Operation`] `Transaction`s are

/// applied. To ensure multiple changes happen in the same database operation,

/// multiple operations can be added to a `Transaction`:

///

/// ```rust

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

/// # use bonsaidb_core::connection::Connection;

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

/// use bonsaidb_core::transaction::{Operation, Transaction};

/// let mut tx = Transaction::new();

/// tx.push(Operation::push_serialized::<MyCollection>(

///     &MyCollection::default(),

/// )?);

/// tx.push(Operation::push_serialized::<MyCollection>(

///     &MyCollection::default(),

/// )?);

/// let results = tx.apply(db)?;

/// assert_eq!(results.len(), 2);

/// println!("Two new documents inserted: {results:?}");

/// # Ok(())

/// # }

/// ```

#[must_use]

pub struct Transaction {

    /// The operations in this transaction.

    pub operations: Vec<Operation>,

}

impl Transaction {

    /// Returns a new, empty transaction.

    /// Adds an operation to the transaction.

    /// Appends an operation to the transaction and returns self.

    /// Applies the transaction to the `database`, returning the results of the

    /// operations. All operations will succeed or none will be performed and an

    /// error will be returned.

    /// Applies the transaction to the `database`, returning the results of the

    /// operations. All operations will succeed or none will be performed and an

    /// error will be returned.

}

impl From<Operation> for Transaction {

}

impl Transaction {

    /// Inserts a new document with `contents` into `collection`.  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.

    /// Updates a document in `collection`.

    /// Overwrites a document in `collection`. If a document with `id` exists,

    /// it will be overwritten. If a document with `id` doesn't exist, it will

    /// be created.

    /// Deletes a document from a `collection`.

}

/// A single operation performed on a `Collection`.

#[must_use]

pub struct Operation {

    /// The id of the `Collection`.

    pub collection: CollectionName,

    /// The command being performed.

    pub command: Command,

}

impl Operation {

    /// Inserts a new document with `contents` into `collection`.  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.

    /// Inserts a new document with the serialized representation of `contents`

    /// into `collection`. 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.

    /// Pushes a new document with the serialized representation of `contents`

    /// into `collection`.

    ///

    /// ## Automatic ID Assignment

    ///

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

    /// retrieve a primary key value from `contents`. 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`](crate::key::Key) trait to assign ids.

    /// Updates a document in `collection`.

    /// Updates a document with the serialized representation of `contents` in

    /// `collection`.

        Ok(Self::update(

        ))

    /// Overwrites a document in `collection`. If a document with `id` exists,

    /// it will be overwritten. If a document with `id` doesn't exist, it will

    /// be created.

    /// Overwrites a document with the serialized representation of `contents`

    /// in `collection`. If a document with `id` exists, it will be overwritten.

    /// If a document with `id` doesn't exist, it will be created.

        Ok(Self::overwrite(

        ))

    /// Deletes a document from a `collection`.

}

/// A command to execute within a `Collection`.

pub enum Command {

    /// Inserts a new document containing `contents`.

    Insert {

        /// An optional id for the document. If this is `None`, a unique id will

        /// be generated. If this is `Some()` and a document already exists with

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

        id: Option<DocumentId>,

        /// The initial contents of the document.

        contents: Bytes,

    },

    /// Update an existing `Document` identified by `header`. `header.revision` must match

    /// the currently stored revision on the `Document`. If it does not, the

    /// command fill fail with a `DocumentConflict` error.

    Update {

        /// The header of the `Document`. The revision must match the current

        /// document.

        header: Header,

        /// The new contents to store within the `Document`.

        contents: Bytes,

    },

    /// Overwrite an existing `Document` identified by `id`. The revision will

    /// not be checked before the document is updated. If the document does not

    /// exist, it will be created.

    Overwrite {

        /// The id of the document to overwrite.

        id: DocumentId,

        /// The new contents to store within the `Document`.

        contents: Bytes,

    },

    /// Delete an existing `Document` identified by `id`. `revision` must match

    /// the currently stored revision on the `Document`. If it does not, the

    /// command fill fail with a `DocumentConflict` error.

    Delete {

        /// The current header of the `Document`.

        header: Header,

    },

}

/// Information about the result of each `Operation` in a transaction.

pub enum OperationResult {

    /// An operation succeeded but had no information to output.

    Success,

    /// A `Document` was updated.

    DocumentUpdated {

        /// The id of the `Collection` of the updated `Document`.

        collection: CollectionName,

        /// The header of the updated `Document`.

        header: Header,

    },

    /// A `Document` was deleted.

    DocumentDeleted {

        /// The id of the `Collection` of the deleted `Document`.

        collection: CollectionName,

        /// The id of the deleted `Document`.

        id: DocumentId,

    },

}

/// Details about an executed transaction.

pub struct Executed {

    /// The id of the transaction.

    pub id: u64,

    /// A list of containing ids of `Documents` changed.

    pub changes: Changes,

}

/// A list of changes.

pub enum Changes {

    /// A list of changed documents.

    Documents(DocumentChanges),

    /// A list of changed keys.

    Keys(Vec<ChangedKey>),

}

impl Changes {

    /// Returns the list of documents changed in this transaction, or None if

    /// the transaction was not a document transaction.

    #[must_use]

    pub const fn documents(&self) -> Option<&DocumentChanges> {

        } else {

        }

    /// Returns the list of keys changed in this transaction, or None if the

    /// transaction was not a `KeyValue` transaction.

    #[must_use]

    pub fn keys(&self) -> Option<&[ChangedKey]> {

        } else {

        }

}

/// A list of changed documents.

pub struct DocumentChanges {

    /// All of the collections changed.

    pub collections: Vec<CollectionName>,

    /// The individual document changes.

    pub documents: Vec<ChangedDocument>,

}

impl DocumentChanges {

    /// Returns the changed document and the name of the collection the change

    /// happened to.

    #[must_use]

    /// Returns the number of changes in this collection.

    #[must_use]

    /// Returns true if there are no changes.

    #[must_use]

    /// Returns an interator over all of the changed documents.

}

/// An iterator over [`DocumentChanges`].

#[must_use]

pub struct DocumentChangesIter<'a> {

    changes: &'a DocumentChanges,

    index: Option<usize>,

}

impl<'a> Iterator for DocumentChangesIter<'a> {

    type Item = (&'a CollectionName, &'a ChangedDocument);

}

/// A draining iterator over [`ChangedDocument`]s.

#[must_use]

pub struct DocumentChangesIntoIter {

    collections: Vec<CollectionName>,

    documents: std::vec::IntoIter<ChangedDocument>,

}

impl Iterator for DocumentChangesIntoIter {

    type Item = (CollectionName, ChangedDocument);

}

impl IntoIterator for DocumentChanges {

    type Item = (CollectionName, ChangedDocument);

    type IntoIter = DocumentChangesIntoIter;

}

        }

    }

        }

    }

/// A record of a changed document.

pub struct ChangedDocument {

    /// The index of the `CollectionName` within the `collections` field of [`Changes::Documents`].

    pub collection: u16,

    /// The id of the changed `Document`.

    pub id: DocumentId,

    /// If the `Document` has been deleted, this will be `true`.

    pub deleted: bool,

}

/// A record of a changed `KeyValue` entry.

pub struct ChangedKey {

    /// The namespace of the key.

    pub namespace: Option<String>,

    /// The key that was changed.

    pub key: String,

    /// True if the key was deleted.

    pub deleted: bool,

}