/**
    * Copyright 2005-2016 The Kuali Foundation
    *
    * Licensed under the Educational Community License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    * http://www.opensource.org/licenses/ecl2.php
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.kuali.rice.core.api.mo;
  
  import org.apache.commons.lang.builder.EqualsBuilder;
  import org.apache.commons.lang.builder.HashCodeBuilder;
  import org.apache.commons.lang.builder.ToStringBuilder;
  import org.kuali.rice.core.api.CoreConstants;
  import org.kuali.rice.core.api.util.collect.CollectionUtils;
  
  import javax.xml.bind.Unmarshaller;
  import javax.xml.bind.annotation.XmlTransient;
  import java.io.IOException;
  import java.io.ObjectInputStream;
  import java.io.ObjectOutputStream;
  import java.lang.reflect.Field;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.Collections;
  
  /**
   * All model object's that are Jaxb annotated should extend this class.
   *
   * This class does several important things:
   * <ol>
   *     <li>Defines jaxb callback method to ensure that Collection and Map types are unmarshalled into immutable empty forms rather than null values</li>
   *     <li>Defines equals/hashcode/toString</li>
   *
   *     Note: the equals/hashCode implementation excludes {@value CoreConstants.CommonElements#FUTURE_ELEMENTS} field.
   *     This element should be present on all jaxb annotated classes.
   * </ol>
   *
   * <b>Important: all classes extending this class must be immutable</b>
   */
  @XmlTransient // marked as @XmlTransient so that an AbstractDataTransferObjectType is not included in all WSDL schemas
  public abstract class AbstractDataTransferObject implements ModelObjectComplete {
  
      private transient volatile Integer _hashCode;
      private transient volatile String _toString;
  
      protected AbstractDataTransferObject() {
          super();
      }
  
      /**
       * compute or return the memoized hashcode for this immutable class, excluding the named fields.
       * @param excludedFields the names of fields to exclude when computing the hashcode.
       * @return the hashcode value
       * @see #equalsExcludeFields(Object, java.util.Collection)
       * @see #getDefaultHashCodeEqualsExcludeFields()
       */
      protected final int hashCodeExcludeFields(Collection<String> excludedFields) {
          //using DCL idiom to cache hashCodes.  Hashcodes on immutable objects never change.  They can be safely cached.
          //see effective java 2nd ed. pg. 71
          Integer h = _hashCode;
          if (h == null) {
              synchronized (this) {
                  h = _hashCode;
                  if (h == null) {
                      _hashCode = h = Integer.valueOf(HashCodeBuilder.reflectionHashCode(this, excludedFields));
                  }
              }
          }
  
          return h.intValue();
      }
  
      @Override
      public int hashCode() {
          return hashCodeExcludeFields(Constants.hashCodeEqualsExclude);
      }
  
      /**
       * Indicates whether the obj parameter is equal to this object.  Uses {@link org.apache.commons.lang.builder.EqualsBuilder#reflectionEquals(Object, Object, java.util.Collection)}
       * and takes the names of fields to exclude from comparison.
       * @param obj the other object to compare to
       * @param excludedFields the names of fields to exclude when computing the hashcode.
       * @return if equal
       * @see #hashCodeExcludeFields(java.util.Collection)
       * @see #getDefaultHashCodeEqualsExcludeFields()
       */
      protected final boolean equalsExcludeFields(Object obj, Collection<String> excludedFields) {
          return EqualsBuilder.reflectionEquals(obj, this, excludedFields);
      }
  
      @Override
     public boolean equals(Object obj) {
         return equalsExcludeFields(obj, Constants.hashCodeEqualsExclude);
     }
 
     @Override
     public String toString() {
         //using DCL idiom to cache toString.  toStrings on immutable objects never change.  They can be safely cached.
         //see effective java 2nd ed. pg. 71
         String t = _toString;
         if (t == null) {
             synchronized (this) {
                 t = _toString;
                 if (t == null) {
                     _toString = t = ToStringBuilder.reflectionToString(this);
                 }
             }
         }
 
         return t;
     }
 
     @SuppressWarnings("unused")
     protected void beforeUnmarshal(Unmarshaller u, Object parent) throws Exception {
     }
 
     @SuppressWarnings("unused")
     protected void afterUnmarshal(Unmarshaller u, Object parent) throws Exception {
         CollectionUtils.makeUnmodifiableAndNullSafe(this);
     }
 
     private transient Object serializationMutex = new Object();
 
     private void writeObject(ObjectOutputStream out) throws IOException {
         synchronized (serializationMutex) {
             clearFutureElements();
             out.defaultWriteObject();
         }
     }
 
     private void readObject(ObjectInputStream ois) throws IOException,
             ClassNotFoundException {
         ois.defaultReadObject();
         serializationMutex = new Object();
     }
 
     /**
      * Looks for a field named "_futureElements" on the class and clears it's value if it exists.  This allows us to
      * prevent from storing these values during serialization.
      */
     private void clearFutureElements() {
         try {
             Field futureElementsField = getClass().getDeclaredField(CoreConstants.CommonElements.FUTURE_ELEMENTS);
             boolean originalAccessible = futureElementsField.isAccessible();
             futureElementsField.setAccessible(true);
             try {
                 futureElementsField.set(this, null);
             } finally {
                 futureElementsField.setAccessible(originalAccessible);
             }
         } catch (NoSuchFieldException e) {
             // if the field does not exist, don't do anything
         } catch (IllegalAccessException e) {
             // can't modify the field, ignore
         }
     }
 
 
     /**
      * Defines some internal constants used on this class.
      */
     protected static class Constants {
         final static Collection<String> hashCodeEqualsExclude = Collections.unmodifiableCollection(
                 Arrays.asList(CoreConstants.CommonElements.FUTURE_ELEMENTS, "_hashCode", "_toString")
         );
     }
 
     protected static final Collection<String> getDefaultHashCodeEqualsExcludeFields() {
         return Constants.hashCodeEqualsExclude;
     }
 }