mod common;

use chrono::{SubsecRound, TimeDelta};
use gpodder::{AuthStore, Session};
use gpodder_sqlite::SqliteRepository;

#[test]
fn test_create_user() {
    let store = SqliteRepository::in_memory().unwrap();

    let user = store.get_user("test1");
    assert!(user.is_ok());
    assert_eq!(user.unwrap(), None);

    let new_user = store.insert_user("test1", "dummyhash");

    assert!(new_user.is_ok());

    let new_user = new_user.unwrap();
    assert_eq!(new_user.username, "test1");
    assert_eq!(new_user.password_hash, "dummyhash");

    let user = store.get_user("test1");

    assert!(user.is_ok());
    assert_eq!(user.unwrap(), Some(new_user));
}

#[test]
fn test_create_session() {
    let (store, users) = common::setup();

    let session = store.get_session(123).expect("operation shouldn't fail");
    assert_eq!(session, None);

    let new_session = Session {
        id: 123,
        //
        last_seen: chrono::Utc::now().trunc_subsecs(0),
        user: users[0].clone(),
    };

    store
        .insert_session(&new_session)
        .expect("insert session shouldn't fail");

    let session = store.get_session(123).expect("operation shouldn't fail");
    assert_eq!(session, Some(new_session));
}

#[test]
fn test_remove_session() {
    let (store, users) = common::setup();

    let new_session = Session {
        id: 123,
        //
        last_seen: chrono::Utc::now().trunc_subsecs(0),
        user: users[0].clone(),
    };

    store
        .insert_session(&new_session)
        .expect("insert session shouldn't fail");

    assert!(store
        .get_session(123)
        .expect("get session shouldn't fail")
        .is_some());

    store.remove_session(123).expect("remove shouldn't fail");

    assert!(store
        .get_session(123)
        .expect("get session shouldn't fail")
        .is_none());
}

#[test]
fn test_refresh_session() {
    let (store, users) = common::setup();

    let mut new_session = Session {
        id: 123,
        //
        last_seen: chrono::Utc::now().trunc_subsecs(0) - TimeDelta::seconds(10),
        user: users[0].clone(),
    };

    store
        .insert_session(&new_session)
        .expect("insert session shouldn't fail");

    store
        .refresh_session(&new_session, chrono::Utc::now().trunc_subsecs(0))
        .expect("refresh session shouldn't fail");

    new_session.last_seen = chrono::Utc::now().trunc_subsecs(0);

    assert_eq!(
        store.get_session(123).expect("get session shouldn't fail"),
        Some(new_session)
    );
}

#[test]
fn remove_old_sessions() {
    let (store, users) = common::setup();

    let now = chrono::Utc::now().trunc_subsecs(0);
    let timestamps = [
        now,
        now - TimeDelta::seconds(1),
        now - TimeDelta::seconds(2),
    ];

    for (i, ts) in timestamps.into_iter().enumerate() {
        store
            .insert_session(&Session {
                id: i as i64,
                last_seen: ts,
                user: users[0].clone(),
            })
            .expect("insert shouldn't fail");
    }

    assert_eq!(
        store
            .remove_old_sessions(now)
            .expect("remove old sessions shouldn't fail"),
        2
    );

    assert!(matches!(store.get_session(1), Ok(None)));
    assert!(matches!(store.get_session(2), Ok(None)));
    assert_eq!(
        store.get_session(0).expect("get session shouldn't fail"),
        Some(Session {
            id: 0,
            last_seen: now,
            user: users[0].clone(),
        })
    );
}