/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package com.triz.trizservice.service.impl;

import com.triz.trizservice.modeles.Centre;
import com.triz.trizservice.modeles.Consultation;
import com.triz.trizservice.modeles.Medecin;
import com.triz.trizservice.modeles.MedecinSpecialiste;
import com.triz.trizservice.service.DaoService;
import com.triz.trizservice.modeles.ServiceFonctiongroupe;
import com.triz.trizservice.modeles.ServiceFonctionnaliter;
import com.triz.trizservice.modeles.ServiceGroupe;
import com.triz.trizservice.modeles.ServiceIncrementation;
import com.triz.trizservice.modeles.ServiceMember;
import com.triz.trizservice.modeles.ServiceUser;
import com.triz.trizservice.modeles.ServicehistoriqueConnection;
import com.triz.trizservice.modeles.ServiceHistoriqueManipulation;
import com.triz.trizservice.modeles.ServiceUserCentre;
import com.triz.trizservice.modeles.SpecialiteMedicale;
import com.triz.trizservice.modeles.Wilaya;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
import java.util.UUID;
import javax.annotation.Resource;
import javax.persistence.NoResultException;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.stereotype.Repository;

/**
 *
 * @author abder_000
 */
@Repository()
public class DaoServiceImpl implements DaoService {

    @Resource(name = "sessionFactory")
    SessionFactory sessionFactory;

    private Session getCurrentSession() {
        if (sessionFactory.getCurrentSession() == null) {
            return sessionFactory.openSession();
        }
        sessionFactory.getCurrentSession().clear();
        return sessionFactory.getCurrentSession();
    }

    @Override
    public List<ServiceUser> getAllUsers() {
        return getCurrentSession().createCriteria(ServiceUser.class).list();
    }

    @Override
    public List<ServiceFonctionnaliter> getAllFonctionalite() {
        return getCurrentSession().createCriteria(ServiceFonctionnaliter.class).list();
    }

    @Override
    public boolean isItTimeToChangePass() {
        return true;
    }

    @Override
    public ServiceUser getUserById(String userId) {
        return (ServiceUser) getCurrentSession()
                .createQuery("SELECT user FROM ServiceUser user WHERE user.userid = :userid")
                .setParameter("userid", userId)
                .setMaxResults(1)
                .uniqueResult();
    }

    @Override
    public List<ServiceMember> getGroupsByUser(ServiceUser user) {
        return getCurrentSession()
                .createQuery("SELECT membre FROM ServiceMember membre WHERE membre.fkUser = :user", ServiceMember.class)
                .setParameter("user", user)
                .getResultList();
    }

    @Override
    public ServiceMember getGroupByUser(ServiceUser user) {
        return getCurrentSession()
                .createQuery("SELECT membre FROM ServiceMember membre WHERE membre.fkUser = :user", ServiceMember.class)
                .setParameter("user", user)
                .setMaxResults(1)
                .uniqueResult();
    }

    @Override
    public void saveUser(ServiceUser object) {
        getCurrentSession().saveOrUpdate(object);
    }

    @Override
    public ServiceGroupe getGroupsById(UUID id) {
        return (ServiceGroupe) getCurrentSession().createCriteria(ServiceGroupe.class).add(Restrictions.eq("id", id)).setMaxResults(1).uniqueResult();
    }

    @Override
    public void saveGroup(ServiceGroupe object) {
        getCurrentSession().saveOrUpdate(object);
    }

    @Override
    public void saveMembership(ServiceMember object) {
        getCurrentSession().saveOrUpdate(object);
    }

    @Override
    public void saveFonctionsGroupes(ServiceFonctiongroupe object) {
        getCurrentSession().saveOrUpdate(object);
    }

    @Override
    public ServicehistoriqueConnection getLastHistoriqueConnectionByUsers(ServiceUser user) {
        return (ServicehistoriqueConnection) getCurrentSession().createCriteria(ServicehistoriqueConnection.class).add(Restrictions.eq("fkUser", user)).addOrder(Order.desc("id")).setMaxResults(1).uniqueResult();
    }

    @Override
    public ServicehistoriqueConnection getLastHistoriqueConnectionById(Long id) {
        return (ServicehistoriqueConnection) getCurrentSession().createCriteria(ServicehistoriqueConnection.class).add(Restrictions.eq("id", id)).setMaxResults(1).uniqueResult();
    }

    @Override
    public void save(ServicehistoriqueConnection historique) {
        getCurrentSession().saveOrUpdate(historique);
    }

    @Override
    public List<ServiceGroupe> getAllGroups() {
        return getCurrentSession().createCriteria(ServiceGroupe.class).add(Restrictions.eq("actif", "true")).list();
    }

    @Override
    public List<ServiceMember> getAllMembershipByUser(ServiceUser user) {
        return getCurrentSession().createCriteria(ServiceMember.class).add(Restrictions.eq("fkUser", user)).list();
    }

    @Override
    public List<ServiceFonctiongroupe> getAllFonctionsGroupesByGroupe(ServiceGroupe group) {
        return getCurrentSession().createCriteria(ServiceFonctiongroupe.class).add(Restrictions.eq("fkGroupe", group)).list();
    }

    @Override
    public List<ServiceMember> getAllMembership() {
        return getCurrentSession().createCriteria(ServiceMember.class).addOrder(Order.desc("date")).list();
    }

    @Override
    public ServiceFonctionnaliter getFonctionnaliteById(String id) {
        return (ServiceFonctionnaliter) getCurrentSession().createCriteria(ServiceFonctionnaliter.class).add(Restrictions.eq("id", id)).setMaxResults(1).uniqueResult();
    }

    @Override
    public List<ServiceFonctionnaliter> getAllFonctionnaliteServer() {
        return getCurrentSession().createCriteria(ServiceFonctionnaliter.class).list();
    }

    @Override
    public void save(ServiceFonctionnaliter object) {
        getCurrentSession().saveOrUpdate(object);
    }

    @Override
    public void save(ServiceHistoriqueManipulation object) {
        getCurrentSession().saveOrUpdate(object);
    }

    @Override
    public List<ServiceFonctiongroupe> getAllFonctionsGroups() {
        return getCurrentSession().createCriteria(ServiceFonctiongroupe.class).list();
    }

    @Override
    public List<ServiceFonctionnaliter> getFonctionServerByGroups(ServiceGroupe groupe) {
        return getCurrentSession().createQuery("select sf from ServiceFonctionnaliter sf,ServiceFonctiongroupe sfg   where   sf.nom=sfg.fkFonctionnalite.nom and sfg.fkGroupe =:groupeS").setParameter("groupeS", groupe).list();
    }

    @Override
    public List<ServiceFonctionnaliter> getFonctionServerByUsers(ServiceUser user) {
        return getCurrentSession().createQuery("select sf from ServiceFonctionnaliter sf,ServiceFonctiongroupe sfg, ServiceMember mem    where   sf.id=sfg.fkFonctionnalite.id and sfg.fkGroupe = mem.fkGroupe and mem.fkUser= :user ").setParameter("user", user).list();
    }

    @Override
    public ServiceFonctionnaliter getFonctionnaliteServerByFonction(String fonction) {
        return (ServiceFonctionnaliter) getCurrentSession().createCriteria(ServiceFonctionnaliter.class).add(Restrictions.eq("fonction", fonction)).setMaxResults(1).uniqueResult();
    }

    @Override
    public int genererBDD(String chemain, String nomSql) {
        return getCurrentSession().createSQLQuery("BACKUP DATABASE " + nomSql + " TO DISK = '" + chemain + "'   WITH FORMAT,  MEDIANAME = 'SQLServerBackups',  NAME = 'Full Backup of " + nomSql + "' ").executeUpdate();

    }

    @Override
    public List<ServiceMember> getAllMemberShipByUser(ServiceUser user) {
        return getCurrentSession().createQuery("select m from ServiceMember m where m.fkUser =:idUser").setParameter("idUser", user).list();
    }

    @Override
    public ServiceFonctiongroupe getFonctionGroupByFonctionIdAndGoupe(String id, ServiceGroupe group) {
        return (ServiceFonctiongroupe) getCurrentSession().createQuery("select fg from ServiceFonctiongroupe fg where fg.fkFonctionnalite.id =:fonction and fg.fkGroupe.id =:group").setParameter("fonction", id).setParameter("group", group.getId()).setMaxResults(1).uniqueResult();
    }

    @Override
    public void save(ServiceIncrementation object) {
        getCurrentSession().saveOrUpdate(object);
    }

    @Override
    public ServiceIncrementation getIncrementation() {
        return (ServiceIncrementation) getCurrentSession().createQuery("select increm from ServiceIncrementation increm").setMaxResults(1).uniqueResult();
    }

    @Override
    public ServiceIncrementation getFirstIncrementation() {
        return getCurrentSession().createQuery("SELECT s FROM ServiceIncrementation s ORDER BY s.id ASC", ServiceIncrementation.class).setMaxResults(1).getSingleResult();
    }

    @Override
    public void save(ServiceGroupe object) {
        getCurrentSession().saveOrUpdate(object);
    }

    @Override
    public void removeFonctionsGroupes(ServiceFonctiongroupe fonctionGroupe) {
        getCurrentSession().delete(fonctionGroupe);
    }

    @Override
    public List<ServicehistoriqueConnection> getListHistoriqueConnectionByUsers(ServiceUser user) {
        return getCurrentSession()
                .createQuery("select e from ServicehistoriqueConnection e where e.fkUser = :user", ServicehistoriqueConnection.class)
                .setParameter("user", user)
                .list();
    }

    @Override
    public List<ServiceHistoriqueManipulation> getListHistoriqueManipulationByUsersByEntreprise(ServiceUser user) {
        return getCurrentSession()
                .createQuery("select e from ServiceHistoriqueManipulation e where e.fkUser = :user", ServiceHistoriqueManipulation.class)
                .setParameter("user", user)
                .list();
    }

    @Override
    public Centre getEtablissementById(Object id) {
        return (Centre) getCurrentSession().createQuery("select ca from Centre ca where ca.id = :id ").setParameter("id", id).setMaxResults(1).uniqueResult();
    }

    @Override
    public List<Centre> getAllStockEtablissementFromUsersEtablissementByUser(ServiceUser user) {
        CriteriaBuilder cb = getCurrentSession().getCriteriaBuilder();
        CriteriaQuery<Centre> cq = cb.createQuery(Centre.class);
        Root<ServiceUserCentre> root = cq.from(ServiceUserCentre.class);

        cq.select(root.get("fkCentre")) // sélectionne la relation
                .where(
                        cb.and(
                                cb.equal(root.get("fkUser"), user),
                                cb.equal(root.get("fkCentre").get("actif"), "true")
                        )
                );
        return getCurrentSession().createQuery(cq).getResultList();
    }

    @Override
    public ServiceUserCentre getAllUserCentreByCentreByUser(Centre etablissement, ServiceUser user) {
        return (ServiceUserCentre) getCurrentSession().createCriteria(ServiceUserCentre.class).add(Restrictions.eq("fkCentre", etablissement)).add(Restrictions.eq("fkUser", user)).setMaxResults(1).uniqueResult();
    }

    @Override
    public List<ServiceFonctionnaliter> getFonctionServerByUsersByEtablissement(ServiceUser user, Centre etablissement) {
        return getCurrentSession().createQuery("select sf from ServiceFonctionnaliter sf,ServiceFonctiongroupe sfg, ServiceMember mem    where   sf.id=sfg.fkFonctionnalite and sfg.fkGroupe= mem.fkGroupe and mem.fkUser=:user and mem.fkGroupe.fkCentre=:etab ").setParameter("etab", etablissement).setParameter("user", user).list();
    }

    @Override
    public ServicehistoriqueConnection getLastStockHistoriqueConnectionByUsers(ServiceUser user) {
        return (ServicehistoriqueConnection) getCurrentSession().createCriteria(ServicehistoriqueConnection.class).add(Restrictions.eq("fkUser", user)).addOrder(Order.desc("id")).setMaxResults(1).uniqueResult();
    }

    @Override
    public List<Wilaya> getAllWilaya() {
        return getCurrentSession().createQuery("select m from Wilaya m ").list();
    }

    @Override
    public int getNbrUtilisateurParGroupe(ServiceGroupe groupe) {
        Long count = (Long) getCurrentSession().createQuery("select count(m) from ServiceGroupe m, ServiceMember f where m.id=f.fkGroupe.id and m.id=:groupe ").setParameter("groupe", groupe.getId()).uniqueResult();
        return count.intValue();
    }

    @Override
    public int getNbrFonctionnaliteParGroupe(ServiceGroupe groupe) {
        Long count = (Long) getCurrentSession().createQuery("select count(m) from ServiceGroupe m, ServiceFonctiongroupe f where m.id=f.fkGroupe.id and m.id=:groupe ").setParameter("groupe", groupe.getId()).uniqueResult();
        return count.intValue();
    }

    @Override
    public ServiceFonctiongroupe getFonctiongroupeById(UUID id) {
        return (ServiceFonctiongroupe) getCurrentSession().createQuery("select m from ServiceFonctiongroupe m where m.id=:id ").setParameter("id", id).setMaxResults(1).uniqueResult();
    }

    @Override
    public <T extends Serializable> void save(final T object) {
        getCurrentSession().saveOrUpdate(object);
    }

    @Override
    public <T extends Serializable> void delete(final T object) {
        System.out.println("delete");
        getCurrentSession().delete(object);
    }

    @Override
    public List<Medecin> getAllMedecinByCenter(Centre centre) {
        return getCurrentSession().createQuery("select s from Medecin s where  s.fkCentre=:centre  ").setParameter("centre", centre).list();

    }

    @Override
    public <T extends Serializable, ID extends Serializable> T findById(Class<T> clazz, ID id) {
        return getCurrentSession().get(clazz, id);
    }

    @Override
    public List<SpecialiteMedicale> getAllSpecialitiesByMedecin(Medecin medecin) {
        return getCurrentSession().createQuery("select s.fkSpecialite from MedecinSpecialiste s where  s.fkMedecin =:medecin  ").setParameter("medecin", medecin).list();
    }

    @Override
    public List<Consultation> getAllConsultationByMedecin(Medecin medecin) {
        return getCurrentSession().createQuery("select s from Consultation s where  s.fkMedecin =:medecin  ").setParameter("medecin", medecin).list();
    }

    @Override
    public <T extends Serializable> List<T> findAll(Class<T> clazz) {
        return getCurrentSession().createCriteria(clazz).list();
    }

    @Override
    public List<ServiceUser> getAllUserByCentreNotInMedecinByUser(Centre centre,Medecin medecin) {
        return getCurrentSession().createQuery("select s.fkUser from ServiceUserCentre s  where  s.fkCentre =:centre and (s.fkUser=:user or s.fkUser not in"
                + " (select m.fkUser from Medecin m)) ").setParameter("centre", centre).setParameter("user", medecin.getFkUser()).list();
    }

    @Override
    public MedecinSpecialiste getMedecinSpecialisteByMedcinBySpecialiste(Medecin medecin, SpecialiteMedicale spc) {
       return (MedecinSpecialiste) getCurrentSession().createQuery("select s from MedecinSpecialiste s  where  s.fkMedecin =:medecin and s.fkSpecialite=:spc ").setParameter("spc", spc).setParameter("medecin", medecin).setMaxResults(1).uniqueResult();
    }
    
    @Override
    public List<ServiceUser> getAllUserByCentreNotInMedecin(Centre centre) {
        return getCurrentSession().createQuery("select s.fkUser from ServiceUserCentre s  where  s.fkCentre =:centre and ( s.fkUser not in"
                + " (select m.fkUser from Medecin m)) ").setParameter("centre", centre).list();
    }
}