mod handler;
pub mod subscription;

pub use handler::endpoint;

use crate::database;
use crate::error::{Error, ErrorClass, ErrorKind};
use base64_url;
use crypto::digest::Digest;
use crypto::sha2::Sha256;
use serde::{Deserialize, Serialize};
use serde_json::Value;
use uuid::Uuid;

#[derive(Serialize, Deserialize)]
pub struct InputEnvelope {
    pub endpoint: String,
    pub from_domain: Option<Uuid>,
    pub to_domain: Uuid,
    pub token: Option<String>,
    pub request_nr: Option<u64>,
    pub data: Value,
}

pub struct OutputEnvelope {
    pub error: Option<Error>,
    pub request_nr: Option<u64>,
    pub data: Value,
}

#[derive(Clone, Serialize, Deserialize)]
pub struct Event {
    data: Value,
    id: Option<Uuid>,
}

pub struct Account {
    id: Uuid,
    name: String,
    domain: Uuid,
}

pub struct Session {
    id: Uuid,
    nr: i32,
    account: Option<Account>,
}

pub fn get_account(session: &Option<Session>) -> Result<&Account, Error> {
    match session {
        Some(session) => match &session.account {
            Some(account) => Ok(&account),
            None => {
                return Err(Error::new(
                    ErrorKind::UsimpError,
                    ErrorClass::ClientProtocolError,
                    None,
                ))
            }
        },
        None => {
            return Err(Error::new(
                ErrorKind::UsimpError,
                ErrorClass::ClientProtocolError,
                None,
            ))
        }
    }
}

impl InputEnvelope {
    pub fn respond(&self, data: Value) -> OutputEnvelope {
        OutputEnvelope {
            error: None,
            request_nr: self.request_nr,
            data,
        }
    }
}

impl Session {
    pub async fn from_token(token: &str) -> Result<Self, Error> {
        let backend = database::client().await?;
        let session;
        match backend {
            database::Client::Postgres(client) => {
                let res = client
                    .query(
                        "SELECT session_id, session_nr, a.account_id, account_name, domain_id \
                        FROM account a JOIN session s ON a.account_id = s.account_id \
                        WHERE session_token = $1;",
                        &[&token],
                    )
                    .await?;
                if res.len() == 0 {
                    return Err(Error::new(
                        ErrorKind::InvalidSessionError,
                        ErrorClass::ClientError,
                        None,
                    ));
                }
                let row = &res[0];
                session = Session {
                    id: row.get(0),
                    nr: row.get(1),
                    account: Some(Account {
                        id: row.get(2),
                        name: row.get(3),
                        domain: row.get(4),
                    }),
                };
            }
        }
        Ok(session)
    }
}