//!
//!

use super::models;
use crate::repositories;
use diesel::{result::Error, sql_query, RunQueryDsl};

static MEMBER_QUERY: &str = "
SELECT
  m.id                     as m_id,
  m.site_id                as m_site_id,
  m.member_class_id        as m_member_class_id,  
  m.member_level_id        as m_member_level_id,    
  m.username               as m_username,  
  m.password               as m_password,  
  m.nickname               as m_nickname,
  m.mobile_phone_number    as m_mobile_phone_number,
  m.state                  as m_state,
  m.state_changed_at       as m_state_changed_at,
  m.referrer_member_id     as m_referrer_member_id,
  m.referred_count         as m_referred_count,
  m.last_signined_ip       as m_last_signined_ip,
  m.last_signined_at       as m_last_signined_at,
  m.created_at             as m_created_at,
  m.updated_at             as m_updated_at,
  m.deleted_at             as m_deleted_at,    
  
  s.id           as s_id,          
  s.url          as s_url,         
  s.name         as s_name,         
  s.path         as s_path,         
  s.show         as s_show,         
  s.can_use      as s_can_use,         
  s.memo         as s_memo,         
  s.expires_at   as s_expires_at,  
  s.created_at   as s_created_at,  
  s.updated_at   as s_updated_at,  
  
  mc.id           as mc_id,        
  mc.parent_id    as mc_parent_id, 
  mc.name         as mc_name,      
  mc.show         as mc_show,      
  mc.created_at   as mc_created_at,
  mc.updated_at   as mc_updated_at,
  
  ml.id           as ml_id,
  ml.name         as ml_name,
  ml.show         as ml_show,
  ml.sort_order   as ml_sort_order,
  ml.created_at   as ml_created_at,
  ml.updated_at   as ml_updated_at,
  
  _m.id                     as _m_id,
  _m.site_id                as _m_site_id,
  _m.member_class_id        as _m_member_class_id,  
  _m.member_level_id        as _m_member_level_id,    
  _m.username               as _m_username,  
  _m.password               as _m_password,  
  _m.nickname               as _m_nickname,
  _m.mobile_phone_number    as _m_mobile_phone_number,
  _m.state                  as _m_state,
  _m.state_changed_at       as _m_state_changed_at,
  _m.referrer_member_id     as _m_referrer_member_id,
  _m.referred_count         as _m_referred_count,
  _m.last_signined_ip       as _m_last_signined_ip,
  _m.last_signined_at       as _m_last_signined_at,
  _m.created_at             as _m_created_at,
  _m.updated_at             as _m_updated_at,
  _m.deleted_at             as _m_deleted_at,
  
  mba.id                 as mba_id,
  mba.member_id          as mba_member_id,
  mba.bank_id            as mba_bank_id,
  mba.name               as mba_name,
  mba.account_number     as mba_account_number,
  mba.exchange_password  as mba_exchange_password,
  mba.memo               as mba_memo,
  mba.created_at         as mba_created_at,
  mba.updated_at         as mba_updated_at,
  
  _b.id              as _b_id,
  _b.name            as _b_name,
  _b.sort_order      as _b_sort_order,
  _b.show            as _b_show,
  _b.can_use         as _b_can_use,
  _b.memo            as _b_memo,
  _b.created_at      as _b_created_at,
  _b.updated_at      as _b_updated_at

FROM members as m
  INNER JOIN sites s
    ON s.id = m.site_id
  INNER JOIN member_classes mc
    ON mc.id = m.member_class_id
  INNER JOIN member_levels ml
    ON ml.id = m.member_level_id
  LEFT OUTER JOIN members _m
    ON _m.id = m.referrer_member_id
  LEFT OUTER JOIN member_bank_accounts mba
    ON mba.member_id = m.id
  LEFT OUTER JOIN banks _b
    ON _b.id = mba.bank_id
";

pub struct Composition {}

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

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

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

  ///
  pub fn select(
    &self,
    conn: &diesel::PgConnection,
    id: uuid::Uuid,
  ) -> Result<Option<models::MemberModel>, Error> {
    let query = format!(
      "
    {}
    WHERE
      m.id = $1
    ",
      MEMBER_QUERY
    );

    match sql_query(query)
      .bind::<diesel::sql_types::Uuid, _>(id)
      .get_result::<models::MemberModel>(conn)
    {
      Ok(m) => Ok(Some(m)),
      Err(e) => match e {
        diesel::result::Error::NotFound => Ok(None),
        _ => Err(e),
      },
    }
  }

  ///
  pub fn select_by_username(
    &self,
    conn: &diesel::PgConnection,
    username: &str,
  ) -> Result<Option<models::MemberModel>, Error> {
    let query = format!(
      "
    {}
    WHERE
      m.username = $1
    ",
      MEMBER_QUERY
    );

    match sql_query(query)
      .bind::<diesel::sql_types::Text, _>(username)
      .get_result::<models::MemberModel>(conn)
    {
      Ok(m) => Ok(Some(m)),
      Err(e) => match e {
        diesel::result::Error::NotFound => Ok(None),
        _ => Err(e),
      },
    }
  }

  ///
  pub fn select_all(
    &self,
    conn: &diesel::PgConnection,
    find_all: &repositories::member::models::FindAll,
  ) -> Result<Vec<models::MemberModel>, Error> {
    use std::fmt::Write;

    let mut query = String::new();
    write!(&mut query, "{}", MEMBER_QUERY)
      .map_err(|e| diesel::result::Error::QueryBuilderError(e.to_string().into()))?;

    let mut query_where = String::new();

    if let Some(s) = &find_all.search {
      if let Some(sp) = s.site_id {
        if !query_where.is_empty() {
          write!(&mut query_where, " AND ")
            .map_err(|e| diesel::result::Error::QueryBuilderError(e.to_string().into()))?;
        }
        write!(&mut query_where, "m.site_id = '{}'", sp)
          .map_err(|e| diesel::result::Error::QueryBuilderError(e.to_string().into()))?;
      }
      if let Some(sp) = s.member_class_id {
        if !query_where.is_empty() {
          write!(&mut query_where, " AND ")
            .map_err(|e| diesel::result::Error::QueryBuilderError(e.to_string().into()))?;
        }
        write!(&mut query_where, "m.member_class_id = '{}'", sp)
          .map_err(|e| diesel::result::Error::QueryBuilderError(e.to_string().into()))?;
      }
      if let Some(sp) = s.member_level_id {
        if !query_where.is_empty() {
          write!(&mut query_where, " AND ")
            .map_err(|e| diesel::result::Error::QueryBuilderError(e.to_string().into()))?;
        }
        write!(&mut query_where, "m.member_level_id = '{}'", sp)
          .map_err(|e| diesel::result::Error::QueryBuilderError(e.to_string().into()))?;
      }
      if let Some(sp) = &s.username_like {
        if !query_where.is_empty() {
          write!(&mut query_where, " AND ")
            .map_err(|e| diesel::result::Error::QueryBuilderError(e.to_string().into()))?;
        }
        write!(&mut query_where, "m.username like '{}'", sp)
          .map_err(|e| diesel::result::Error::QueryBuilderError(e.to_string().into()))?;
      }
      if let Some(sp) = &s.nickname_like {
        if !query_where.is_empty() {
          write!(&mut query_where, " AND ")
            .map_err(|e| diesel::result::Error::QueryBuilderError(e.to_string().into()))?;
        }
        write!(&mut query_where, "m.nickname like '{}'", sp)
          .map_err(|e| diesel::result::Error::QueryBuilderError(e.to_string().into()))?;
      }
      if let Some(sp) = &s.mobile_phone_number_like {
        if !query_where.is_empty() {
          write!(&mut query_where, " AND ")
            .map_err(|e| diesel::result::Error::QueryBuilderError(e.to_string().into()))?;
        }
        write!(&mut query_where, "m.mobile_phone_number like '{}'", sp)
          .map_err(|e| diesel::result::Error::QueryBuilderError(e.to_string().into()))?;
      }
      if let Some(sp) = &s.last_signined_ip {
        if !query_where.is_empty() {
          write!(&mut query_where, " AND ")
            .map_err(|e| diesel::result::Error::QueryBuilderError(e.to_string().into()))?;
        }
        write!(&mut query_where, "m.last_signined_ip = '{}'", sp)
          .map_err(|e| diesel::result::Error::QueryBuilderError(e.to_string().into()))?;
      }
      if let Some(sp) = s.state {
        if !query_where.is_empty() {
          write!(&mut query_where, " AND ")
            .map_err(|e| diesel::result::Error::QueryBuilderError(e.to_string().into()))?;
        }
        write!(&mut query_where, "m.state = '{:?}'", sp)
          .map_err(|e| diesel::result::Error::QueryBuilderError(e.to_string().into()))?;
      }

      if !query_where.is_empty() {
        write!(&mut query_where, " AND ")
          .map_err(|e| diesel::result::Error::QueryBuilderError(e.to_string().into()))?;
      }
      if s.deleted_at.is_some() {
        write!(&mut query_where, "m.deleted_at IS NOT NULL")
          .map_err(|e| diesel::result::Error::QueryBuilderError(e.to_string().into()))?;
      } else {
        write!(&mut query_where, "m.deleted_at IS NULL")
          .map_err(|e| diesel::result::Error::QueryBuilderError(e.to_string().into()))?;
      }
    }

    if !query_where.is_empty() {
      write!(&mut query, " WHERE {}", query_where)
        .map_err(|e| diesel::result::Error::QueryBuilderError(e.to_string().into()))?;
    }

    println!("query: {}", query);

    match sql_query(query).get_results::<models::MemberModel>(conn) {
      Ok(m) => Ok(m),
      Err(e) => match e {
        diesel::result::Error::NotFound => Ok(vec![]),
        _ => Err(e),
      },
    }
  }
}