use arc_bytes::serde::Bytes;

use serde::{Deserialize, Serialize};

mod timestamp;

pub use self::timestamp::Timestamp;

use crate::Error;

mod implementation {

    use arc_bytes::serde::Bytes;

    use async_trait::async_trait;

    use futures::future::BoxFuture;

    use serde::Serialize;

    use crate::{

        keyvalue::{Command, KeyCheck, KeyOperation, KeyStatus, Output, Timestamp},

        Error,

    };

    /// Types for executing get operations.

    pub mod get;

    /// Types for executing increment/decrement operations.

    pub mod increment;

    /// Types for handling key namespaces.

    pub mod namespaced;

    /// Types for executing set operations.

    pub mod set;

    use namespaced::Namespaced;

    use super::{IncompatibleTypeError, Numeric, Value};

    /// Key-Value store methods. The Key-Value store is designed to be a

    /// high-performance, lightweight storage mechanism.

    ///

    /// When compared to Collections, the Key-Value store does not offer

    /// ACID-compliant transactions. Instead, the Key-Value store is made more

    /// efficient by periodically flushing the store to disk rather than during

    /// each operation. As such, the Key-Value store is intended to be used as a

    /// lightweight caching layer. However, because each of the operations it

    /// supports are executed atomically, the Key-Value store can also be

    /// utilized for synchronized locking.

    ///

    /// ## Floating Point Operations

    ///

    /// When using [`KeyValue::set_numeric_key()`] or any numeric operations, if

    /// a [Not a Number (NaN) value][nan] is encountered, [`Error::NotANumber`]

    /// will be returned without allowing the operation to succeed.

    ///

    /// Positive and negative infinity values are allowed, as they do not break

    /// comparison operations.

    ///

    /// [nan]: https://en.wikipedia.org/wiki/NaN

    #[async_trait]

    pub trait KeyValue: Sized + Send + Sync {

        /// Executes a single [`KeyOperation`].

        async fn execute_key_operation(&self, op: KeyOperation) -> Result<Output, Error>;

        /// Sets `key` to `value`. This function returns a builder that is also a

        /// Future. Awaiting the builder will execute [`Command::Set`] with the options

        /// given.

        /// Sets `key` to `bytes`. This function returns a builder that is also

        /// a Future. Awaiting the builder will execute [`Command::Set`] with

        /// the options given.

        /// Sets `key` to `value`. This stores the value as a `Numeric`,

        /// enabling atomic math operations to be performed on this key. This

        /// function returns a builder that is also a Future. Awaiting the

        /// builder will execute [`Command::Set`] with the options given.

        /// Increments `key` by `value`. The value stored must be a `Numeric`,

        /// otherwise an error will be returned. The result of the increment

        /// will be the `value`'s type. For example, if the stored value is

        /// currently a `u64`, but `value` is a `f64`, the current value will be

        /// converted to an `f64`, and the stored value will be an `f64`.

        /// Decrements `key` by `value`. The value stored must be a `Numeric`,

        /// otherwise an error will be returned. The result of the decrement

        /// will be the `value`'s type. For example, if the stored value is

        /// currently a `u64`, but `value` is a `f64`, the current value will be

        /// converted to an `f64`, and the stored value will be an `f64`.

        /// Gets the value stored at `key`. This function returns a builder that is also a

        /// Future. Awaiting the builder will execute [`Command::Get`] with the options

        /// given.

        /// Deletes the value stored at `key`.

            {

            }

        /// The current namespace.

        /// Access this Key-Value store within a namespace. When using the returned

        /// [`Namespaced`] instance, all keys specified will be separated into their

        /// own storage designated by `namespace`.

    }

    enum BuilderState<'a, T, V> {

        Pending(Option<T>),

        Executing(BoxFuture<'a, V>),

    }

    #[allow(clippy::redundant_pub_crate)]

    pub(crate) enum PendingValue<'a, V> {

        Bytes(&'a [u8]),

        Serializeable(&'a V),

        Numeric(Numeric),

    }

    impl<'a, V> PendingValue<'a, V>

    where

        V: Serialize,

    {

            }

    }

}

pub use implementation::*;

/// Checks for existing keys.

pub enum KeyCheck {

    /// Only allow the operation if an existing key is present.

    OnlyIfPresent,

    /// Only allow the opeartion if the key isn't present.

    OnlyIfVacant,

}

/// An operation performed on a key.

pub struct KeyOperation {

    /// The namespace for the key.

    pub namespace: Option<String>,

    /// The key to operate on.

    pub key: String,

    /// The command to execute.

    pub command: Command,

}

/// Commands for a key-value store.

pub enum Command {

    /// Set a key/value pair.

    Set(SetCommand),

    /// Get the value from a key.

    Get {

        /// Remove the key after retrieving the value.

        delete: bool,

    },

    /// Increment a numeric key. Returns an error if the key cannot be

    /// deserialized to the same numeric type as `amount`. If `saturating` is

    /// true, overflows will be prevented and the value will remain within the

    /// numeric bounds.

    Increment {

        /// The amount to increment by.

        amount: Numeric,

        /// If true, the result will be constrained to the numerical bounds of

        /// the type of `amount`.

        saturating: bool,

    },

    /// Decrement a numeric key. Returns an error if the key cannot be

    /// deserialized to the same numeric type as `amount`. If `saturating` is

    /// true, overflows will be prevented and the value will remain within the

    /// numeric bounds.

    Decrement {

        /// The amount to increment by.

        amount: Numeric,

        /// If true, the result will be constrained to the numerical bounds of

        /// the type of `amount`.

        saturating: bool,

    },

    /// Delete a key.

    Delete,

}

/// Set a key/value pair.

pub struct SetCommand {

    /// The value.

    pub value: Value,

    /// If set, the key will be set to expire automatically.

    pub expiration: Option<Timestamp>,

    /// If true and the key already exists, the expiration will not be

    /// updated. If false and an expiration is provided, the expiration will

    /// be set.

    pub keep_existing_expiration: bool,

    /// Conditional checks for whether the key is already present or not.

    pub check: Option<KeyCheck>,

    /// If true and the key already exists, the existing key will be returned if overwritten.

    pub return_previous_value: bool,

}

/// A value stored in a key.

pub enum Value {

    /// A value stored as a byte array.

    Bytes(Bytes),

    /// A numeric value.

    Numeric(Numeric),

}

impl Value {

    /// Validates this value to ensure it is safe to store.

        }

    /// Deserializes the bytes contained inside of this value. Returns an error

    /// if this value doesn't contain bytes.

        }

    /// Returns this value as an `i64`, allowing for precision to be lost if the type was not an `i64` originally. If saturating is true, the conversion will not allow overflows. Returns None if the value is bytes.

    #[must_use]

        }

    /// Returns this value as an `u64`, allowing for precision to be lost if the type was not an `u64` originally. If saturating is true, the conversion will not allow overflows. Returns None if the value is bytes.

    #[must_use]

        }

    /// Returns this value as an `f64`, allowing for precision to be lost if the type was not an `f64` originally. Returns None if the value is bytes.

    #[must_use]

        }

    /// Returns this numeric as an `i64`, allowing for precision to be lost if the type was not an `i64` originally. Returns None if the value is bytes.

    #[must_use]

        }

    /// Returns this numeric as an `u64`, allowing for precision to be lost if the type was not an `u64` originally. Returns None if the value is bytes.

    #[must_use]

        }

    /// Returns this numeric as an `f64`, allowing for precision to be lost if the type was not an `f64` originally. Returns None if the value is bytes.

    #[must_use]

        }

}

/// A numerical value.

pub enum Numeric {

    /// A 64-bit signed integer.

    Integer(i64),

    /// A 64-bit unsigned integer.

    UnsignedInteger(u64),

    /// A 64-bit floating point number.

    Float(f64),

}

impl Numeric {

    /// Ensures this value contains a valid value.

    ///

    /// # Errors

    ///

    /// [`Error::NotANumber`] is returned if this contains a NaN floating point

    /// value.

    pub fn validate(self) -> Result<Self, Error> {

    /// Returns this numeric as an `i64`. If this conversion cannot be done

    /// without losing precision or overflowing, None will be returned.

    #[must_use]

    #[allow(clippy::cast_possible_truncation)]

                } else {

                }

            }

        }

    /// Returns this numeric as an `i64`, allowing for precision to be lost if

    /// the type was not an `i64` originally. If saturating is true, the

    /// conversion will not allow overflows.

    #[must_use]

    #[allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation)]

                } else {

                }

            }

        }

    /// Returns this numeric as an `u64`. If this conversion cannot be done

    /// without losing precision or overflowing, None will be returned.

    #[must_use]

    #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]

                } else {

                }

            }

        }

    /// Returns this numeric as an `u64`, allowing for precision to be lost if

    /// the type was not an `i64` originally. If saturating is true, the

    /// conversion will not allow overflows.

    #[must_use]

    #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]

                } else {

                }

            }

        }

    /// Returns this numeric as an `f64`. If this conversion cannot be done

    /// without losing precision, None will be returned.

    #[must_use]

    #[allow(clippy::cast_precision_loss)]

                } else {

                }

            }

                {

                } else {

                }

            }

        }

    /// Returns this numeric as an `f64`, allowing for precision to be lost if

    /// the type was not an `f64` originally.

    #[must_use]

    #[allow(clippy::cast_precision_loss)]

        }

}

/// A conversion between numeric types wasn't supported.

#[error("incompatible numeric type")]

pub struct IncompatibleTypeError;

impl From<f64> for Numeric {

}

impl From<i64> for Numeric {

}

impl From<u64> for Numeric {

}

#[allow(clippy::fallible_impl_from)]

impl TryFrom<Numeric> for f64 {

    type Error = IncompatibleTypeError;

    fn try_from(value: Numeric) -> Result<Self, IncompatibleTypeError> {

        } else {

        }

}

#[allow(clippy::fallible_impl_from)]

impl TryFrom<Numeric> for u64 {

    type Error = IncompatibleTypeError;

    fn try_from(value: Numeric) -> Result<Self, IncompatibleTypeError> {

        } else {

        }

}

#[allow(clippy::fallible_impl_from)]

impl TryFrom<Numeric> for i64 {

    type Error = IncompatibleTypeError;

    fn try_from(value: Numeric) -> Result<Self, IncompatibleTypeError> {

        } else {

        }

}

/// The result of a [`KeyOperation`].

pub enum Output {

    /// A status was returned.

    Status(KeyStatus),

    /// A value was returned.

    Value(Option<Value>),

}

/// The status of an operation on a Key.

pub enum KeyStatus {

    /// A new key was inserted.

    Inserted,

    /// An existing key was updated with a new value.

    Updated,

    /// A key was deleted.

    Deleted,

    /// No changes were made.

    NotChanged,

}