package org.starobjects.jpa.runtime.persistence.oid;
   
   import static org.hamcrest.CoreMatchers.*;
   
   import java.io.IOException;
   import java.io.Serializable;
   import java.text.NumberFormat;
   import java.text.ParseException;
   import java.util.HashMap;
  import java.util.Map;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import javax.persistence.DiscriminatorValue;
  
  import org.nakedobjects.metamodel.adapter.oid.Oid;
  import org.nakedobjects.metamodel.adapter.oid.stringable.directly.DirectlyStringableOid;
  import org.nakedobjects.metamodel.commons.encoding.DataInputExtended;
  import org.nakedobjects.metamodel.commons.encoding.DataOutputExtended;
  
  import static org.nakedobjects.metamodel.commons.ensure.Ensure.*;
  import org.nakedobjects.metamodel.spec.NakedObjectSpecification;
  import org.nakedobjects.metamodel.specloader.NakedObjectReflector;
  import org.nakedobjects.metamodel.util.ClassUtil;
  import org.nakedobjects.runtime.context.NakedObjectsContext;
  import org.nakedobjects.runtime.persistence.oidgenerator.OidGenerator;
  import org.nakedobjects.runtime.persistence.services.ServiceUtil;
  import org.starobjects.jpa.metamodel.facets.object.discriminator.JpaDiscriminatorValueFacet;
  import org.starobjects.jpa.metamodel.facets.object.entity.JpaEntityFacet;
  import org.starobjects.jpa.metamodel.specloader.DiscriminatorCache;
  
  
  public final class JpaOid implements Oid, Cloneable, DirectlyStringableOid {
  
      private static final long serialVersionUID = 1L;
  
      private static final String DESTRING_IAE_EXCEPTION_MSG =
              "Does not match format XXX|nnnn (persistent) or XXX|nnnn~ (transient)";
      private static Pattern DESTRING_PATTERN = Pattern
              .compile("^([A-Z]+)\\|([0-9]+)(~?)$");
  
      private static Map<Class<?>,String> discriminatorByClass = new HashMap<Class<?>,String>();
  
      private static String lookupDiscriminator(String className) {
          try {
              Class<?> cls = Thread.currentThread().getContextClassLoader().loadClass(className);
              return lookupDiscriminator(cls);
          } catch (ClassNotFoundException e) {
              return className; // fallback
          }
      }
  
      private static String lookupDiscriminator(Class<?> cls) {
          String discriminator = discriminatorByClass.get(cls);
          if (discriminator == null) {
              discriminator = lookupAndStoreDiscriminator(cls, discriminator);
          }
          if (discriminator != null) {
              return discriminator;
          }
          // search up hierarchy
          Class<?> superclass = cls.getSuperclass();
          if (superclass == null) {
              return cls.getName(); // fallback
          }
          return lookupDiscriminator(superclass); 
      }
  
      private static synchronized String lookupAndStoreDiscriminator(Class<?> cls,
              String discriminator) {
          DiscriminatorValue discriminatorValue = cls.getAnnotation(DiscriminatorValue.class);
          if (discriminatorValue == null) {
              return null;
          } 
          discriminator = discriminatorValue.value();
          discriminatorByClass.put(cls, discriminator);
          return discriminator;
      }
      
      public static void testReset() {
          discriminatorByClass.clear();
      }
  
      private String classname;
      private Number id;
      private Number newId;
      private boolean isTransient;
      private JpaOid previous;
  
      private String discriminator;
  
      private int cachedHashCode;
      private String cachedToString;
      private String cachedEnstring;
  
  
      private static enum State {
          TRANSIENT,
          PERSISTENT;
 
         public boolean isTransient() {
             return this == TRANSIENT;
         }
 
         @SuppressWarnings("unused")
         public boolean isPersistent() {
             return this == PERSISTENT;
         }
 
         public static State decode(final boolean isTransient) {
             return isTransient ? TRANSIENT : PERSISTENT;
         }
     }
 
     // /////////////////////////////////////////////////////////
     // Factory methods
     // /////////////////////////////////////////////////////////
 
     /**
      * Create a new transient instance using the provided <tt>id</tt>.
      * 
      * @see #createTransient(String, Number) for postconditions.
      */
     public static JpaOid createTransient(
             final Class<?> clazz,
             final Number id) {
         return createTransient(clazz.getName(), id);
     }
 
     /**
      * Create a new transient id.
      * <p>
      * The {@link #getNewId()} will initially be <tt>null</tt>.
      */
     public static JpaOid createTransient(
             final String className,
             final Number id) {
         return createTransient(className, id, null);
     }
 
     /**
      * Create a new transient id.
      * <p>
      * The {@link #getNewId()} will initially be <tt>null</tt>.
      */
     public static JpaOid createTransient(
             final String className,
             final Number id,
             final String discriminator) {
         return new JpaOid(className, id, null, State.TRANSIENT, discriminator);
     }
 
     /**
      * Creates a new persistent instance, using the specified <tt>id</tt>.
      * 
      * @see #createPersistent(String, Serializable) for postconditions.
      */
     public static JpaOid createPersistent(
             final Class<?> clazz,
             final Number id) {
         return createPersistent(clazz.getName(), id);
     }
 
     /**
      * Creates a new persistent instance, using the specified <tt>id</tt>.
      * <p>
      * The {@link #getNewId()} will be the same as the <tt>primaryKey</tt>.
      */
     public static JpaOid createPersistent(
             final String className,
             final Number id) {
         return createPersistent(className, id, null);
     }
 
     /**
      * Creates a new persistent instance, using the specified <tt>id</tt>.
      * <p>
      * The {@link #getNewId()} will be the same as the <tt>primaryKey</tt>.
      */
     public static JpaOid createPersistent(
             final String className,
             final Number id,
             final String discriminator) {
         return new JpaOid(className, id, null, State.PERSISTENT, discriminator);
     }
 
     // /////////////////////////////////////////////////////////
     // Constructor
     // /////////////////////////////////////////////////////////
 
     /**
      * If the <tt>discriminator</tt> is blank, then will lookup from classname.
      */
     private JpaOid(
             final String classname,
             final Number id,
             final Number newId,
             final State state,
             final String discriminator) {
         this.classname = classname;
         this.id = id;
         this.newId = newId;
         this.isTransient = state.isTransient();
         this.discriminator = lookupDiscriminatorIfRequired(discriminator);
         initialized();
     }
 
     private String lookupDiscriminatorIfRequired(final String discriminator) {
         if (discriminator != null)
             return discriminator;
         else
             return lookupDiscriminator(this.getClassName());
     }
 
 
     public JpaOid(final DataInputExtended input) throws IOException {
         this.classname = input.readUTF();
         this.id = input.readSerializable(Number.class);
         this.isTransient = input.readBoolean();
         this.newId = input.readSerializable(Number.class);
         this.previous = input.readEncodable(JpaOid.class);
         initialized();
     }
 
     public void encode(final DataOutputExtended output) throws IOException {
         output.writeUTF(classname);
         output.writeSerializable(id);
         output.writeBoolean(isTransient);
         output.writeSerializable(newId);
         output.writeEncodable(previous);
     }
 
     private void initialized() {
         cacheState();
     }
 
     // /////////////////////////////////////////////////////////
     // copyFrom
     // /////////////////////////////////////////////////////////
 
     public void copyFrom(final Oid oid) {
         ensureThatArg(oid instanceof JpaOid, is(true));
         final JpaOid from = (JpaOid) oid;
         this.id = from.id;
         this.classname = from.classname;
         this.newId = from.newId;
         this.isTransient = from.isTransient;
         cacheState();
     }
 
     // /////////////////////////////////////////////////////////
     // className, id, discriminator
     // /////////////////////////////////////////////////////////
 
     /**
      * Used in {@link #equals(Object)}.
      */
     public String getClassName() {
         return classname;
     }
 
     /**
      * Used in {@link #equals(Object)}.
      * <p>
      * Will be the same as the {@link #getNewId()} once the Oid has been
      * {@link #makePersistent() made persistent}.
      * 
      * @return
      */
     public Number getId() {
         return id;
     }
     
     public String getDiscriminator() {
         return discriminator;
     }
     
 
     // /////////////////////////////////////////////////////////
     // makePersistent, HibernateId
     // /////////////////////////////////////////////////////////
 
     /**
      * Use the {@link #getNewId() jpa Id} as the {@link #getId() primary key},
      * in the
      * process marking the Oid as {@link #isTransient() persistent}, and storing
      * the {@link #getPrevious() previous} value.
      * <p>
      * Note 1: should be preceded by a call to {@link #setNewId(Serializable)}
      * to set the {@link #getNewId() jpa Id}. The two methods cannot be combined
      * because of {@link OidGenerator#convertPersistentToTransientOid(Oid)}. If
      * this is not done then the id is left unchanged.
      * <p>
      * Note 2: if called then the {@link #hashCode()} may change; it is the
      * caller's responsibility to manage any {@link Map}s that the Oid might be
      * using.
      */
     public void makePersistent() {
         ensureThatState(isTransient(), is(true));
         this.previous = new JpaOid(this.classname, this.id, null,
                 State.TRANSIENT, this.discriminator);
 
         if (newId != null) {
             id = newId;
         }
         this.isTransient = false;
         newId = null;
         cacheState();
     }
 
 
     /**
      * The id set by {@link #setNewId(Long)}.
      * <p>
      * Will return <tt>null</tt> once the Oid has been {@link #makePersistent()
      * made persistent}.
      */
     public Number getNewId() {
         return newId;
     }
 
     /**
      * Update the Id, prior to {@link #makePersistent()}.
      * <p>
      * The new Id does not come into effect until {@link #makePersistent()} is
      * called.
      */
     public void setNewId(final Number newId) {
         this.newId = newId;
         cacheState();
     }
 
 
     // /////////////////////////////////////////////////////////
     // getPrevious, hasPrevious
     // /////////////////////////////////////////////////////////
 
     /**
      * The previous Oid, if any.
      * <p>
      * Will hold this {@link Oid} in its transient form once
      * {@link #makePersistent()} has been called. This allows client-side code
      * to maintain its Oid->Object maps.
      */
     public Oid getPrevious() {
         return previous;
     }
 
     public boolean hasPrevious() {
         return previous != null;
     }
 
     public void clearPrevious() {
         previous = null;
     }
 
 
     // /////////////////////////////////////////////////////////
     // isTransient
     // /////////////////////////////////////////////////////////
 
     public boolean isTransient() {
         return isTransient;
     }
 
 
     // /////////////////////////////////////////////////////////
     // DirectlyStringableOid
     // /////////////////////////////////////////////////////////
 
 
     public static JpaOid deString(final String oidStr) {
         final NakedObjectReflector reflector =
                 (NakedObjectReflector) NakedObjectsContext
                 .getSpecificationLoader();
         final DiscriminatorCache discriminatorCache =
                 (DiscriminatorCache) reflector.getMetaModelValidator();
         return deString(oidStr, discriminatorCache);
     }
 
     public static JpaOid deString(final String oidStr,
             final DiscriminatorCache discriminatorCache) {
         if (oidStr == null) {
             return null;
         }
         final Matcher matcher = DESTRING_PATTERN.matcher(oidStr);
         if (!matcher.matches()) {
             throw new IllegalArgumentException(DESTRING_IAE_EXCEPTION_MSG);
         }
         final String discriminator = matcher.group(1);
         final NakedObjectSpecification noSpec = discriminatorCache
                 .lookupClassFor(discriminator);
         if (noSpec == null) {
             throw new IllegalArgumentException("Unknown discriminator '" + discriminator + "'");
         }
         final String className = noSpec.getFullName();
 
         final String idStr = matcher.group(2);
         Number id;
         try {
             id = NumberFormat.getInstance().parse(idStr);
         } catch (final ParseException e) {
             throw new IllegalArgumentException(DESTRING_IAE_EXCEPTION_MSG);
         }
 
         final String transientStr = matcher.group(3);
         return transientStr != null ? JpaOid.createTransient(className, id, discriminator)
                 : JpaOid.createPersistent(className, id, discriminator);
     }
 
     public String enString() {
         return cachedEnstring;
     }
 
 
     // /////////////////////////////////////////////////////////
     // equals, hashCode impl.
     // /////////////////////////////////////////////////////////
 
     @Override
     public boolean equals(final Object other) {
         if (other == this) {
             return true;
         }
         if (getClass() != other.getClass()) {
             return false;
         }
         return equals((JpaOid) other);
     }
 
     public boolean equals(final JpaOid other) {
         return isTransient == other.isTransient &&
                 classname.equals(other.classname) &&
                 id.equals(other.id);
     }
 
     /**
      * Note that the hashCode changes when {@link #makePersistent() persisted}.
      * Therefore
      * the Oid must be removed from any maps prior to this.
      */
     @Override
     public int hashCode() {
         return cachedHashCode;
     }
 
     private void cacheState() {
         cachedHashCode = 17;
         cachedHashCode = 37 * cachedHashCode + classname.hashCode();
         cachedHashCode = 37 * cachedHashCode + id.hashCode();
 
         cachedToString = (isTransient() ? "T" : "") + "HOID#" + id.toString()
                 + "/" + classname
                 + (newId == null ? "" : "(" + newId + ")")
                 + (previous == null ? "" : "+");
 
         cachedEnstring = discriminator + "|" + this.id + (isTransient?"~":"");
     }
 
 
     // /////////////////////////////////////////////////////////
     // Cloneable
     // /////////////////////////////////////////////////////////
 
     @Override
     public JpaOid clone() {
         final JpaOid jpaOid = new JpaOid(this.classname, this.id, this.newId,
                 State.decode(this.isTransient), this.discriminator);
         jpaOid.previous = this.previous;
         return jpaOid;
     }
 
 
     // /////////////////////////////////////////////////////////
     // toString
     // /////////////////////////////////////////////////////////
 
     @Override
     public String toString() {
         return cachedToString;
     }
 
 
 }