package ru.indvdum.jpa.dao

import java.sql.Connection

import java.sql.SQLException

import java.util.Map.Entry

import javax.persistence.EntityManager

import javax.persistence.EntityManagerFactory

import javax.persistence.EntityTransaction

import javax.persistence.NoResultException

import javax.persistence.Persistence

import javax.persistence.Query

import javax.persistence.criteria.CriteriaBuilder

import javax.persistence.criteria.CriteriaQuery

import javax.persistence.criteria.Predicate

import javax.persistence.criteria.Root

import javax.sql.DataSource

import org.apache.commons.configuration.XMLConfiguration

import org.apache.openjpa.conf.OpenJPAConfiguration

import org.apache.openjpa.persistence.OpenJPAEntityManagerFactorySPI

import org.apache.openjpa.persistence.OpenJPAPersistence

import org.slf4j.Logger

import org.slf4j.LoggerFactory

import ru.indvdum.jpa.entities.AbstractEntity

import ru.indvdum.jpa.props.Props

/**

 * @author indvdum (gotoindvdum[at]gmail[dot]com)

 * @since 08.11.2012 23:35:04

 *

 */

public class JPADataAccessObject {

	protected static Logger log = LoggerFactory.getLogger(JPADataAccessObject.class.getSimpleName());

	protected static String persistenceUnitName = null;

	protected static EntityManagerFactory emf = Persistence.createEntityManagerFactory(getPersistenceUnitName(), JPAPropertySelector.select());

	protected EntityManager em = emf.createEntityManager();

	protected EntityTransaction tx = null;

	JPADataAccessObject() {

		tx = em.getTransaction();

		tx.begin();

	}

	void close() {

		commit()

		em.close()

		em = null

	}

	void commit() {

		if(tx != null && tx.isActive()) {

			tx.commit()

		}

	}

	void rollback() {

		if(tx != null && tx.isActive()) {

			tx.rollback()

		}

	}

	void detach(Object entity) {

		em.detach(entity);

	}

	protected static String getPersistenceUnitName() {

		if (persistenceUnitName != null)

			return persistenceUnitName;

		if (persistenceUnitName == null)

			persistenceUnitName = System.getProperty(Props.PERSISTANCE_UNIT_NAME_PROPERTY);

		if (persistenceUnitName == null) {

			try {

				persistenceUnitName = ResourceBundle.getBundle(Props.JPADAO_PROPERTY_FILE).getString(Props.PERSISTANCE_UNIT_NAME_PROPERTY);

			} catch (MissingResourceException e) {

				log.info("Configuration file " + Props.JPADAO_PROPERTY_FILE + ".properties not found");

			}

		}

		if (persistenceUnitName == null) {

			XMLConfiguration conf = new XMLConfiguration("META-INF/persistence.xml");

			persistenceUnitName = conf.getString("persistence-unit[@name]");

		}

		if (persistenceUnitName == null)

			persistenceUnitName = "database";

		return persistenceUnitName;

	}

	public static Connection getSQLConnection() throws SQLException {

		OpenJPAEntityManagerFactorySPI openjpaemf = (OpenJPAEntityManagerFactorySPI) OpenJPAPersistence.cast(emf);

		OpenJPAConfiguration conf = openjpaemf.getConfiguration();

		DataSource ds = (DataSource) conf.getConnectionFactory();

		return ds.getConnection();

	}

	public <T> T mergeAndRefresh(T object) {

		def merged = em.merge(object)

		em.refresh(merged)

		merged

	}

	public <T extends AbstractEntity> T read(T object) {

		return find(object.class, object.getIdentifierValue())

	}

	public <T> T merge(T object) {

		em.merge(object)

	}

	void refresh(Object ... refreshObjects) {

		for(object in refreshObjects) {

			em.refresh(object)

		}

	}

	boolean persist(Object ... persistanceQueue) {

		persistAndRemove(persistanceQueue, new Object[0])

	}

	boolean persist(Collection entities) {

		persistAndRemove(entities.toArray(), new Object[0])

	}

	boolean remove(Object ... removeQueue) {

		persistAndRemove(new Object[0], removeQueue)

	}

	boolean remove(Collection entities) {

		persistAndRemove(new Object[0], entities.toArray())

	}

	synchronized boolean persistAndRemove(Object[] persistanceQueue, Object[] removeQueue) {

		try {

			if(persistanceQueue != null) {

				for(object in persistanceQueue) {

					if(object != null) {

						em.persist(object)

					}

				}

			}

			if(removeQueue != null) {

				for(object in removeQueue) {

					if(object != null) {

						em.remove(object)

					}

				}

			}

		}

		catch(Throwable t) {

			log.error("Error while synchronizing with Database: ", t);

			return false;

		}

		return true

	}

	public <T> List<T> list(Class<T> entityClass) {

		// TODO: check for AbstractEntity type of T

		CriteriaQuery<T> query = em.getCriteriaBuilder().createQuery(entityClass);

		query.from(entityClass);

		return new ArrayList(em.createQuery(query).getResultList());

	}

	public <T> List<T> list(Class<T> entityClass, Map<String, Object> equalProperties, Map<String, Object> notEqualProperties) {

		CriteriaBuilder cb = em.getCriteriaBuilder();

		CriteriaQuery<T> query = cb.createQuery(entityClass);

		Root<T> root = query.from(entityClass);

		Collection<Predicate> predicates = new HashSet<Predicate>();

		if(equalProperties != null) {

			for(Entry<String, Object> entry: equalProperties.entrySet()){

				String property = entry.getKey();

				Object value = entry.getValue();

				predicates.add(cb.equal(root.get(property), value));

			}

		}

		if(notEqualProperties != null) {

			for(Entry<String, Object> entry: equalProperties.entrySet()){

				String property = entry.getKey();

				Object value = entry.getValue();

				predicates.add(cb.notEqual(root.get(property), value));

			}

		}

		query.where(cb.and(predicates.toArray(new Predicate[predicates.size()])));

		return em.createQuery(query).getResultList();

	}

	public <T> List<T> list(Class<T> entityClass, Object ... equalFieldNamesAndValues) {

		if (equalFieldNamesAndValues.length % 2 != 0)

			throw new RuntimeException("Illegal arguments count: ${equalFieldNamesAndValues.length}");

		Map fieldValues = [:];

		for (int i = 0; i < equalFieldNamesAndValues.length;) {

			String field = (String) equalFieldNamesAndValues[i++];

			Object value = equalFieldNamesAndValues[i++];

			fieldValues["${field}"] = value;

		}

		return list(entityClass, fieldValues, null);

	}

	public List list(String jpql, Object ... paramValues) {

		Query query = em.createQuery(jpql);

		for (int i = 0; i < paramValues.length; i++)

			query.setParameter(i + 1, paramValues[i]);

		return query.getResultList();

	}

	public <T> T find(Class<T> entityClass, Object primaryKey) {

		return em.find(entityClass, primaryKey);

	}

	public <T> T find(Class<T> entityClass, Map<String, Object> equalProperties, Map<String, Object> notEqualProperties) {

		CriteriaBuilder cb = em.getCriteriaBuilder();

		CriteriaQuery<T> query = cb.createQuery(entityClass);

		Root<T> root = query.from(entityClass);

		Collection<Predicate> predicates = new HashSet<Predicate>();

		if(equalProperties != null) {

			for(Entry<String, Object> entry: equalProperties.entrySet()){

				String property = entry.getKey();

				Object value = entry.getValue();

				predicates.add(cb.equal(root.get(property), value));

			}

		}

		if(notEqualProperties != null) {

			for(Entry<String, Object> entry: equalProperties.entrySet()){

				String property = entry.getKey();

				Object value = entry.getValue();

				predicates.add(cb.notEqual(root.get(property), value));

			}

		}

		query.where(cb.and(predicates.toArray(new Predicate[predicates.size()])));

		T result = null;

		try {

			result = em.createQuery(query).getSingleResult();

		} catch (NoResultException e) {

			log.info("Object not found in Database: " + e.getMessage());

		}

		return result;

	}

	public <T> T find(Class<T> entityClass, Object ... equalFieldNamesAndValues) {

		if (equalFieldNamesAndValues.length % 2 != 0)

			throw new RuntimeException("Illegal arguments count: ${equalFieldNamesAndValues.length}");

		Map fieldValues = [:];

		for (int i = 0; i < equalFieldNamesAndValues.length;) {

			String field = (String) equalFieldNamesAndValues[i++];

			Object value = equalFieldNamesAndValues[i++];

			fieldValues["${field}"] = value;

		}

		return find(entityClass, fieldValues, null);

	}

	public Object find(String jpql, Object ... paramValues) {

		Query query = em.createQuery(jpql);

		for (int i = 0; i < paramValues.length; i++)

			query.setParameter(i + 1, paramValues[i]);

		return query.getSingleResult();

	}

	public boolean contains(Collection entities) {

		boolean res = true;

		entities.each {res &= contains(it)}

		return res

	}

	public boolean contains(Object entity) {

		return em.contains(entity);

	}

	private Object getSingleResult(Query query) {

		try {

			return query.getSingleResult()

		}

		catch (NoResultException e) {

			return null

		}

	}

}