use api::connection_capnp::bootstrap;
pub use api::connection_capnp::bootstrap::Client;
use std::fmt;
use std::fmt::{Formatter, Write};
use std::net::SocketAddr;

use crate::authentication::AuthenticationHandle;
use crate::capnp::authenticationsystem::Authentication;
use crate::session::SessionManager;
use capnp::capability::Promise;
use capnp_rpc::pry;
use rsasl::mechname::Mechname;
use tracing::Span;

/// Cap'n Proto API Handler
pub struct BootCap {
    peer_addr: SocketAddr,
    authentication: AuthenticationHandle,
    sessionmanager: SessionManager,
    span: Span,
}

impl BootCap {
    pub fn new(
        peer_addr: SocketAddr,
        authentication: AuthenticationHandle,
        sessionmanager: SessionManager,
        span: Span,
    ) -> Self {
        Self {
            peer_addr,
            authentication,
            sessionmanager,
            span,
        }
    }
}

impl bootstrap::Server for BootCap {
    fn get_a_p_i_version(
        &mut self,
        _: bootstrap::GetAPIVersionParams,
        _: bootstrap::GetAPIVersionResults,
    ) -> Promise<(), ::capnp::Error> {
        let _guard = self.span.enter();
        let _span = tracing::trace_span!(
            target: "bffh::api",
            "Bootstrap",
            method = "getAPIVersion",
        )
        .entered();
        tracing::trace!("method call");
        Promise::ok(())
    }

    fn get_server_release(
        &mut self,
        _: bootstrap::GetServerReleaseParams,
        mut result: bootstrap::GetServerReleaseResults,
    ) -> Promise<(), ::capnp::Error> {
        let _guard = self.span.enter();
        let _span = tracing::trace_span!(
            target: "bffh::api",
            "Bootstrap",
            method = "getServerRelease",
        )
        .entered();
        tracing::trace!("method call");

        let mut builder = result.get();
        builder.set_name("bffhd");
        builder.set_release(crate::env::VERSION);

        tracing::trace!(
            results.name = "bffhd",
            results.release = crate::env::VERSION,
            "method return"
        );
        Promise::ok(())
    }

    fn mechanisms(
        &mut self,
        _params: bootstrap::MechanismsParams,
        mut result: bootstrap::MechanismsResults,
    ) -> Promise<(), ::capnp::Error> {
        let _guard = self.span.enter();
        let _span = tracing::trace_span!(
            target: "bffh::api",
            "mechanisms",
        )
        .entered();
        tracing::trace!(target: "bffh::api", "method call");

        let builder = result.get();
        let mechs: Vec<_> = self
            .authentication
            .list_available_mechs()
            .into_iter()
            .map(|m| m.as_str())
            .collect();
        let mut mechbuilder = builder.init_mechs(mechs.len() as u32);
        for (i, m) in mechs.iter().enumerate() {
            mechbuilder.set(i as u32, m);
        }

        struct DisMechs<'a>(Vec<&'a str>);
        impl fmt::Display for DisMechs<'_> {
            fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
                f.write_char('[')?;
                let mut first = true;
                for mechanism in self.0.iter() {
                    if first {
                        first = false;
                        f.write_str(mechanism)?;
                    } else {
                        f.write_str(" ,")?;
                        f.write_str(mechanism)?;
                    }
                }
                f.write_char(']')?;
                Ok(())
            }
        }
        tracing::trace!(
            results.mechs = %DisMechs(mechs),
            "method return"
        );
        Promise::ok(())
    }

    fn create_session(
        &mut self,
        params: bootstrap::CreateSessionParams,
        mut result: bootstrap::CreateSessionResults,
    ) -> Promise<(), ::capnp::Error> {
        let _guard = self.span.enter();
        let _span = tracing::trace_span!(
            target: "bffh::api",
            "createSession",
        )
        .entered();

        let params = pry!(params.get());
        let mechanism: &str = pry!(params.get_mechanism());

        tracing::trace!(params.mechanism = mechanism, "method call");

        let mechname = Mechname::new(mechanism.as_bytes());
        let auth = if let Ok(mechname) = mechname {
            if let Ok(session) = self.authentication.start(mechname) {
                Authentication::new(&self.span, mechname, session, self.sessionmanager.clone())
            } else {
                Authentication::invalid_mechanism()
            }
        } else {
            Authentication::invalid_mechanism()
        };

        tracing::trace!(
            results.authentication = %auth,
            "method return"
        );

        let mut builder = result.get();
        builder.set_authentication(capnp_rpc::new_client(auth));

        Promise::ok(())
    }
}