/**
    * 2008, Digitalis Informatica. All rights reserved. Distribuicao e Gestao de Informatica, Lda. Estrada de Paco de Arcos
    * num.9 - Piso -1 2780-666 Paco de Arcos Telefone: (351) 21 4408990 Fax: (351) 21 4408999 http://www.digitalis.pt
    */
   
   package pt.digitalis.dif.model.dataset;
   
   import java.beans.PropertyDescriptor;
   import java.util.LinkedHashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Map.Entry;
  import java.util.Set;
  
  import org.apache.commons.beanutils.PropertyUtils;
  
  import pt.digitalis.utils.common.IBeanAttributes;
  import pt.digitalis.utils.common.StringUtils;
  import pt.digitalis.utils.common.collections.CaseInsensitiveHashMap;
  import pt.digitalis.utils.common.collections.CaseInsentiveArrayList;
  
  /**
   * An abstract base implementation for data sources
   * 
   * @author Pedro Viegas <a href="mailto:pviegas@digitalis.pt">pviegas@digitalis.pt</a><br/>
   * @param <T>
   *            the data object type of the data source
   * @created 2008/11/19
   */
  public abstract class AbstractDataSet<T extends IBeanAttributes> implements IDataSet<T> {
  
      /**
       * Throws an unsupported operation exception for non-implemented dataset operations
       * 
       * @param reason
       *            the reason why this operation in not supported
       * @throws DataSetException
       */
      static public void throwUnsuportedOperationException(String reason) throws DataSetException
      {
          StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
  
          throw new DataSetException(reason, new RuntimeException("Unsuported Dataset Operation: "
                  + stackTraceElements[1].getClassName() + stackTraceElements[1].getMethodName() + "\n" + reason));
      }
  
      /** The attributes definition objects */
      protected CaseInsensitiveHashMap<AttributeDefinition> attributesDefinition;
  
      /** the changes recorder */
      private LinkedHashMap<String, ChangeDescriptor<T>> changeSet = new LinkedHashMap<String, ChangeDescriptor<T>>();
  
      /** The data object class */
      protected Class<T> clazz;
  
      /** The attribute to use as the data object id */
      protected String idAttribute = "id";
  
      /** a possible ID generator to use for inserts */
      private IIDGenerator<T> idGenerator;
  
      /** if T will not report development errors */
      boolean ignoreDevelopmentErrors = false;
  
      /** if T will track all changes made to the dataset from this point on */
      private boolean trackChanges = false;
  
      /**
       * Default constructor
       * 
       * @param clazz
       */
      public AbstractDataSet(Class<T> clazz)
      {
          this.clazz = clazz;
      }
  
      /**
       * @see pt.digitalis.dif.model.dataset.IDataSet#delete(java.lang.String)
       */
      final public boolean delete(String id) throws DataSetException
      {
          if (this.isTrackChanges())
          {
              T instance = this.get(id);
  
              // Only if the id is in fact in the current dataset
              if (instance != null)
              {
                  // See if previous changes exist for this record
                  ChangeDescriptor<T> change = this.getInternalChangeSet().get(id);
  
                  if (change == null)
                  {
                      // No previous changes. Add the deletion.
                      change = new ChangeDescriptor<T>(DMLOperation.DELETE, RecordType.ORIGINAL, instance);
                      this.getInternalChangeSet().put(id, change);
                  }
                  else
                 {
                     // Previous changes exist. Keep previous record type (could be NEW for inserted or UPDATED for
                     // changed record
                     change = new ChangeDescriptor<T>(DMLOperation.DELETE, change.getRecordType(), instance);
                     this.getInternalChangeSet().put(id, change);
                 }
             }
         }
 
         return this.deleteSpecific(id);
     }
 
     /**
      * Deletes a given data object
      * 
      * @param id
      *            the id of the object to delete
      * @return T if the update was successful
      * @throws DataSetException
      */
     abstract public boolean deleteSpecific(String id) throws DataSetException;
 
     /**
      * Detects the current data object attributes
      */
     protected void detectAttributeDefinition()
     {
         if (clazz != null)
         {
             PropertyDescriptor[] propDescriptors = PropertyUtils.getPropertyDescriptors(clazz);
             CaseInsensitiveHashMap<AttributeDefinition> tempAttributesDef = new CaseInsensitiveHashMap<AttributeDefinition>();
 
             for (PropertyDescriptor propDescriptor: propDescriptors)
             {
 
                 if (!propDescriptor.getName().equals("class") && !propDescriptor.getName().equals("bytes")
                         && (propDescriptor.getPropertyType() != Map.class)
                         && (propDescriptor.getPropertyType() != List.class)
                         && (propDescriptor.getPropertyType() != Set.class))
                 {
                     AttributeDefinition def = new AttributeDefinition(propDescriptor.getName(),
                             StringUtils.camelCaseToString(propDescriptor.getName()), propDescriptor.getPropertyType());
 
                     tempAttributesDef.put(propDescriptor.getName(), def);
                 }
             }
 
             attributesDefinition = tempAttributesDef;
         }
     }
 
     /**
      * Executed a given query.
      * 
      * @param query
      *            the query object to execute
      * @return the list of business instances
      * @throws DataSetException
      *             the data set exception
      */
     @SuppressWarnings("unchecked")
     public List<T> executeQuery(Query<T> query) throws DataSetException
     {
         CollectorListProcessor processor = new CollectorListProcessor();
         this.executeQuery(query, processor);
 
         return (List<T>) processor.getList();
     }
 
     /**
      * @see pt.digitalis.dif.model.dataset.IDataSet#getAttributeDefinition(java.lang.String)
      */
     public AttributeDefinition getAttributeDefinition(String attribute)
     {
         return this.getAttributesDefinition().get(attribute);
     }
 
     /**
      * @see pt.digitalis.dif.model.dataset.IDataSet#getAttributeList()
      */
     public CaseInsentiveArrayList getAttributeList()
     {
         return new CaseInsentiveArrayList(getAttributesDefinition().keySet());
     }
 
     /**
      * @see pt.digitalis.dif.model.dataset.IDataSet#getAttributesDefinition()
      */
     public CaseInsensitiveHashMap<AttributeDefinition> getAttributesDefinition()
     {
 
         if (attributesDefinition == null)
             detectAttributeDefinition();
 
         return attributesDefinition;
     }
 
     /**
      * @see pt.digitalis.dif.model.dataset.IDataSet#getChanges()
      */
     public Map<String, ChangeDescriptor<T>> getChanges() throws DataSetException
     {
         LinkedHashMap<String, ChangeDescriptor<T>> result = new LinkedHashMap<String, ChangeDescriptor<T>>();
 
         for (Entry<String, ChangeDescriptor<T>> change: this.getInternalChangeSet().entrySet())
         {
             ChangeDescriptor<T> internalChangeDescriptor = change.getValue();
 
             if (internalChangeDescriptor.getOperation() == DMLOperation.DELETE
                     && internalChangeDescriptor.getRecordType() == RecordType.NEW)
                 // A record that was inserted and deleted afterwards.
                 // No need to report, the end result is the same as in the beginning
                 ;
             else
             {
                 T bean = internalChangeDescriptor.getBeanInstance();
                 if (bean == null)
                     bean = this.get(change.getKey());
 
                 ChangeDescriptor<T> newChangeDescriptor = new ChangeDescriptor<T>(
                         internalChangeDescriptor.getOperation(), internalChangeDescriptor.getRecordType(), bean);
 
                 result.put(change.getKey(), newChangeDescriptor);
             }
         }
 
         return result;
     }
 
     /**
      * @see pt.digitalis.dif.model.dataset.IDataSet#getIDFieldName()
      */
     public String getIDFieldName()
     {
         return idAttribute;
     }
 
     /**
      * Inspector for the 'idGenerator' attribute.
      * 
      * @return the idGenerator value
      */
     public IIDGenerator<T> getIdGenerator()
     {
         return idGenerator;
     }
 
     /**
      * Inspector for the 'changeSet' attribute.
      * 
      * @return the changeSet value
      */
     protected Map<String, ChangeDescriptor<T>> getInternalChangeSet()
     {
         return changeSet;
     }
 
     /**
      * @see pt.digitalis.dif.model.dataset.IDataSet#insert(java.lang.String, java.util.Map)
      */
     public T insert(String id, Map<String, String> attributeValues) throws DataSetException
     {
 
         T instance = instanciateDataObject(attributeValues);
         if (id != null)
         {
             instance.setAttributeFromString(idAttribute, id);
         }
 
         return insert(instance);
     }
 
     /**
      * @see pt.digitalis.dif.model.dataset.IDataSet#insert(pt.digitalis.utils.common.IBeanAttributes)
      */
     final public T insert(T instance) throws DataSetException
     {
         // No ID passed and an ID generator exists. Use it!
         if (this.getIdGenerator() != null && instance.getAttribute(this.getIDFieldName()) == null)
         {
             String newID = this.getIdGenerator().generateID(instance);
             instance.setAttributeFromString(this.getIDFieldName(), newID);
         }
 
         instance = this.insertSpecific(instance);
 
         if (this.getIdGenerator() != null)
             this.getIdGenerator().reportInsertedID(instance.getAttributeAsString(this.getIDFieldName()));
 
         // TrackChanges
         if (this.isTrackChanges())
         {
             if (instance.getAttribute(this.getIDFieldName()) == null)
                 throwUnsuportedOperationException("Cannot use track changes for empty ID inserts. "
                         + "Set the ID field before inserting the record in the dataset.");
             else
             {
                 ChangeDescriptor<T> change = this.getInternalChangeSet().get(
                         instance.getAttributeAsString(this.getIDFieldName()));
 
                 if (change == null)
                 {
                     // New record
                     change = new ChangeDescriptor<T>(DMLOperation.INSERT, RecordType.NEW, null);
                     this.getInternalChangeSet().put(instance.getAttributeAsString(this.getIDFieldName()), change);
                 }
                 else
                 {
                     // Record has already existed
                     if (change.getRecordType() == RecordType.NEW)
                         // New record, keep previous change set but with INSERT instead of delete
                         change = new ChangeDescriptor<T>(DMLOperation.INSERT, RecordType.NEW, null);
                     else
                     {
                         // Not new, then a possible delete that has now been restored, or previous update that will be
                         // overridden by this insert.
                         change = new ChangeDescriptor<T>(DMLOperation.UPDATE, RecordType.UPDATED, null);
                     }
 
                     this.getInternalChangeSet().put(instance.getAttributeAsString(this.getIDFieldName()), change);
                 }
             }
         }
 
         return instance;
     }
 
     /**
      * Inserts a new data object
      * 
      * @param instance
      *            the data object to insert, with the new values
      * @return the inserted data object
      * @throws DataSetException
      */
     abstract public T insertSpecific(T instance) throws DataSetException;
 
     /**
      * @return an instantiated generic data object
      */
     protected T instanciateDataObject()
     {
         if (clazz != null)
         {
             try
             {
                 T instance = clazz.newInstance();
 
                 return instance;
             }
             catch (InstantiationException e)
             {
                 return null;
             }
             catch (IllegalAccessException e)
             {
                 return null;
             }
         }
         return null;
     }
 
     /**
      * @param attributeValues
      *            the values to set the instance attributes with
      * @return an instantiated generic data object
      */
     protected T instanciateDataObject(Map<String, String> attributeValues)
     {
         T instance = instanciateDataObject();
 
         if (instance != null)
             for (Entry<String, String> entry: attributeValues.entrySet())
                 instance.setAttributeFromString(entry.getKey(), entry.getValue());
 
         return instance;
     }
 
     /**
      * @see pt.digitalis.dif.model.dataset.IDataSet#isCompositeID()
      */
     public boolean isCompositeID()
     {
         return false;
     }
 
     /**
      * @see pt.digitalis.dif.model.dataset.IDataSet#isIgnoreDevelopmentErrors()
      */
     public boolean isIgnoreDevelopmentErrors()
     {
         return ignoreDevelopmentErrors;
     }
 
     /**
      * @see pt.digitalis.dif.model.dataset.IDataSet#isTrackChanges()
      */
     public boolean isTrackChanges()
     {
         return trackChanges;
     }
 
     /**
      * @see pt.digitalis.dif.model.dataset.IDataSet#newDataInstance()
      */
     public T newDataInstance()
     {
         return instanciateDataObject();
     }
 
     /**
      * @see pt.digitalis.dif.model.dataset.IDataSet#query()
      */
     public Query<T> query()
     {
         return new Query<T>(this, true, true);
     }
 
     /**
      * @see pt.digitalis.dif.model.dataset.IDataSet#refresh(pt.digitalis.utils.common.IBeanAttributes)
      */
     public T refresh(T instance) throws DataSetException
     {
         return instance;
     }
 
     /**
      * @see pt.digitalis.dif.model.dataset.IDataSet#resetTrackChanges()
      */
     public void resetTrackChanges()
     {
         this.getInternalChangeSet().clear();
     }
 
     /**
      * Modifier for the 'idGenerator' attribute.
      * 
      * @param idGenerator
      *            the new idGenerator value to set
      * @throws DataSetException
      */
     public void setIdGenerator(IIDGenerator<T> idGenerator) throws DataSetException
     {
         if (this.isCompositeID())
             throwUnsuportedOperationException("Can only use ID Generator for non-composite ID datasets");
         else
             this.idGenerator = idGenerator;
     }
 
     /**
      * @see pt.digitalis.dif.model.dataset.IDataSet#setIgnoreDevelopmentErrors(boolean)
      */
     public void setIgnoreDevelopmentErrors(boolean ignoreDevelopmentErrors)
     {
         this.ignoreDevelopmentErrors = ignoreDevelopmentErrors;
     }
 
     /**
      * @see pt.digitalis.dif.model.dataset.IDataSet#setTrackChanges(boolean)
      */
     public void setTrackChanges(boolean trackChanges)
     {
         this.trackChanges = trackChanges;
 
         if (trackChanges)
             changeSet = new LinkedHashMap<String, ChangeDescriptor<T>>();
     }
 
     /**
      * @see pt.digitalis.dif.model.dataset.IDataSet#undelete(java.lang.String)
      */
     public T undelete(String id) throws DataSetException
     {
         if (!this.isTrackChanges())
         {
             throwUnsuportedOperationException("Cannot undelete a record without track changes active");
 
             // Does not reach here. Just for Eclipse complication errors sake!
             return null;
         }
         else
         {
             ChangeDescriptor<T> change = this.getInternalChangeSet().get(id);
 
             if (change == null)
             {
                 String messageRecordId = this.clazz.getSimpleName() + "[" + id + "]";
                 throw new DataSetException("Record not found for recover: " + messageRecordId);
             }
             else
             {
                 // Reinsert it in the database
                 T instance = this.insertSpecific(change.getBeanInstance());
 
                 if (change.getRecordType() == RecordType.NEW)
                 {
                     // New record, keep previous change set but with INSERT instead of delete
                     change = new ChangeDescriptor<T>(DMLOperation.INSERT, RecordType.NEW, null);
                 }
                 else if (change.getRecordType() == RecordType.UPDATED)
                 {
                     // Previously updated record, keep previous change set but with UPDATE instead of delete
                     change = new ChangeDescriptor<T>(DMLOperation.UPDATE, RecordType.UPDATED, null);
                 }
                 else
                 {
                     // Original record deleted.
                     // Undelete replaced the original data so, the change became irrelevant. Remove it.
                     change = null;
                 }
 
                 if (change == null)
                     this.getInternalChangeSet().remove(id);
                 else
                     this.getInternalChangeSet().put(id, change);
 
                 return instance;
             }
         }
     }
 
     /**
      * @see pt.digitalis.dif.model.dataset.IDataSet#update(java.lang.String, java.util.Map)
      */
     public T update(String id, Map<String, String> attributeValues) throws DataSetException
     {
 
         T instance = get(id);
 
         if (instance != null)
         {
             for (Entry<String, String> prop: attributeValues.entrySet())
             {
 
                 if (prop.getValue() == null)
                     instance.setAttribute(prop.getKey(), null);
                 else if (!(instance.getAttribute(prop.getKey()) instanceof String) && "".equals(prop.getValue()))
                     instance.setAttribute(prop.getKey(), null);
                 else
                     instance.setAttributeFromString(prop.getKey(), prop.getValue());
             }
             return update(instance);
         }
         else
             return null;
     }
 
     /**
      * @see pt.digitalis.dif.model.dataset.IDataSet#update(pt.digitalis.utils.common.IBeanAttributes)
      */
     final public T update(T instance) throws DataSetException
     {
         instance = this.updateSpecific(instance);
 
         if (this.isTrackChanges() && this.get(instance.getAttributeAsString(this.getIDFieldName())) != null)
         {
             // Only if the id is in fact in the current dataset
             // See if previous changes exist for this record
             String id = instance.getAttributeAsString(this.getIDFieldName());
             ChangeDescriptor<T> change = this.getInternalChangeSet().get(id);
 
             if (change == null)
             {
                 // No previous changes. Add the update.
                 change = new ChangeDescriptor<T>(DMLOperation.UPDATE, RecordType.UPDATED, null);
                 this.getInternalChangeSet().put(id, change);
             }
             else
             {
                 // Previous changes exist. If it's a NEW record, keep it, since changes to a non persisted record are
                 // translated to an insert anyway
                 if (change.getRecordType() == RecordType.NEW)
                     change = new ChangeDescriptor<T>(DMLOperation.INSERT, RecordType.NEW, null);
                 else
                     change = new ChangeDescriptor<T>(DMLOperation.UPDATE, RecordType.UPDATED, null);
 
                 this.getInternalChangeSet().put(id, change);
             }
         }
 
         return instance;
     }
 
     /**
      * @see pt.digitalis.dif.model.dataset.IDataSet#updateBean(pt.digitalis.utils.common.IBeanAttributes)
      */
     public T updateBean(T instance) throws DataSetException
     {
         return update(instance);
     }
 
     /**
      * Updates a given data object
      * 
      * @param instance
      *            the data object to update, with the new values
      * @return the updated data object
      * @throws DataSetException
      */
     abstract public T updateSpecific(T instance) throws DataSetException;
 
 }