//! Browser sessions as server-side records (oxygenhub#223).

use super::{now_ms, Pool};

use sqlx::FromRow;

/// A session ends after this long unused.

pub const IDLE_MS: i64 = 14 * 24 * 60 * 60_000;

/// And after this long whatever happens.

pub const ABSOLUTE_MS: i64 = 30 * 24 * 60 * 60_000;

/// `seen_ms` is written at most this often per session.

const TOUCH_EVERY_MS: i64 = 60_000;

#[derive(Clone, Debug, FromRow)]

pub struct Session {

    pub id: i64,

    pub account_id: i64,

    pub salt: String,

    pub created_ms: i64,

    pub seen_ms: i64,

    pub address: String,

    pub agent: String,

    /// When it last proved a second factor, or signed in (oxygenhub#356):

    /// the sudo step asks again once this is older than its window.

    pub second_factor_ms: i64,

}

impl Session {

    /// Whether it is still good at `now`, for an account whose salt is `salt`.

    pub fn live(&self, salt: &str, now: i64) -> bool {

        self.salt == salt && now - self.seen_ms < IDLE_MS && now - self.created_ms < ABSOLUTE_MS

    }

}

const COLUMNS: &str = "id, account_id, salt, created_ms, seen_ms, address, agent, second_factor_ms";

pub async fn create(pool: &Pool, account_id: i64, hash: &str, salt: &str) -> sqlx::Result<i64> {

    let now = now_ms();

    // Signing in is as fresh as proof gets (oxygenhub#356).

    sqlx::query_scalar(

        "INSERT INTO sessions (account_id, hash, salt, created_ms, seen_ms, second_factor_ms) VALUES ($1, $2, $3, $4, $5, $6) RETURNING id",

    )

    .bind(account_id)

    .bind(hash)

    .bind(salt)

    .bind(now)

    .bind(now)

    .bind(now)

    .fetch_one(pool)

    .await

}

/// The session proved a second factor (or the password, for an account

/// without one) at `now`: the sudo step lets it through for a while.

pub async fn mark_second_factor(pool: &Pool, session_id: i64, now: i64) -> sqlx::Result<()> {

    sqlx::query("UPDATE sessions SET second_factor_ms = $1 WHERE id = $2").bind(now).bind(session_id).execute(pool).await?;

    Ok(())

}

pub async fn by_id(pool: &Pool, id: i64) -> sqlx::Result<Option<Session>> {

    sqlx::query_as(&format!("SELECT {COLUMNS} FROM sessions WHERE id = $1")).bind(id).fetch_optional(pool).await

}

pub async fn by_hash(pool: &Pool, hash: &str) -> sqlx::Result<Option<Session>> {

    sqlx::query_as(&format!("SELECT {COLUMNS} FROM sessions WHERE hash = $1")).bind(hash).fetch_optional(pool).await

}

/// Note a use: the time (at most once a minute) and, the first time, the

/// address and browser it came from.

pub async fn touch(pool: &Pool, s: &Session, address: &str, agent: &str, now: i64) -> sqlx::Result<()> {

    if s.agent.is_empty() && s.address.is_empty() && (!agent.is_empty() || !address.is_empty()) {

        sqlx::query("UPDATE sessions SET seen_ms = $1, address = $2, agent = $3 WHERE id = $4")

            .bind(now)

            .bind(address)

            .bind(agent)

            .bind(s.id)

            .execute(pool)

            .await?;

    } else if now - s.seen_ms >= TOUCH_EVERY_MS {

        sqlx::query("UPDATE sessions SET seen_ms = $1 WHERE id = $2").bind(now).bind(s.id).execute(pool).await?;

    }

    Ok(())

}

/// An account's live sessions, most recently used first.

pub async fn of_account(pool: &Pool, account_id: i64, salt: &str) -> sqlx::Result<Vec<Session>> {

    let now = now_ms();

    let all: Vec<Session> = sqlx::query_as(&format!("SELECT {COLUMNS} FROM sessions WHERE account_id = $1 ORDER BY seen_ms DESC"))

        .bind(account_id)

        .fetch_all(pool)

        .await?;

    Ok(all.into_iter().filter(|s| s.live(salt, now)).collect())

}

/// End one session of an account's; whether there was one.

pub async fn end(pool: &Pool, account_id: i64, id: i64) -> sqlx::Result<bool> {

    let r = sqlx::query("DELETE FROM sessions WHERE id = $1 AND account_id = $2").bind(id).bind(account_id).execute(pool).await?;

    Ok(r.rows_affected() > 0)

}

pub async fn end_hash(pool: &Pool, hash: &str) -> sqlx::Result<()> {

    sqlx::query("DELETE FROM sessions WHERE hash = $1").bind(hash).execute(pool).await?;

    Ok(())

}

/// Every session of an account's but `keep`.

pub async fn end_others(pool: &Pool, account_id: i64, keep: i64) -> sqlx::Result<()> {

    sqlx::query("DELETE FROM sessions WHERE account_id = $1 AND id != $2").bind(account_id).bind(keep).execute(pool).await?;

    Ok(())

}

/// Forget sessions that can no longer be used; how many.

pub async fn sweep(pool: &Pool) -> sqlx::Result<u64> {

    let now = now_ms();

    let r = sqlx::query(

        "DELETE FROM sessions WHERE seen_ms < $1 OR created_ms < $2 \

         OR salt != (SELECT session_salt FROM accounts WHERE accounts.id = sessions.account_id)",

    )

    .bind(now - IDLE_MS)

    .bind(now - ABSOLUTE_MS)

    .execute(pool)

    .await?;

    Ok(r.rows_affected())

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn a_session_ends_on_a_new_salt_when_idle_or_when_old() {

        let t0 = 1_000_000_000_000;

        let s = Session {

            id: 1,

            account_id: 1,

            salt: "a".into(),

            created_ms: t0,

            seen_ms: t0,

            address: String::new(),

            agent: String::new(),

            second_factor_ms: t0,

        };

        assert!(s.live("a", t0 + 1000));

        assert!(!s.live("b", t0 + 1000), "a new salt: signed out everywhere");

        assert!(!s.live("a", t0 + IDLE_MS), "unused for 14 days");

        let busy = Session { seen_ms: t0 + ABSOLUTE_MS - 1000, ..s.clone() };

        assert!(busy.live("a", t0 + ABSOLUTE_MS - 1));

        assert!(!busy.live("a", t0 + ABSOLUTE_MS), "30 days, however busy");

    }

}