package org.apache.ojb.broker.metadata;
   
   /* Copyright 2002-2005 The Apache Software Foundation
    *
    * Licensed under the Apache 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.apache.org/licenses/LICENSE-2.0
   *
   * 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.
   */
  
  import java.util.Hashtable;
  import java.util.Iterator;
  import java.util.Vector;
  
  import org.apache.commons.lang.builder.ToStringBuilder;
  import org.apache.ojb.broker.OJBRuntimeException;
  import org.apache.ojb.broker.PersistenceBrokerException;
  import org.apache.ojb.broker.core.proxy.ProxyHelper;
  import org.apache.ojb.broker.metadata.fieldaccess.PersistentField;
  
  /**
   * Describes a Field containing a reference to another class. Provides handling for foreign keys etc.
   * <br>
   * Note: Be careful when use references of this class or caching instances of this class,
   * because instances could become invalid (see {@link MetadataManager}).
   *
   * @author <a href="mailto:thma@apache.org">Thomas Mahler<a>
   *
   */
  public class ObjectReferenceDescriptor extends AttributeDescriptorBase implements XmlCapable
  {
      private static final long serialVersionUID = 5561562217150972131L;
  
      public static final int CASCADE_NONE = 17;
      public static final int CASCADE_LINK = 19;
      public static final int CASCADE_OBJECT = 23;
  
      private Class m_ClassOfItems = null;
      private Vector m_ForeignKeyFields = new Vector();
      private boolean m_CascadeRetrieve = true;
      private int m_CascadeStore = CASCADE_NONE;
      private int m_CascadeDelete = CASCADE_NONE;
      private int m_ProxyPrefetchingLimit = 50;
  
      private Class m_ProxyOfItems = null;
      private boolean m_LookedUpProxy = false;
      private boolean m_OtmDependent = false;
  
      /**
       * holds the foreign-key field descriptor array for a specified class
       */
      private Hashtable fkFieldMap = new Hashtable();
      /**
       * define loading strategy of the resulting object
       */
      private boolean lazy = false;
      /**
       * if true relationship is refreshed when owner is found in cache
       */
      private boolean refresh = false;
  
      /**
       *
       */
      public ObjectReferenceDescriptor(ClassDescriptor descriptor)
      {
          super(descriptor);
      }
  
      /**
       *
       */
      public Class getItemProxyClass() throws PersistenceBrokerException
      {
          if (!m_LookedUpProxy)
          {
              m_ProxyOfItems = getClassDescriptor().getRepository().
                                  getDescriptorFor(m_ClassOfItems).getProxyClass();
              m_LookedUpProxy = true;
          }
          return m_ProxyOfItems;
      }
  
      /**
       *
       */
  	public FieldDescriptor[] getForeignKeyFieldDescriptors(ClassDescriptor cld)
  	{
  		FieldDescriptor[] foreignKeyFieldDescriptors;
  		if ((foreignKeyFieldDescriptors = (FieldDescriptor[]) fkFieldMap.get(cld)) == null)
  		{
  			// 1. collect vector of indices of Fk-Fields
 			Vector v = getForeignKeyFields();
 			// 2. get FieldDescriptor for each index from Class-descriptor
 			// 2A. In a many-to-many relationship foreignkeyfields vector will be null.
 			if (v != null)
 			{
 				Vector ret;
 				if (cld.isInterface())
 				{
 					//exchange interface class descriptor with first concrete
 					//class
 					Vector extents = cld.getExtentClasses();
 					Class firstConcreteClass = (Class) extents.get(0);
 					cld = getClassDescriptor().getRepository().getDescriptorFor(firstConcreteClass);
 				}
 				ret = new Vector();
 
 				Iterator iter = v.iterator();
 				while (iter.hasNext())
 				{
 					Object fk = iter.next();
 					FieldDescriptor fkfd = null;
 					/*
                     OJB-55
                     it's possible that the FK field is declared in the super classes of this object,
                     so we can search for a valid field in super class-descriptor
                     */
                     ClassDescriptor tmp = cld;
                     while(tmp != null)
                     {
                         if (fk instanceof Integer)
                         {
                             Integer index = (Integer) fk;
                             fkfd = cld.getFieldDescriptorByIndex(index.intValue());
                         }
                         else
                         {
                             fkfd = tmp.getFieldDescriptorByName((String) fk);
                         }
                         if(fkfd != null)
                         {
                             break;
                         }
                         else
                         {
                             tmp = tmp.getSuperClassDescriptor();
                         }
                     }
 
                     if (fkfd == null)
 					{
                         throw new OJBRuntimeException("Incorrect or not found field reference name '"
                                 + fk + "' in descriptor " + this + " for class-descriptor '"
                                 + (cld != null ? cld.getClassNameOfObject() + "'" : "'null'"));
 					}
 					ret.add(fkfd);
 				}
 				foreignKeyFieldDescriptors = (FieldDescriptor[]) ret.toArray(new FieldDescriptor[ret.size()]);
 				fkFieldMap.put(cld, foreignKeyFieldDescriptors);
 			}
 		}
 		return foreignKeyFieldDescriptors;
 	}
 
     /**
      * Returns an Object array of all FK field values of the specified object.
      * If the specified object is an unmaterialized Proxy, it will be materialized
      * to read the FK values.
      *
      * @throws MetadataException if an error occours while accessing ForeingKey values on obj
      */
     public Object[] getForeignKeyValues(Object obj, ClassDescriptor mif)
             throws PersistenceBrokerException
     {
         FieldDescriptor[] fks = getForeignKeyFieldDescriptors(mif);
         // materialize object only if FK fields are declared
         if(fks.length > 0) obj = ProxyHelper.getRealObject(obj);
         Object[] result = new Object[fks.length];
         for (int i = 0; i < result.length; i++)
         {
             FieldDescriptor fmd = fks[i];
             PersistentField f = fmd.getPersistentField();
 
             // BRJ: do NOT convert.
             // conversion is done when binding the sql-statement
             //
             // FieldConversion fc = fmd.getFieldConversion();
             // Object val = fc.javaToSql(f.get(obj));
 
             result[i] = f.get(obj);
         }
         return result;
     }
 
     /**
      *
      */
     public Class getItemClass()
     {
         return m_ClassOfItems;
     }
 
     /**
      * @return the fully qualified name of the item class for this descriptor.
      */
     public String getItemClassName()
     {
         return this.m_ClassOfItems != null ? this.m_ClassOfItems.getName() : null;
     }
 
     /**
      * sets the item class
      * @param c the items class object
      */
     public void setItemClass(Class c)
     {
         m_ClassOfItems = c;
     }
 
     /**
      *
      */
     public Vector getForeignKeyFields()
     {
         return m_ForeignKeyFields;
     }
 
     /**
      *
      */
     public void setForeignKeyFields(Vector vec)
     {
         m_ForeignKeyFields = vec;
     }
 
     /**
      * add a foreign key field ID
      */
     public void addForeignKeyField(int newId)
     {
         if (m_ForeignKeyFields == null)
         {
             m_ForeignKeyFields = new Vector();
         }
         m_ForeignKeyFields.add(new Integer(newId));
     }
 
     /**
      * add a foreign key field
      */
     public void addForeignKeyField(String newField)
     {
         if (m_ForeignKeyFields == null)
         {
             m_ForeignKeyFields = new Vector();
         }
         m_ForeignKeyFields.add(newField);
     }
 
     /**
      * Gets the refresh.
      * @return Returns a boolean
      */
     public boolean isRefresh()
     {
         return refresh;
     }
 
     /**
      * Sets the refresh.
      * @param refresh The refresh to set
      */
     public void setRefresh(boolean refresh)
     {
         this.refresh = refresh;
     }
 
     /**
      * Gets the lazy.
      * @return Returns a boolean
      */
     public boolean isLazy()
     {
         return lazy;
     }
 
     /**
      * Sets the lazy.
      * @param lazy The lazy to set
      */
     public void setLazy(boolean lazy)
     {
         this.lazy = lazy;
     }
 
     /**
      *
      */
     public boolean getCascadeRetrieve()
     {
         return m_CascadeRetrieve;
     }
 
     /**
      *
      */
     public void setCascadeRetrieve(boolean b)
     {
         m_CascadeRetrieve = b;
     }
 
     /**
      *
      */
     public int getCascadingStore()
     {
         return m_CascadeStore;
     }
 
     /**
      *
      */
     public void setCascadingStore(int cascade)
     {
         m_CascadeStore = cascade;
     }
 
     public void setCascadingStore(String value)
     {
         setCascadingStore(getCascadeStoreValue(value));
     }
 
     /**
      * @deprecated use {@link #getCascadingStore} instead.
      */
     public boolean getCascadeStore()
     {
         return getCascadingStore() == CASCADE_OBJECT;
     }
 
     /**
      * @deprecated use {@link #setCascadingStore(int)} instead.
      */
     public void setCascadeStore(boolean cascade)
     {
         if(cascade)
         {
             setCascadingStore(getCascadeStoreValue("true"));
         }
         else
         {
             setCascadingStore(getCascadeStoreValue("false"));
         }
     }
 
     /**
      *
      */
     public int getCascadingDelete()
     {
         return m_CascadeDelete;
     }
 
     /**
      *
      */
     public void setCascadingDelete(int cascade)
     {
         m_CascadeDelete = cascade;
     }
 
     public void setCascadingDelete(String value)
     {
         setCascadingDelete(getCascadeDeleteValue(value));
     }
 
     /**
      * @deprecated use {@link #getCascadingDelete} instead.
      */
     public boolean getCascadeDelete()
     {
         return getCascadingDelete() == CASCADE_OBJECT;
     }
 
     /**
      * @deprecated use {@link #setCascadingDelete(int)}
      */
     public void setCascadeDelete(boolean cascade)
     {
         if(cascade)
         {
             setCascadingDelete(getCascadeDeleteValue("true"));
         }
         else
         {
             setCascadingDelete(getCascadeDeleteValue("false"));
         }
     }
 
     protected int getCascadeStoreValue(String cascade)
     {
         if(cascade.equalsIgnoreCase(RepositoryTags.CASCADE_NONE_STR))
         {
             return CASCADE_NONE;
         }
         else if(cascade.equalsIgnoreCase(RepositoryTags.CASCADE_LINK_STR))
         {
             return CASCADE_LINK;
         }
         else if(cascade.equalsIgnoreCase(RepositoryTags.CASCADE_OBJECT_STR))
         {
             return CASCADE_OBJECT;
         }
         else if(cascade.equalsIgnoreCase("true"))
         {
             return CASCADE_OBJECT;
         }
         else if(cascade.equalsIgnoreCase("false"))
         {
             /*
             in old implementation the FK values of an 1:1 relation are always
             set. Thus we choose 'link' instead of 'none'
             The CollectionDescriptor should override this behaviour.
             */
             return CASCADE_LINK;
         }
         else
         {
             throw new OJBRuntimeException("Invalid value! Given value was '" + cascade
                     + "', expected values are: " + RepositoryTags.CASCADE_NONE_STR + ", "
                     + RepositoryTags.CASCADE_LINK_STR + ", " + RepositoryTags.CASCADE_OBJECT_STR
                     + " ('false' and 'true' are deprecated but still valid)");
         }
     }
 
     protected int getCascadeDeleteValue(String cascade)
     {
         if(cascade.equalsIgnoreCase(RepositoryTags.CASCADE_NONE_STR))
         {
             return CASCADE_NONE;
         }
         else if(cascade.equalsIgnoreCase(RepositoryTags.CASCADE_LINK_STR))
         {
             return CASCADE_LINK;
         }
         else if(cascade.equalsIgnoreCase(RepositoryTags.CASCADE_OBJECT_STR))
         {
             return CASCADE_OBJECT;
         }
         else if(cascade.equalsIgnoreCase("true"))
         {
             return CASCADE_OBJECT;
         }
         else if(cascade.equalsIgnoreCase("false"))
         {
             return CASCADE_NONE;
         }
         else
         {
             throw new OJBRuntimeException("Invalid value! Given value was '" + cascade
                     + "', expected values are: " + RepositoryTags.CASCADE_NONE_STR + ", "
                     + RepositoryTags.CASCADE_LINK_STR + ", " + RepositoryTags.CASCADE_OBJECT_STR
                     + " ('false' and 'true' are deprecated but still valid)");
         }
     }
 
     public String getCascadeAsString(int cascade)
     {
         String result = null;
         switch(cascade)
         {
             case CASCADE_NONE:
                 result = RepositoryTags.CASCADE_NONE_STR;
                 break;
             case CASCADE_LINK:
                 result = RepositoryTags.CASCADE_LINK_STR;
                 break;
             case CASCADE_OBJECT:
                 result = RepositoryTags.CASCADE_OBJECT_STR;
                 break;
         }
         return result;
     }
 
     public int getProxyPrefetchingLimit()
     {
         return m_ProxyPrefetchingLimit;
     }
 
     public void setProxyPrefetchingLimit(int proxyPrefetchingLimit)
     {
         m_ProxyPrefetchingLimit = proxyPrefetchingLimit;
     }
 
     /**
      *
      */
     public boolean getOtmDependent()
     {
         return m_OtmDependent;
     }
 
     /**
      *
      */
     public void setOtmDependent(boolean b)
     {
         m_OtmDependent = b;
     }
 
     /**
      * Returns <code>true</code> if this descriptor was used to
      * describe a reference to a super class of an object.
      *
      * @return always <code>false</code> for this instance.
      */
     public boolean isSuperReferenceDescriptor()
     {
         return false;
     }
 
     /**
      * Returns <em>true</em> if a foreign key constraint to the referenced object is
      * declared, else <em>false</em> is returned.
      */
     public boolean hasConstraint()
     {
         /*
         arminw: Currently we don't have a ForeignKey descriptor object and
         a official xml-element to support FK settings. As a workaround I introduce
         a custom-attribute to handle FK settings in collection-/reference-decriptor
         */
         String result = getAttribute("constraint");
         return result != null && result.equalsIgnoreCase("true");
     }
 
     /**
      * Set a foreign key constraint flag for this reference - see {@link #hasConstraint()}
      * @param constraint If set <em>true</em>, signals a foreign key constraint in database. 
      */
     public void setConstraint(boolean constraint)
     {
         addAttribute("constraint", constraint ? "true" : "false");
     }
 
     public String toString()
     {
         return new ToStringBuilder(this)
                 .append("cascade_retrieve", getCascadeRetrieve())
                 .append("cascade_store", getCascadeAsString(m_CascadeStore))
                 .append("cascade_delete", getCascadeAsString(m_CascadeDelete))
                 .append("is_lazy", lazy)
                 .append("class_of_Items", m_ClassOfItems)
                 .toString();
     }
 
     /*
      * @see XmlCapable#toXML()
      */
     public String toXML()
     {
         RepositoryTags tags = RepositoryTags.getInstance();
         String eol = System.getProperty( "line.separator" );
 
         // opening tag
         StringBuffer result = new StringBuffer( 1024 );
         result.append( "      " );
         result.append( tags.getOpeningTagNonClosingById( REFERENCE_DESCRIPTOR ) );
         result.append( eol );
 
         // attributes
         // name
         String name = this.getAttributeName();
         if( name == null )
         {
             name = RepositoryElements.TAG_SUPER;
         }
         result.append( "        " );
         result.append( tags.getAttribute( FIELD_NAME, name ) );
         result.append( eol );
 
         // class-ref
         result.append( "        " );
         result.append( tags.getAttribute( REFERENCED_CLASS, this.getItemClassName() ) );
         result.append( eol );
 
         // proxyReference is optional
         if( isLazy() )
         {
             result.append( "        " );
             result.append( tags.getAttribute( PROXY_REFERENCE, "true" ) );
             result.append( eol );
             result.append( "        " );
             result.append( tags.getAttribute( PROXY_PREFETCHING_LIMIT, "" + this.getProxyPrefetchingLimit() ) );
             result.append( eol );
         }
 
         //reference refresh is optional, disabled by default
         if( isRefresh() )
         {
             result.append( "        " );
             result.append( tags.getAttribute( REFRESH, "true" ) );
             result.append( eol );
         }
 
         //auto retrieve
         result.append( "        " );
         result.append( tags.getAttribute( AUTO_RETRIEVE, "" + getCascadeRetrieve() ) );
         result.append( eol );
 
         //auto update
         result.append( "        " );
         result.append( tags.getAttribute( AUTO_UPDATE, getCascadeAsString( getCascadingStore() ) ) );
         result.append( eol );
 
         //auto delete
         result.append( "        " );
         result.append( tags.getAttribute( AUTO_DELETE, getCascadeAsString( getCascadingDelete() ) ) );
         result.append( eol );
 
         //otm-dependent is optional, disabled by default
         if( getOtmDependent() )
         {
             result.append( "        " );
             result.append( tags.getAttribute( OTM_DEPENDENT, "true" ) );
             result.append( eol );
         }
 
         // close opening tag
         result.append( "      >" );
         result.append( eol );
 
         // elements
         // write foreignkey elements
         for( int i = 0; i < getForeignKeyFields().size(); i++ )
         {
             Object obj = getForeignKeyFields().get( i );
             if( obj instanceof Integer )
             {
                 String fkId = obj.toString();
                 result.append( "        " );
                 result.append( tags.getOpeningTagNonClosingById( FOREIGN_KEY ) );
                 result.append( " " );
                 result.append( tags.getAttribute( FIELD_ID_REF, fkId ) );
                 result.append( "/>" );
                 result.append( eol );
             }
             else
             {
                 String fk = ( String ) obj;
                 result.append( "        " );
                 result.append( tags.getOpeningTagNonClosingById( FOREIGN_KEY ) );
                 result.append( " " );
                 result.append( tags.getAttribute( FIELD_REF, fk ) );
                 result.append( "/>" );
                 result.append( eol );
             }
         }
 
         // closing tag
         result.append( "      " );
         result.append( tags.getClosingTagById( REFERENCE_DESCRIPTOR ) );
         result.append( eol );
         return result.toString();
     }
 }