//!
//!
use super::{models, schema::member_roles};
use beteran_common_rust as bcr;
use diesel::prelude::*;
use diesel::result::Error;

///
pub struct Repository {}

impl std::fmt::Debug for Repository {
  fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
    f.debug_struct("Repository of member_roles").finish()
  }
}

impl Default for Repository {
  fn default() -> Self {
    Self::new()
  }
}

impl Repository {
  ///
  pub fn new() -> Repository {
    Repository {}
  }

  ///
  pub fn insert(
    &self,
    conn: &diesel::PgConnection,
    new_resource: &models::NewMemberRole,
  ) -> Result<models::MemberRole, Error> {
    let inserted = diesel::insert_into(member_roles::table)
      .values(new_resource)
      .get_result::<models::MemberRole>(conn)?;

    Ok(inserted)
  }

  ///
  pub fn inserts(
    &self,
    conn: &diesel::PgConnection,
    new_resource_actions: &Vec<models::NewMemberRole>,
  ) -> Result<Vec<models::MemberRole>, Error> {
    let inserted = diesel::insert_into(member_roles::table)
      .values(new_resource_actions)
      .get_results(conn)?;

    Ok(inserted)
  }

  ///
  pub fn select(
    &self,
    conn: &diesel::PgConnection,
    member_id: uuid::Uuid,
    role_id: uuid::Uuid,
  ) -> Result<models::MemberRole, Error> {
    use member_roles::dsl;

    member_roles::table
      .filter(dsl::member_id.eq(member_id).and(dsl::role_id.eq(role_id)))
      .first::<models::MemberRole>(conn)
  }

  ///
  pub fn select_all_count(
    &self,
    conn: &diesel::PgConnection,
    find_all: models::FindAll,
  ) -> Result<i64, Error> {
    let mut q = member_roles::table.into_boxed();

    if let Some(sp) = find_all.role_id {
      q = q.filter(member_roles::dsl::role_id.eq(sp));
    }
    if let Some(sp) = find_all.member_id {
      q = q.filter(member_roles::dsl::member_id.eq(sp));
    }

    q.count().get_result(conn)
  }

  ///
  pub fn select_all(
    &self,
    conn: &diesel::PgConnection,
    find_all: models::FindAll,
  ) -> Result<Vec<models::MemberRole>, Error> {
    let mut q = member_roles::table.into_boxed();

    if let Some(sp) = find_all.role_id {
      q = q.filter(member_roles::dsl::role_id.eq(sp));
    }
    if let Some(sp) = find_all.member_id {
      q = q.filter(member_roles::dsl::member_id.eq(sp));
    }

    if let Some(p) = find_all.pagination {
      let page = p.page.unwrap_or(1);

      if let Some(page_size) = p.page_size {
        q = q.offset(((page - 1) * page_size) as i64);
        q = q.limit(page_size as i64);
      }
    }
    if let Some(orderbys) = find_all.sorts {
      for s in orderbys {
        match s {
          bcr::models::pagination::Sort::ASC(property) => match property.as_str() {
            "role_id" => {
              q = q.order_by(member_roles::role_id.asc());
            }
            "member_id" => {
              q = q.order_by(member_roles::member_id.asc());
            }
            "created_at" => {
              q = q.order_by(member_roles::created_at.asc());
            }
            _ => {}
          },
          bcr::models::pagination::Sort::DESC(property) => match property.as_str() {
            "role_id" => {
              q = q.order_by(member_roles::role_id.desc());
            }
            "member_id" => {
              q = q.order_by(member_roles::member_id.desc());
            }
            "created_at" => {
              q = q.order_by(member_roles::created_at.desc());
            }

            _ => {}
          },
        };
      }
    }

    q.load::<models::MemberRole>(conn)
  }

  ///
  pub fn delete(
    &self,
    conn: &diesel::PgConnection,
    member_id: uuid::Uuid,
    role_id: uuid::Uuid,
  ) -> Result<u64, Error> {
    use member_roles::dsl;

    diesel::delete(
      member_roles::table.filter(dsl::member_id.eq(member_id).and(dsl::role_id.eq(role_id))),
    )
    .execute(conn)
    .map(|c| c as u64)
  }

  ///
  pub fn delete_by_member_id(
    &self,
    conn: &diesel::PgConnection,
    member_id: uuid::Uuid,
  ) -> Result<u64, Error> {
    use member_roles::dsl;

    diesel::delete(member_roles::table.filter(dsl::member_id.eq(member_id)))
      .execute(conn)
      .map(|c| c as u64)
  }
}