package ru.indvdum.jpa.tests

;

import static org.junit.Assert.*

import java.lang.reflect.Field

import java.lang.reflect.Method

import java.lang.reflect.Modifier

import javax.persistence.EmbeddedId

import javax.persistence.Entity

import javax.persistence.GeneratedValue

import javax.persistence.Id

import javax.persistence.IdClass

import javax.persistence.Transient

import org.junit.Test

import ru.indvdum.jpa.dao.JPADataAccessObject

import ru.indvdum.jpa.entities.AbstractEntity

/**

 * JUnit test case for testing of a creating, listing, updating and removing 

 * operations with database of the JPA entities.

 * 

 * @author 	indvdum (gotoindvdum@gmail.com)

 * @since 23.12.2011 22:54:26

 *

 */

abstract class AbstractJPAEntityTest extends AbstractJPATest {

	protected def uniqueValue = 1

	protected JPADataAccessObject dao = null

	protected Set toRemove = new HashSet()

	protected Map<Class, Integer> existedEntitiesCount = [:]

	@Test

	public void testEntity() {

		dao = createDAO()

		try {

			testEntity(getEntityClass())

		} catch (Throwable t) {

			dao.rollback()

			throw t

		} finally {

			dao.close()		

		}

	}

	/**

	 * @return Your implementation of JPADataAccessObject

	 */

	protected abstract JPADataAccessObject createDAO();

	/**

	 * Test creating, listing, updating, and removing of an {@code entityClass} object

	 * 

	 * @param entityClass

	 */

	protected void testEntity(Class entityClass) {

		assert AbstractEntity.class.isAssignableFrom(entityClass)

		Map<String, Object> fieldsValues

		def dbEntity

		// creating

		def entity = createEntity(entityClass)

		testCreatedEntity(entity)

		// listing

		toRemove.each {

			assert dao.list(it.class).each { it2 ->

				assert it.class.isAssignableFrom(it2.class)

			}.size() == toRemove.findAll { it2 ->

				it.class.isAssignableFrom(it2.class)

			}.size() + existedEntitiesCount[it.class]

		}

		// updating

		fieldsValues = updateFields(entity)

		assert dao.persist(entity)

		assert dao.contains(entity)

		dbEntity = dao.find(entityClass, (entity as AbstractEntity).getIdentifierValue())

		assert dbEntity != null

		assert checkEntityFieldValues(dbEntity, fieldsValues)

		testUpdatedEntity(entity)

		// removing

		assert dao.remove(toRemove)

		assert !dao.contains(toRemove)

		testRemovedEntity(entity)

	}

	/**

	 * Create and persist to database an {@code entityClass} object

	 * 

	 * @param entityClass

	 * @return created entity object

	 */

	protected Object createEntity(Class entityClass) {

		if (entityClass.isInterface())

			return null;

		assertNotNull entityClass.annotations.find {it instanceof Entity}

		def entity = entityClass.newInstance()

		assert entity.class == entityClass

		toRemove.add(entity)

		if (!existedEntitiesCount.containsKey(entityClass))

			existedEntitiesCount[entityClass] = dao.list(entityClass).size()

		Map<String, Object> fieldsValues = updateFields(entity)

		assert dao.persist(entity)

		assert dao.contains(entity)

		def dbEntity = dao.find(entityClass, (entity as AbstractEntity).getIdentifierValue())

		assert dbEntity != null

		assert checkEntityFieldValues(dbEntity, fieldsValues)

		return entity

	}

	/**

	 * Update all fields of an {@code entity} object

	 * @param entity

	 * @return generated field values

	 */

	protected Map<String, Object> updateFields(Object entity) {

		Map<String, Object> fieldsValues = new HashMap<String, Object>()

		getFields(entity).grep {

			it.annotations.find {

				it instanceof Transient || it instanceof GeneratedValue

			} == null

		}.each {

			def newValue = generateFieldValue(entity, it)

			setFieldValueBySetter(entity, it, newValue)

			fieldsValues.put(it.name, newValue)

		}

		return fieldsValues

	}

	/**

	 * Collections and arrays will not be processed

	 * 

	 * @param entity

	 * @param field

	 * @return generated field value

	 */

	protected Object generateFieldValue(Object entity, Field field) {

		def type = field.getType()

		def newValue

		if(type.toString() == 'boolean' || type == Boolean.class) {

			newValue = (boolean) (uniqueValue++ % 2i == 0i)

		} else if(type.toString() == 'byte' || type == Byte) {

			newValue = (byte) (uniqueValue++ % Byte.MAX_VALUE + 1i)

		} else if(type.toString() == 'char' || type == Character) {

			newValue = (char) (uniqueValue++ % (int) Character.MAX_VALUE + 1i)

		} else if(type.toString() == 'short' || type == Short) {

			newValue = (short) (uniqueValue++ % Short.MAX_VALUE + 1i)

		} else if(type.toString() == 'int' || type == Integer) {

			newValue = (int) (uniqueValue++ % Integer.MAX_VALUE + 1i)

		} else if(type.toString() == 'long' || type == Long) {

			newValue = (long) uniqueValue++ % Long.MAX_VALUE + 1L

		} else if(type.toString() == 'float' || type == Float) {

			newValue = (float) uniqueValue++ % Float.MAX_VALUE + 1f

		} else if(type.toString() == 'double' || type == Double) {

			newValue = (double) uniqueValue++ % Double.MAX_VALUE + 1d

		} else if(Number.class.isAssignableFrom(type)) {

			// trying to use constructor with int argument

			newValue = type.newInstance(uniqueValue++ % Byte.MAX_VALUE + 1i)

		} else if(type == String.class) {

			newValue = (String) "test${uniqueValue++}"

		} else if(type instanceof Class && ((type as Class).isInterface() || (type as Class).annotations.find {it instanceof Entity} != null)) { // modifying of a primary keys is deprecated

			// an attempt to use already created entities

			def currentValue = getFieldValue(entity, field)

			newValue = toRemove.find {it.class.isAssignableFrom(type) && it != currentValue}

			if(newValue == null)

				newValue = createEntity(type as Class)

		} else if(Enum.class.isAssignableFrom(type)) {

			def values = type.values();

			newValue = values[uniqueValue++ % values.size()];

		} else if(

				type instanceof Class 

				&& !(

					field.clazz.annotations.find {it instanceof IdClass} != null 

					&& field.declaredAnnotations.find {it instanceof Id} != null

				)

				&& field.declaredAnnotations.find {it instanceof EmbeddedId} == null

				&& !Collection.class.isAssignableFrom(type)

				&& !(type as Class).isArray()

			) { // modifying of a primary keys is deprecated

			newValue = (type as Class).newInstance()

		} else {

			newValue = getFieldValue(entity, field)

		}

		return newValue

	}

	/**

	 * @param entity

	 * @param rightValues

	 * @return {@code true}, if all entity fields is equals to {@code rightValues}

	 */

	protected boolean checkEntityFieldValues(Object entity, Map<String, Object> rightValues) {

		def result = true

		def fields = getFields(entity)

		rightValues.each {  key, value ->

			fields.find { it.name == key }.each {

				if(!getFieldValue(entity, it).equals(value)) {

					result = false

				}

			}

		}

		return result

	}

	/**

	 * Set a {@code field} to a {@code value} of an entity {@code object}

	 * 

	 * @param object

	 * @param field

	 * @param value

	 */

	protected void setFieldValue(Object object, Field field, Object value) {

		boolean isAccessible = field.accessible

		field.accessible = true

		field.set(object, value)

		field.accessible = isAccessible

	}

	/**

	 * Trying set a {@code field} to a {@code value} of an entity {@code object}

	 * by using a setter method. If setter not found, field will be set directly

	 * throw {@code setFieldValue} method.

	 * 

	 * @param object

	 * @param field

	 * @param value

	 */

	protected void setFieldValueBySetter(Object object, Field field, Object value) {

		boolean isSetted = false

		getMethods(object).grep {

			(

				Modifier.isPublic(it.modifiers) 

				&& it.parameterTypes.size() == 1 

				&& (

					value == null 

					|| it.parameterTypes[0].isAssignableFrom(value.class)

					)

				&& it.name =~ /^set(?i:${field.name.charAt(0)})${field.name.replaceFirst("^.{1}", "")}/

			)

		}.each {

			object."${it.name}"(value)

			isSetted = true

		}

		if(isSetted)

			return

		setFieldValue(object, field, value)

	}

	/**

	 * @param object

	 * @param field

	 * @return the field value of an object

	 */

	protected Object getFieldValue(Object object, Field field) {

		boolean isAccessible = field.accessible

		field.accessible = true

		def value = field.get(object)

		field.accessible = isAccessible

		return value

	}

	/**

	 * @param obj

	 * @return all object fields, including inherited

	 */

	protected Collection<Field> getFields(obj) {

		Class clazz = obj.getClass()

		Collection<Field> fields = clazz.declaredFields

		while(clazz.superclass != null) {

			clazz = clazz.superclass

			fields.addAll(clazz.declaredFields)

		}

		fields.grep {

			!it.synthetic &&

					!Modifier.isStatic(it.modifiers) &&

					!Modifier.isTransient(it.modifiers)

		}

	}

	/**

	 * @param obj

	 * @return all object methods, including inherited

	 */

	protected Collection<Method> getMethods(obj) {

		Class clazz = obj.getClass()

		Collection<Method> methods = clazz.declaredMethods

		while(clazz.superclass != null) {

			clazz = clazz.superclass

			methods.addAll(clazz.declaredMethods)

		}

		methods.grep {

			!it.synthetic &&

					!Modifier.isStatic(it.modifiers) &&

					!Modifier.isTransient(it.modifiers)

		}

	}

	/**

	 * For implement in successors

	 *

	 * @param entity

	 */

	protected void testCreatedEntity(Object entity) {

	}

	/**

	 * For implement in successors

	 *

	 * @param entity

	 */

	protected void testUpdatedEntity(Object entity) {

	}

	/**

	 * For implement in successors

	 *

	 * @param entity

	 */

	protected void testRemovedEntity(Object entity) {

	}

	/**

	 * @return an {@link AbstractEntity} successor

	 */

	abstract protected Class getEntityClass()

}