use super::schema::users::{self, dsl::*};
use diesel::dsl::Eq;
use diesel::dsl::{AsSelect, Select};
use diesel::expression::AsExpression;
use diesel::helper_types::Filter;
use diesel::prelude::*;
use diesel::sql_types::BigInt;
use diesel::sqlite::Sqlite;
use diesel::sqlite::SqliteConnection;

#[derive(Queryable, Selectable)]
#[diesel(table_name = users)]
pub struct User {
    pub id: i32,
    pub discord_id: i64,
    pub guild_id: i64,
    pub email: String,
    pub first_name: String,
    pub last_name: String,
}

#[derive(Insertable)]
#[diesel(table_name = users)]
pub struct NewUser {
    pub discord_id: i64,
    pub guild_id: i64,
    pub email: String,
    pub first_name: String,
    pub last_name: String,
}

type All = Select<users::table, AsSelect<User, Sqlite>>;
type WithGuild<T> = Eq<guild_id, T>;
type ByGuild<T> = Filter<All, WithGuild<T>>;

impl User {
    pub fn all() -> All {
        users::table.select(User::as_select())
    }

    // pub fn by_guild<T>(guild_id_: T) -> ByGuild<T>
    //     where T: AsExpression<BigInt>
    //  {
    //     Self::all().filter(guild_id.eq(guild_id_))
    // }

    pub fn by_guild_id(guild_id_: i64) -> ByGuild<i64> {
        Self::all().filter(guild_id.eq(guild_id_))
    }

    pub fn get(
        conn: &mut SqliteConnection,
        guild_id_: i64,
        discord_id_: i64,
    ) -> Result<User, diesel::result::Error> {
        Self::all()
            .filter(guild_id.eq(guild_id_))
            .filter(discord_id.eq(discord_id_))
            .first(conn)
    }

    pub fn get_by_id(conn: &mut SqliteConnection, id_: i32) -> Result<User, diesel::result::Error> {
        Self::all().filter(id.eq(id_)).first(conn)
    }
}

impl NewUser {
    pub fn insert(&self, conn: &mut SqliteConnection) -> User {
        diesel::insert_into(users::table)
            .values(self)
            .get_result(conn)
            .expect("fuck")
    }
}