macltok

use std::fmt;

use ruma::{UserId, api::client::uiaa, serde::JsonObject};

#[cfg(feature = "serde")]

use serde::{Deserialize, Serialize};

#[derive(Eq, PartialEq)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

#[non_exhaustive]

pub enum InteractiveAuth {

    Password {

        password: String,

        session: Option<String>,

    },

    ReCaptcha {

        response: String,

        session: Option<String>,

    },

    Dummy {

        session: Option<String>,

    },

    FallbackAcknowledgement {

        session: String,

    },

    OAuth {

        session: Option<String>,

    },

    Stage {

        auth_type: String,

        session: Option<String>,

        data: JsonObject,

    },

}

impl InteractiveAuth {

    #[must_use]

    pub fn password(password: impl Into<String>, session: Option<String>) -> Self {

        Self::Password {

            password: password.into(),

            session,

        }

    }

    #[must_use]

    pub fn recaptcha(response: impl Into<String>, session: Option<String>) -> Self {

        Self::ReCaptcha {

            response: response.into(),

            session,

        }

    }

    #[must_use]

    pub fn dummy(session: Option<String>) -> Self {

        Self::Dummy { session }

    }

    #[must_use]

    pub fn fallback_acknowledgement(session: impl Into<String>) -> Self {

        Self::FallbackAcknowledgement {

            session: session.into(),

        }

    }

    #[must_use]

    pub fn oauth(session: Option<String>) -> Self {

        Self::OAuth { session }

    }

    #[must_use]

    pub fn stage(auth_type: impl Into<String>, session: Option<String>, data: JsonObject) -> Self {

        Self::Stage {

            auth_type: auth_type.into(),

            session,

            data,

        }

    }

    pub(crate) fn into_sdk(self, user_id: &UserId) -> Result<uiaa::AuthData, String> {

        match self {

            Self::Password { password, session } => {

                let mut password = uiaa::Password::new(user_id.to_owned().into(), password);

                password.session = session;

                Ok(uiaa::AuthData::Password(password))

            }

            Self::ReCaptcha { response, session } => {

                let mut recaptcha = uiaa::ReCaptcha::new(response);

                recaptcha.session = session;

                Ok(uiaa::AuthData::ReCaptcha(recaptcha))

            }

            Self::Dummy { session } => {

                let mut dummy = uiaa::Dummy::new();

                dummy.session = session;

                Ok(uiaa::AuthData::Dummy(dummy))

            }

            Self::FallbackAcknowledgement { session } => {

                Ok(uiaa::AuthData::fallback_acknowledgement(session))

            }

            Self::OAuth { session } => {

                let mut oauth = uiaa::OAuth::new();

                oauth.session = session;

                Ok(uiaa::AuthData::OAuth(oauth))

            }

            Self::Stage {

                auth_type,

                session,

                data,

            } => uiaa::AuthData::new(&auth_type, session, data).map_err(|error| error.to_string()),

        }

    }

}

impl fmt::Debug for InteractiveAuth {

    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {

        match self {

            Self::Password {

                password: _,

                session,

            } => formatter

                .debug_struct("Password")

                .field("session", &session.as_ref().map(|_| "..."))

                .finish_non_exhaustive(),

            Self::ReCaptcha {

                response: _,

                session,

            } => formatter

                .debug_struct("ReCaptcha")

                .field("session", &session.as_ref().map(|_| "..."))

                .finish_non_exhaustive(),

            Self::Dummy { session } => formatter

                .debug_struct("Dummy")

                .field("session", &session.as_ref().map(|_| "..."))

                .finish(),

            Self::FallbackAcknowledgement { session: _ } => formatter

                .debug_struct("FallbackAcknowledgement")

                .field("session", &"...")

                .finish(),

            Self::OAuth { session } => formatter

                .debug_struct("OAuth")

                .field("session", &session.as_ref().map(|_| "..."))

                .finish(),

            Self::Stage {

                auth_type,

                session,

                data: _,

            } => formatter

                .debug_struct("Stage")

                .field("auth_type", auth_type)

                .field("session", &session.as_ref().map(|_| "..."))

                .finish_non_exhaustive(),

        }

    }

}

#[derive(Clone, Eq, PartialEq)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

#[non_exhaustive]

pub struct InteractiveAuthChallenge {

    pub flows: Vec<InteractiveAuthFlow>,

    pub completed: Vec<String>,

    pub parameters_json: Option<String>,

    pub session: Option<String>,

    pub error: Option<InteractiveAuthFailure>,

}

impl fmt::Debug for InteractiveAuthChallenge {

    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {

        formatter

            .debug_struct("InteractiveAuthChallenge")

            .field("flows", &self.flows)

            .field("completed", &self.completed)

            .field(

                "parameters_json",

                &self.parameters_json.as_ref().map(|_| "..."),

            )

            .field("session", &self.session.as_ref().map(|_| "..."))

            .field("error", &self.error)

            .finish()

    }

}

impl From<&uiaa::UiaaInfo> for InteractiveAuthChallenge {

    fn from(info: &uiaa::UiaaInfo) -> Self {

        Self {

            flows: info

                .flows

                .iter()

                .map(|flow| InteractiveAuthFlow {

                    stages: flow

                        .stages

                        .iter()

                        .map(|stage| stage.as_str().to_owned())

                        .collect(),

                })

                .collect(),

            completed: info

                .completed

                .iter()

                .map(|stage| stage.as_str().to_owned())

                .collect(),

            parameters_json: info.params.as_ref().map(|params| params.get().to_owned()),

            session: info.session.clone(),

            error: info

                .auth_error

                .as_ref()

                .map(|error| InteractiveAuthFailure {

                    code: error.kind.errcode().as_str().to_owned(),

                    message: error.message.clone(),

                }),

        }

    }

}

#[derive(Clone, Debug, Eq, PartialEq)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

#[non_exhaustive]

pub struct InteractiveAuthFlow {

    pub stages: Vec<String>,

}

#[derive(Clone, Debug, Eq, PartialEq)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

#[non_exhaustive]

pub struct InteractiveAuthFailure {

    pub code: String,

    pub message: String,

}

#[derive(Clone, Debug, Eq, PartialEq)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

pub enum InteractiveAuthOutcome {

    Completed,

    Challenge(InteractiveAuthChallenge),

}