package ts.mo.tele3.dao.core;

import org.springframework.transaction.annotation.Transactional;

import java.lang.reflect.ParameterizedType;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaDelete;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;

/**
 * Abstract class for generic CRUD operations on a repository for a specific type.
 */
@Transactional
public abstract class CrudDao<T, ID> implements Dao<T, ID> {

    private Class<T> clazz;

    @PersistenceContext
    protected EntityManager em;

    @SuppressWarnings("unchecked")
    public CrudDao() {
        // TODO figure out what that means
        clazz = (Class<T>)
            ((ParameterizedType)getClass().getGenericSuperclass())
                .getActualTypeArguments()[0];
    }

    /**
     * Saves a given entity.
     */
    public void save(T entity) {
        em.persist(entity);
    }

    /**
     * Updates a given entity.
     * Use the returned instance for further operations as the save operation might have changed the
     * entity instance completely.
     */
    public <S extends T> S update(S entity) {
        return em.merge(entity);
    }

    /**
     * Retrieves an entity by its id.
     */
    public T findById(ID id) {
        return em.find(clazz, id);
    }

    /**
     * Returns all instances of the type.
     */
    public Iterable<T> findAll() {
        CriteriaBuilder cb = em.getCriteriaBuilder();
        CriteriaQuery<T> cq = cb.createQuery(clazz);
        Root<T> rootEntry = cq.from(clazz);
        CriteriaQuery<T> all = cq.select(rootEntry);

        TypedQuery<T> allQuery = em.createQuery(all);
        return allQuery.getResultList();
    }

    /**
     * Deletes the entity with the given id.
     */
    public void deleteById(ID id) {
        CriteriaBuilder cb = this.em.getCriteriaBuilder();
        CriteriaDelete<T> delete = cb.createCriteriaDelete(clazz);
        Root<T> e = delete.from(clazz);
        // TODO JPA Metamodel
        delete.where(cb.equal(e.get("id"), id));

        this.em.createQuery(delete).executeUpdate();
    }

    /**
     * Deletes a given entity.
     */
    public void delete(T entity) {
        em.remove(entity);
    }

}