//! # Friends helper
//!
//! @author Pierre Hubert


use crate::constants::database_tables_names::{FRIENDS_TABLE, USERS_TABLE};
use crate::data::error::{ExecError, ResultBoxError};
use crate::data::friend::Friend;
use crate::data::user::UserID;
use crate::helpers::database;
use crate::helpers::database::QueryInfo;

/// Structure used to get a friend information
pub struct GetFriendsQuery {
    target_user: UserID,
    friend_id: Option<UserID>,
}

impl GetFriendsQuery {
    /// Construct a new request
    pub fn new(target_user: &UserID) -> GetFriendsQuery {
        GetFriendsQuery {
            target_user: target_user.clone(),
            friend_id: None,
        }
    }

    /// Get the list of friends
    pub fn exec(self) -> ResultBoxError<Vec<Friend>> {
        get_list(&self)
    }

    /// Get information about a single friendship
    pub fn get_single_friend(mut self, friend_id: &UserID) -> ResultBoxError<Friend> {
        self.friend_id = Some(friend_id.clone());
        get_list(&self)?
            .pop()
            .ok_or(ExecError::boxed_new("Single friend not found!"))
    }
}

/// Get the list of friends of a user
fn get_list(friend_query: &GetFriendsQuery) -> ResultBoxError<Vec<Friend>> {
    let mut query = database::QueryInfo::new(FRIENDS_TABLE)
        .alias("f")
        .cond_user_id("ID_personne", &friend_query.target_user)
        .join(USERS_TABLE, "u", "f.ID_amis = u.ID")
        .add_field("u.last_activity")
        .add_field("f.ID_amis")
        .add_field("f.actif")
        .add_field("f.abonnement")
        .add_field("f.autoriser_post_page")
        .set_order("u.last_activity DESC");

    if let Some(friend_id) = friend_query.friend_id.as_ref() {
        query = query.cond_user_id("ID_amis", friend_id);
    }

    query.exec(db_to_friend)
}

/// Check out whether two users are friend or not
pub fn are_friend(user_one: &UserID, user_two: &UserID) -> ResultBoxError<bool> {
    Ok(database::count(QueryInfo::new(FRIENDS_TABLE)
        .cond_user_id("ID_personne", user_one)
        .cond_user_id("ID_amis", user_two)
        .cond_i64("actif", 1))? > 0)
}

/// Count the number of friends of a user
pub fn count_friends(user_id: &UserID) -> ResultBoxError<usize> {
    QueryInfo::new(FRIENDS_TABLE)
        .cond_user_id("ID_amis", user_id)
        .cond_u32("actif", 1)
        .exec_count()
}

/// Check if a user can create posts on another friend's page
pub fn can_post_texts(user_id: &UserID, target_user: &UserID) -> ResultBoxError<bool> {
    QueryInfo::new(FRIENDS_TABLE)
        .cond_user_id("ID_personne", target_user)
        .cond_user_id("ID_amis", user_id)
        .add_field("autoriser_post_page")
        .query_row(|res| res.get_legacy_bool("autoriser_post_page"))
        .or(Ok(false))
}

/// Turn a database entry into a Friend structure
fn db_to_friend(row: &database::RowResult) -> ResultBoxError<Friend> {
    Ok(Friend {
        friend_id: row.get_user_id("ID_amis")?,
        accepted: row.get_legacy_bool("actif")?,
        following: row.get_legacy_bool("abonnement")?,
        last_activity_time: row.get_u64("last_activity")?,
        can_post_texts: row.get_legacy_bool("autoriser_post_page")?,
    })
}