/**
 * 
 */
package org.gcube.documentstore.records.implementation;

import java.io.Serializable;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.UUID;

import org.gcube.com.fasterxml.jackson.annotation.JsonIgnore;
import org.gcube.documentstore.exception.InvalidValueException;
import org.gcube.documentstore.records.AggregatedRecord;
import org.gcube.documentstore.records.Record;
import org.gcube.documentstore.records.implementation.validations.annotations.NotEmpty;
import org.gcube.documentstore.records.implementation.validations.annotations.ValidLong;
import org.gcube.documentstore.records.implementation.validations.validators.ValidLongValidator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


/**
 * @author Luca Frosini (ISTI - CNR)
 */
public abstract class AbstractRecord implements Record {

	/**
	 * Generated Serial Version UID
	 */
	private static final long serialVersionUID = -2060728578456796388L;
	
	private static Logger logger = LoggerFactory.getLogger(AbstractRecord.class);
	
	@NotEmpty
	protected static final String ID = Record.ID;

	@ValidLong
	protected static final String CREATION_TIME = Record.CREATION_TIME;
	
	/** resource-specific properties */
	protected Map<String, Serializable> resourceProperties;
	protected Map<String, List<FieldAction>> validation;
	protected Map<String, List<FieldAction>> computation;
	
	protected Set<String> requiredFields;
	protected Set<String> computedFields;
	protected Set<String> aggregatedFields;
	
	protected static Set<Field> getAllFields(Class<?> type) {
		Set<Field> fields = new HashSet<Field>();
		for (Class<?> c = type; c != null; c = c.getSuperclass()) {
			fields.addAll(Arrays.asList(c.getDeclaredFields()));
			fields.addAll(Arrays.asList(c.getFields()));
		}
		return fields;
	}
	
	
	protected void initializeValidation() {
		Set<Field> fields = getAllFields(this.getClass());
		for(Field field : fields){
			boolean defaultAccessibility = field.isAccessible();
			field.setAccessible(true);
			String keyString;
			try {
				keyString = (String) field.get(null);
			} catch (Exception e) {
				continue;
			}
			
			if(field.getAnnotations().length>0){
				
				List<FieldAction> fieldValidators =  validation.get(keyString);
				if(fieldValidators==null){
					fieldValidators = new ArrayList<FieldAction>();
					validation.put(keyString, fieldValidators);
				}
				
				List<FieldAction> fieldComputations = computation.get(keyString);
				if(fieldComputations==null){
					fieldComputations = new ArrayList<FieldAction>();
					computation.put(keyString, fieldComputations);
				}
				
				for (Annotation annotation : field.getAnnotations()){
					Class<? extends Annotation> annotationType = annotation.annotationType();
					if (annotationType.isAnnotationPresent(FieldDecorator.class)){
						Class<? extends FieldAction> managedClass = ((FieldDecorator)annotationType.getAnnotation(FieldDecorator.class)).action();
						FieldAction validator;
						try {
							validator = managedClass.newInstance();
						} catch (InstantiationException | IllegalAccessException e) {
							logger.error("{} {}", keyString, annotation, e);
							continue;
						}
						fieldValidators.add(validator);
					}
					if(annotationType.isAssignableFrom(RequiredField.class)){
						requiredFields.add(keyString);
					}
					if(annotationType.isAssignableFrom(AggregatedField.class)){
						aggregatedFields.add(keyString);
					}
					if(annotationType.isAssignableFrom(ComputedField.class)){
						computedFields.add(keyString);
						Class<? extends FieldAction> managedClass = ((ComputedField) annotation).action();
						FieldAction computeAction;
						try {
							computeAction = managedClass.newInstance();
						} catch (InstantiationException | IllegalAccessException e) {
							logger.error("{} {}", keyString, annotation, e);
							continue;
						}
						fieldComputations.add(computeAction);
					}
				}
			}
			field.setAccessible(defaultAccessibility);
		}
		
	}
	
	@Override
	public SortedSet<String> getQuerableKeys()
					throws Exception {
		SortedSet<String> properties = new TreeSet<>(
				this.getRequiredFields());

		properties.removeAll(this.getAggregatedFields());
		properties.removeAll(this.getComputedFields());
		properties.remove(Record.ID);
		properties.remove(Record.CREATION_TIME);

		return properties;
	}

	protected void cleanExtraFields(){
		Set<String> neededFields = this.requiredFields;
		neededFields.addAll(this.aggregatedFields);
		
		Set<String> keysToRemove = new HashSet<String>();
		Set<String> propertyKeys = this.resourceProperties.keySet();
		for(String propertyName : propertyKeys){
			if(!neededFields.contains(propertyName)){
				keysToRemove.add(propertyName);
			}
		}
		
		for(String keyToRemove : keysToRemove){
			this.resourceProperties.remove(keyToRemove);
		}
	}
	
	/**
	 * Initialize variable
	 */
	protected void init() {
		this.validation = new HashMap<String, List<FieldAction>>();
		this.computation = new HashMap<String, List<FieldAction>>();
		this.requiredFields = new HashSet<String>();
		this.aggregatedFields = new HashSet<String>();
		this.computedFields = new HashSet<String>();
		this.resourceProperties = new HashMap<String, Serializable>();
		initializeValidation();
	}
	
		
	public AbstractRecord(){
		init();
		this.resourceProperties.put(ID, UUID.randomUUID().toString());
		Calendar calendar = Calendar.getInstance();
		this.resourceProperties.put(CREATION_TIME, calendar.getTimeInMillis());
	}

		
	public AbstractRecord(Map<String, ? extends Serializable> properties) throws InvalidValueException {
		init();
		setResourceProperties(properties);
		if(this instanceof AggregatedRecord){
			this.resourceProperties.put(AggregatedRecord.AGGREGATED, true);
			cleanExtraFields();
		}
	}
	
	/**
	 * {@inheritDoc}
	 */
	@Override
	@JsonIgnore
	public Set<String> getRequiredFields() {
		return new HashSet<String>(requiredFields);
	}
	
	/**
	 * {@inheritDoc}
	 */
	@Override
	@JsonIgnore
	public Set<String> getComputedFields() {
		return new HashSet<String>(computedFields);
	}

	@JsonIgnore
	public Set<String> getAggregatedFields() {
		return new HashSet<String>(aggregatedFields);
	}
	
	/**
	 * {@inheritDoc}
	 */
	@Override
	public String getId() {
		return (String) this.resourceProperties.get(ID);
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	public void setId(String id) throws InvalidValueException {
		setResourceProperty(ID, id);
	}
	
	public static Calendar timestampToCalendar(long millis){
		Calendar calendar = Calendar.getInstance();
		calendar.setTimeInMillis(millis);
		return calendar;
	}
	
	/**
	 * {@inheritDoc}
	 */
	@Override
	public Calendar getCreationTime() {
		Long millis = null;
		try {
			millis = (Long) new ValidLongValidator().validate(CREATION_TIME, this.resourceProperties.get(CREATION_TIME), null);
			return timestampToCalendar(millis);
		} catch (InvalidValueException e) {
			return null;
		}
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	public void setCreationTime(Calendar creationTime) throws InvalidValueException {
		setResourceProperty(CREATION_TIME, creationTime.getTimeInMillis());
	}
		
	/**
	 * {@inheritDoc}
	 */
	@Override
	public Map<String, Serializable> getResourceProperties() {
		return new HashMap<String, Serializable>(this.resourceProperties);
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	public void setResourceProperties(Map<String, ? extends Serializable> properties) throws InvalidValueException {		
		Map<String, ? extends Serializable> validated = validateProperties(properties);		
		this.resourceProperties = new HashMap<String, Serializable>(validated);
	}
	
	/**
	 * {@inheritDoc}
	 */
	@Override
	public Serializable getResourceProperty(String key) {
		return this.resourceProperties.get(key);
	}
	
	@Override
	public void removeResourceProperty(String key) {
		this.resourceProperties.remove(key);
	}
	
	/**
	 * {@inheritDoc}
	 */
	@Override	
	public void setResourceProperty(String key, Serializable value) throws InvalidValueException {
		Serializable checkedValue = validateField(key, value);
		if(checkedValue == null){
			this.resourceProperties.remove(key);
		}else{
			this.resourceProperties.put(key, checkedValue);
		}
	}
	
	
	
	
	// AGGREGATION
	/* --------------------------------------- */
	
	/**
	 * Set the right end of the time interval covered by this Record
	 * @param endTime End Time
	 * @throws InvalidValueException
	 */
	protected void setEndTime(Calendar endTime) throws InvalidValueException {
		setResourceProperty(AggregatedRecord.END_TIME, endTime.getTimeInMillis());
	}
	
	/**
	 * Return the right end of the time interval covered by this Record
	 * @return End Time
	 */
	protected long getEndTimeInMillis() {
		return (Long) this.resourceProperties.get(AggregatedRecord.END_TIME);
	}
	
	/**
	 * Return the right end of the time interval covered by this Record
	 * @return End Time
	 */
	protected Calendar getEndTimeAsCalendar() {
		long millis = getEndTimeInMillis();
		return timestampToCalendar(millis);
	}
	
	@JsonIgnore
	protected int getOperationCount() {
		return (Integer) this.resourceProperties.get(AggregatedRecord.OPERATION_COUNT);
	}

	protected void setOperationCount(int operationCount) throws InvalidValueException {
		setResourceProperty(AggregatedRecord.OPERATION_COUNT, operationCount);
	}
	
	/**
	 * Return the left end of the time interval covered by this Record
	 * @return Start Time
	 */
	protected long getStartTimeInMillis() {
		return (Long) this.resourceProperties.get(AggregatedRecord.START_TIME);
	}
	
	/**
	 * Return the left end of the time interval covered by this Record
	 * @return Start Time
	 */
	protected Calendar getStartTimeAsCalendar() {
		long millis = getStartTimeInMillis();
		return timestampToCalendar(millis);
	}
	
	/**
	 * Set the left end of the time interval covered by this Record
	 * @param startTime Start Time
	 * @throws InvalidValueException
	 */
	protected void setStartTime(Calendar startTime) throws InvalidValueException {
		setResourceProperty(AggregatedRecord.START_TIME, startTime.getTimeInMillis());
	}
	
	/**
	 * Set the boolean aggregate by this Record
	 * @param aggregate
	 * @throws InvalidValueException
	 */
	protected void setAggregated(Boolean aggregate) throws InvalidValueException {
		setResourceProperty(AggregatedRecord.AGGREGATED, aggregate);
	}

	@JsonIgnore
	protected Boolean isAggregated() {
		Boolean bool = (Boolean) this.resourceProperties.get(AggregatedRecord.AGGREGATED);
		if(bool==null){
			return false;
		}
		return bool;
	}
	
	protected Serializable validateField(String key, Serializable value) throws InvalidValueException {
		if(key == null){
			throw new InvalidValueException("The key of property to set cannot be null");
		}
		Serializable checkedValue = value;
		List<FieldAction> fieldValidators = validation.get(key);
		if(fieldValidators!=null){
			for(FieldAction fieldValidator : fieldValidators){
				if(aggregatedFields.contains(key)){
					// TODO
				}
				if(computedFields.contains(key)){
					logger.debug("{} is a computed field. To be calculated all the required fields to calcutalate it MUST be set. In any case the provided value will be ignored.", key);
				}
				try {
					
					checkedValue = fieldValidator.validate(key, checkedValue, this);
					if(checkedValue==null){
						return null;
					}
				} catch (InvalidValueException e) {
					logger.error(String.format("The provided value %s is NOT valid for field with key %s.", checkedValue, key));
					throw e;
				}
			}
		}
		return checkedValue;
	}
	
	protected void computeField(String key) throws InvalidValueException {
		if(key == null){
			throw new InvalidValueException("The key of property to set cannot be null");
		}
		Serializable computedValue = null;
		List<FieldAction> fieldComputations = computation.get(key);
		if(fieldComputations!=null){
			for(FieldAction fieldValidator : fieldComputations){
				try {
					computedValue = fieldValidator.validate(key, null, this);
					this.resourceProperties.put(key, computedValue);
				} catch (InvalidValueException e) {
					logger.error(String.format("Unable to calculate the field with key %s", key));
					throw e;
				}
			}
		}
	}
	
	protected Map<String, ? extends Serializable> validateProperties(Map<String, ? extends Serializable> properties) throws InvalidValueException{
		Map<String, Serializable> validated = new HashMap<String, Serializable>();
		for(String key : properties.keySet()){
			Serializable value = properties.get(key);
			
			Serializable checkedValue = validateField(key, value);
			if(checkedValue == null){
				validated.remove(key);
			}else{
				validated.put(key, checkedValue);
			}
			
		}
		return validated;
	}
	
	/**
	 * {@inheritDoc}
	 */
	@Override
	public void validate() throws InvalidValueException {
		for(String key : this.computedFields){
			computeField(key);
		}
		
		validateProperties(this.resourceProperties);
		Set<String> notPresentProperties = new HashSet<String>();
		for(String key : this.requiredFields){
			if(!this.resourceProperties.containsKey(key)){
				notPresentProperties.add(key);
			}
		}
		if(!notPresentProperties.isEmpty()){
			String pluralManagement = notPresentProperties.size() == 1 ? "y" : "ies";
			logger.debug("ID doc:{}",this.getId());
			throw new InvalidValueException(String.format("The Record does not contain the following required propert%s %s", pluralManagement, notPresentProperties.toString()));
		}
	}
	
	@Override
	public String toString(){
		return resourceProperties.toString();
	}

	/**
	 * Compare this Record instance with the one provided as argument
	 * @param record the Record to compare
	 * @return 0 is and only if the Record provided as parameter
	 * contains all and ONLY the parameters contained in this instance.
	 * If the number of parameters differs, the methods return the difference 
	 * between the number of parameter in this instance and the ones in the
	 * Record provided as parameter.
	 * If the size is the same but the Record provided as parameter does
	 * not contains all parameters in this instance, -1 is returned. 
	 */
	@Override
	public int compareTo(Record record) {
		Set<Entry<String, Serializable>> thisSet = this.resourceProperties.entrySet();
		Set<Entry<String, Serializable>> recordSet = record.getResourceProperties().entrySet();
		if(thisSet.size() != recordSet.size()){
			return thisSet.size() - recordSet.size();
		}
		if(recordSet.containsAll(thisSet)){
			return 0;
		}
		return 1;
	}

}