//!
//!

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

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> {
    match sql_query(
      "
      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.created_at   as mc_created_at,
        mc.updated_at   as mc_updated_at,
        mc.deleted_at   as mc_deleted_at,

        ml.id           as ml_id,
        ml.name         as ml_name,
        ml.sort_order   as ml_sort_order,
        ml.created_at   as ml_created_at,
        ml.updated_at   as ml_updated_at,
        ml.deleted_at   as ml_deleted_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    

      FROM members as m
        JOIN sites s
          ON s.id = m.site_id
        JOIN member_classes mc
          ON mc.id = m.member_class_id
        JOIN member_levels ml
          ON ml.id = m.member_level_id
        JOIN members _m
          ON _m.id = m.referrer_member_id
      WHERE
        m.id = $1
      ",
    )
    .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_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,
      "
     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.created_at   as mc_created_at,
       mc.updated_at   as mc_updated_at,
       mc.deleted_at   as mc_deleted_at,

       ml.id           as ml_id,
       ml.name         as ml_name,
       ml.sort_order   as ml_sort_order,
       ml.created_at   as ml_created_at,
       ml.updated_at   as ml_updated_at,
       ml.deleted_at   as ml_deleted_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    

     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
     "
    )
    .map_err(|e| diesel::result::Error::QueryBuilderError(e.to_string().into()))?;

    let mut query_where = String::new();

    if let Some(sp) = find_all.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) = find_all.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) = find_all.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) = &find_all.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) = &find_all.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) = &find_all.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) = &find_all.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) = find_all.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 find_all.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),
      },
    }
  }
}