use std::collections::HashMap;

use std::marker::PhantomData;

use std::net::{Ipv6Addr, SocketAddr, SocketAddrV6};

use std::path::Path;

use std::sync::Arc;

use bonsaidb_core::api;

use bonsaidb_core::api::ApiName;

#[cfg(feature = "encryption")]

use bonsaidb_core::document::KeyId;

use bonsaidb_core::permissions::{Permissions, Statement};

use bonsaidb_core::schema::Schema;

#[cfg(feature = "compression")]

use bonsaidb_local::config::Compression;

use bonsaidb_local::config::{Builder, KeyValuePersistence, StorageConfiguration};

#[cfg(feature = "encryption")]

use bonsaidb_local::vault::AnyVaultKeyStorage;

use crate::api::{AnyHandler, AnyWrapper, Handler};

use crate::{Backend, Error, NoBackend};

/// Configuration options for [`Server`](crate::Server)

#[must_use]

#[non_exhaustive]

pub struct ServerConfiguration<B: Backend = NoBackend> {

    /// The [`Backend`] for the server.

    pub backend: B,

    /// The DNS name of the server.

    pub server_name: String,

    /// Number of sumultaneous requests a single client can have in flight at a

    /// time. Default value is 16. It is important to have this number be tuned

    /// relative to `request_workers` such that one client cannot overwhelm the

    /// entire queue.

    pub client_simultaneous_request_limit: usize,

    /// Number of simultaneous requests to be processed. Default value is 16.

    pub request_workers: usize,

    /// Configuration options for individual databases.

    pub storage: StorageConfiguration,

    /// The permissions granted to all connections to this server.

    pub default_permissions: DefaultPermissions,

    /// The ACME settings for automatic TLS certificate management.

    #[cfg(feature = "acme")]

    pub acme: AcmeConfiguration,

    pub(crate) custom_apis: HashMap<ApiName, Arc<dyn AnyHandler<B>>>,

}

impl<B: Backend> ServerConfiguration<B> {

    /// Returns a default configuration for the given backend.

    /// Returns a default configuration for the given backend and path.

    /// Sets [`Self::server_name`](Self#structfield.server_name) to `server_name` and returns self.

    /// Sets [`Self::client_simultaneous_request_limit`](Self#structfield.client_simultaneous_request_limit) to `request_limit` and returns self.

    /// Sets [`Self::request_workers`](Self#structfield.request_workers) to `workers` and returns self.

    /// Sets [`Self::default_permissions`](Self#structfield.default_permissions) to `default_permissions` and returns self.

    /// Sets [`AcmeConfiguration::contact_email`] to `contact_email` and returns self.

    #[cfg(feature = "acme")]

    /// Sets [`AcmeConfiguration::directory`] to `directory` and returns self.

    #[cfg(feature = "acme")]

    /// Registers a `handler` for a [`Api`][api::Api]. When an [`Api`][api::Api] is

    /// received by the server, the handler will be invoked

    /// Registers the custom api dispatcher and returns self.

    pub fn with_api<Dispatcher: Handler<Api, B> + 'static, Api: api::Api>(

        mut self,

    ) -> Result<Self, Error> {

}

impl<B> Default for ServerConfiguration<B>

where

    B: Backend + Default,

{

}

#[cfg(feature = "acme")]

mod acme {

    /// The Automated Certificate Management Environment (ACME) configuration.

    pub struct AcmeConfiguration {

        /// The contact email to register with the ACME directory for the account.

        pub contact_email: Option<String>,

        /// The ACME directory to use for registration. The default is

        /// [`LETS_ENCRYPT_PRODUCTION_DIRECTORY`].

        pub directory: String,

    }

    impl Default for AcmeConfiguration {

    }

    pub use async_acme::acme::{LETS_ENCRYPT_PRODUCTION_DIRECTORY, LETS_ENCRYPT_STAGING_DIRECTORY};

}

#[cfg(feature = "acme")]

pub use acme::*;

/// The default permissions to use for all connections to the server.

pub enum DefaultPermissions {

    /// Allow all permissions. Do not use outside of completely trusted environments.

    AllowAll,

    /// A defined set of permissions.

    Permissions(Permissions),

}

impl From<DefaultPermissions> for Permissions {

        }

}

impl From<Permissions> for DefaultPermissions {

}

impl From<Vec<Statement>> for DefaultPermissions {

}

impl From<Statement> for DefaultPermissions {

}

impl<B: Backend> Builder for ServerConfiguration<B> {

    fn with_schema<S: Schema>(mut self) -> Result<Self, bonsaidb_local::Error> {

    #[cfg(feature = "encryption")]

    #[cfg(feature = "encryption")]

    #[cfg(feature = "compression")]

    #[cfg(feature = "password-hashing")]

}

/// Configuration for the BonsaiDb network protocol.

///

/// The BonsaiDb network protocol is built using QUIC, which uses UDP instead of

/// TCP.

#[non_exhaustive]

pub struct BonsaiListenConfig {

    /// The socket port to listen for connections on.

    ///

    /// By default, this is `[::]:5645`.

    pub address: SocketAddr,

    /// If this is set to true, the `SO_REUSEADDR` flag will be set on the

    /// listening socket.

    ///

    /// This informs the operating system that it should allow reusing the exact

    /// same address/port combination in the future, which enables restarting a

    /// BonsaiDb network protocol listener without restarting the process

    /// itself. In general, this is not needed for users in regular deployments,

    /// and is more useful for specific kinds of testing.

    pub reuse_address: bool,

}

impl Default for BonsaiListenConfig {

}

impl BonsaiListenConfig {

    /// Sets the port for the socket address, and returns the updated config.

    #[must_use]

    /// Sets the [`reuse_address`](Self::reuse_address) flag.

    #[must_use]

}

impl From<u16> for BonsaiListenConfig {

}