//!
//!
use super::{models, schema::api_kgon_vendors};
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 api_kgon_vendors").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_member: &models::NewVendor,
  ) -> Result<models::Vendor, Error> {
    let inserted = diesel::insert_into(api_kgon_vendors::table)
      .values(new_member)
      .get_result::<models::Vendor>(conn)?;

    Ok(inserted)
  }

  ///
  pub fn upserts(
    &self,
    conn: &diesel::PgConnection,
    upsert_vendors: Vec<models::UpsertVendor>,
  ) -> Result<usize, Error> {
    use api_kgon_vendors::dsl;
    use diesel::pg::upsert::excluded;

    let affected = diesel::insert_into(api_kgon_vendors::table)
      .values(upsert_vendors)
      .on_conflict(dsl::id)
      .do_update()
      .set((
        dsl::company_id.eq(excluded(dsl::company_id)),
        dsl::vendor_id.eq(excluded(dsl::vendor_id)),
        dsl::key.eq(excluded(dsl::key)),
        dsl::name.eq(excluded(dsl::name)),
        dsl::category.eq(excluded(dsl::category)),
        dsl::max_bet_casino.eq(excluded(dsl::max_bet_casino)),
        dsl::max_bet_slot.eq(excluded(dsl::max_bet_slot)),
        dsl::is_enable.eq(excluded(dsl::is_enable)),
        dsl::bet_count.eq(excluded(dsl::bet_count)),
      ))
      .execute(conn)?;

    Ok(affected)
  }

  ///
  pub fn select(
    &self,
    conn: &diesel::PgConnection,
    id: i64,
  ) -> Result<Option<models::Vendor>, Error> {
    match api_kgon_vendors::table
      .find(id)
      .first::<models::Vendor>(conn)
    {
      Ok(m) => Ok(Some(m)),
      Err(e) => match e {
        diesel::result::Error::NotFound => Ok(None),
        _ => Err(e),
      },
    }
  }

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

    if let Some(s) = &find_all.search {
      if let Some(sp) = s.company_id {
        q = q.filter(api_kgon_vendors::dsl::company_id.eq(sp));
      }
      if let Some(sp) = s.vendor_id {
        q = q.filter(api_kgon_vendors::dsl::vendor_id.eq(sp));
      }
      if let Some(sp) = &s.key_like {
        q = q.filter(api_kgon_vendors::dsl::key.like(sp));
      }
      if let Some(sp) = &s.name_like {
        q = q.filter(api_kgon_vendors::dsl::name.like(sp));
      }
      if let Some(sp) = &s.category_like {
        q = q.filter(api_kgon_vendors::dsl::category.like(sp));
      }
      if let Some(sp) = &s.is_enable {
        q = q.filter(api_kgon_vendors::dsl::is_enable.eq(sp));
      }
    }

    q.count().get_result(conn)
  }

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

    if let Some(s) = &find_all.search {
      if let Some(sp) = s.company_id {
        q = q.filter(api_kgon_vendors::dsl::company_id.eq(sp));
      }
      if let Some(sp) = s.vendor_id {
        q = q.filter(api_kgon_vendors::dsl::vendor_id.eq(sp));
      }
      if let Some(sp) = &s.key_like {
        q = q.filter(api_kgon_vendors::dsl::key.like(sp));
      }
      if let Some(sp) = &s.name_like {
        q = q.filter(api_kgon_vendors::dsl::name.like(sp));
      }
      if let Some(sp) = &s.category_like {
        q = q.filter(api_kgon_vendors::dsl::category.like(sp));
      }
      if let Some(sp) = &s.is_enable {
        q = q.filter(api_kgon_vendors::dsl::is_enable.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::pagination::Sort::ASC(property) => match property.as_str() {
            "company_id" => {
              q = q.order_by(api_kgon_vendors::company_id.asc());
            }
            "vendor_id" => {
              q = q.order_by(api_kgon_vendors::vendor_id.asc());
            }
            "key" => {
              q = q.order_by(api_kgon_vendors::key.asc());
            }
            "name" => {
              q = q.order_by(api_kgon_vendors::name.asc());
            }
            "category" => {
              q = q.order_by(api_kgon_vendors::category.asc());
            }
            "max_bet_casino" => {
              q = q.order_by(api_kgon_vendors::max_bet_casino.asc());
            }
            "max_bet_slot" => {
              q = q.order_by(api_kgon_vendors::max_bet_slot.asc());
            }
            "is_enable" => {
              q = q.order_by(api_kgon_vendors::is_enable.asc());
            }
            "bet_count" => {
              q = q.order_by(api_kgon_vendors::bet_count.asc());
            }
            "created_at" => {
              q = q.order_by(api_kgon_vendors::created_at.asc());
            }
            "updated_at" => {
              q = q.order_by(api_kgon_vendors::updated_at.asc());
            }
            _ => {}
          },
          bcr::pagination::Sort::DESC(property) => match property.as_str() {
            "company_id" => {
              q = q.order_by(api_kgon_vendors::company_id.desc());
            }
            "vendor_id" => {
              q = q.order_by(api_kgon_vendors::vendor_id.desc());
            }
            "key" => {
              q = q.order_by(api_kgon_vendors::key.desc());
            }
            "name" => {
              q = q.order_by(api_kgon_vendors::name.desc());
            }
            "category" => {
              q = q.order_by(api_kgon_vendors::category.desc());
            }
            "max_bet_casino" => {
              q = q.order_by(api_kgon_vendors::max_bet_casino.desc());
            }
            "max_bet_slot" => {
              q = q.order_by(api_kgon_vendors::max_bet_slot.desc());
            }
            "is_enable" => {
              q = q.order_by(api_kgon_vendors::is_enable.desc());
            }
            "bet_count" => {
              q = q.order_by(api_kgon_vendors::bet_count.desc());
            }
            "created_at" => {
              q = q.order_by(api_kgon_vendors::created_at.desc());
            }
            "updated_at" => {
              q = q.order_by(api_kgon_vendors::updated_at.desc());
            }
            _ => {}
          },
        };
      }
    }

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

  ///
  pub fn update(
    &self,
    conn: &diesel::PgConnection,
    id: i64,
    modify: &models::ModifyVendor,
  ) -> Result<u64, Error> {
    use api_kgon_vendors::dsl;

    diesel::update(dsl::api_kgon_vendors.filter(dsl::id.eq(id)))
      .set(modify)
      .execute(conn)
      .map(|c| c as u64)
  }

  ///
  pub fn delete(&self, conn: &diesel::PgConnection, id: i64) -> Result<u64, Error> {
    use api_kgon_vendors::dsl;

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