/**
    * Redistribution and use of this software and associated documentation
    * ("Software"), with or without modification, are permitted provided
    * that the following conditions are met:
    *
    * 1. Redistributions of source code must retain copyright
    *    statements and notices.  Redistributions must also contain a
    *    copy of this document.
    *
   * 2. Redistributions in binary form must reproduce the
   *    above copyright notice, this list of conditions and the
   *    following disclaimer in the documentation and/or other
   *    materials provided with the distribution.
   *
   * 3. The name "Exolab" must not be used to endorse or promote
   *    products derived from this Software without prior written
   *    permission of Intalio, Inc.  For written permission,
   *    please contact info@exolab.org.
   *
   * 4. Products derived from this Software may not be called "Exolab"
   *    nor may "Exolab" appear in their names without prior written
   *    permission of Intalio, Inc. Exolab is a registered
   *    trademark of Intalio, Inc.
   *
   * 5. Due credit should be given to the Exolab Project
   *    (http://www.exolab.org/).
   *
   * THIS SOFTWARE IS PROVIDED BY INTALIO, INC. AND CONTRIBUTORS
   * ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
   * NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
   * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
   * INTALIO, INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
   * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
   * OF THE POSSIBILITY OF SUCH DAMAGE.
   *
   * Copyright 1999-2003 (C) Intalio, Inc. All Rights Reserved.
   *
   * $Id$
   */
  package org.exolab.castor.builder.descriptors;
  
  import org.exolab.castor.builder.BuilderConfiguration;
  import org.exolab.castor.builder.SGTypes;
  import org.exolab.castor.xml.XMLConstants;
  import org.exolab.javasource.JAnnotation;
  import org.exolab.javasource.JAnnotationType;
  import org.exolab.javasource.JClass;
  import org.exolab.javasource.JConstructor;
  import org.exolab.javasource.JField;
  import org.exolab.javasource.JMethod;
  import org.exolab.javasource.JPrimitiveType;
  import org.exolab.javasource.JSourceCode;
  import org.exolab.javasource.JType;
  
  /**
   * A class which defines the necessary methods for generating ClassDescriptor
   * source files.
   *
   * @author <a href="mailto:kvisco@intalio.com">Keith Visco</a>
   * @version $Revision$ $Date: 2006-03-10 15:42:54 -0700 (Fri, 10 Mar 2006) $
   */
  public final class DescriptorJClass extends JClass {
  
      /** Class Descriptors extend this base class. */
      private static final String XMLCLASS_DESCRIPTOR_IMPL =
          "org.exolab.castor.xml.util.XMLClassDescriptorImpl";
  
      private static final String MAPPING_ACCESS_MODE = "org.exolab.castor.mapping.AccessMode";
  
      /** Field descriptors implement this interface from org.exolab.castor.mapping. */
      private static final JClass FIELD_DESCRIPTOR_CLASS;
  
      /** Field descriptors implement this interface from org.exolab.castor.xml. */
      private static final JClass XML_FIELD_DESCRIPTOR_CLASS;
      /** Type validators implement this interface from org.exolab.castor.xml. */
      private static final JType  TYPE_VALIDATOR_CLASS;
  
      static {
          FIELD_DESCRIPTOR_CLASS     = new JClass("org.exolab.castor.mapping.FieldDescriptor");
          XML_FIELD_DESCRIPTOR_CLASS = new JClass("org.exolab.castor.xml.XMLFieldDescriptor");
          TYPE_VALIDATOR_CLASS       = new JClass("org.exolab.castor.xml.TypeValidator");
      }
  
      /** The type being described by the Descriptor class we'll generate. */
      private final JClass               _type;
      /** Source Builder configuration. */
      private final BuilderConfiguration _config;
  
      /**
       * Constructs a DescriptorJClass.
       * @param config Builder Configuration
       * @param className name of this descriptor class
       * @param type the type that is described by this descriptor
       */
     public DescriptorJClass(final BuilderConfiguration config, final String className,
                             final JClass type) {
         super(className);
         this._config = config;
         this._type   = type;
         init();
     } //-- DescriptorJClass
 
     //-------------------/
     //- Private Methods -/
     //-------------------/
 
     /**
      * Initializes this DescriptorJClass with the required methods.
      */
     private void init() {
         // Make sure that the Descriptor is extended XMLClassDescriptor even when
         // the user has specified a super class for all the generated classes
         String superClass = null;
         if (_config != null) {
             superClass = _config.getProperty(BuilderConfiguration.Property.SUPER_CLASS, null);
         }
 
         boolean extended = false;
 
         if (_type.getSuperClassQualifiedName() == null
             || _type.getSuperClassQualifiedName().equals(superClass)) {
             setSuperClass(XMLCLASS_DESCRIPTOR_IMPL);
         } else {
             if (_type.getSuperClass() == null) {
                 setSuperClass(null);
             } else {
                 extended = true;
                 setSuperClass(getSuperClassName());
             }
         }
         superClass = null;
 
         if (_type.getPackageName() != null && _type.getPackageName().length() > 0) {
             addImport(_type.getName());
         }
 
         addField(new JField(JType.BOOLEAN, "_elementDefinition"));
 
         addField(new JField(SGTypes.STRING, "_nsPrefix"));
         addField(new JField(SGTypes.STRING, "_nsURI"));
         addField(new JField(SGTypes.STRING, "_xmlName"));
         //-- if there is a super class, the identity field must remain
         //-- the same than the one in the super class
         addField(new JField(XML_FIELD_DESCRIPTOR_CLASS, "_identity"));
 
         //-- create default constructor
         addDefaultConstructor(extended);
 
         //jsc.add("Class[] emptyClassArgs = new Class[0];");
         //jsc.add("Class[] classArgs = new Class[1];");
 
         //---------------------------------------------/
         //- Methods Defined by XMLClassDescriptorImpl -/
         //---------------------------------------------/
 
         addXMLClassDescriptorImplOverrides();
 
         //-----------------------------------------/
         //- Methods Defined by XMLClassDescriptor -/
         //-----------------------------------------/
 
         addXMLClassDescriptorOverrides();
 
         //--------------------------------------/
         //- Methods defined by ClassDescriptor -/
         //--------------------------------------/
 
         addClassDescriptorOverrides(extended);
     } //-- createSource
 
     /**
      * Returns the qualified class name of the super class, adjusted to add the
      * 'descriptors' sub-package.
      * @return Returns the qualified class name of the super class
      */
     private String getSuperClassName() {
         final String superClassName;
         if (_type.getSuperClass().getPackageName() == null
                 || _type.getSuperClass().getPackageName().equals("")) {
             if (getPackageName() == null) {
                 // no target package specified --> do not append package (=null)
                 superClassName = _type.getSuperClass().getLocalName()
                         + XMLConstants.DESCRIPTOR_SUFFIX;
             } else {
                 // target package specified --> simply use it
                 superClassName = getPackageName() + "." + _type.getSuperClass().getLocalName()
                         + XMLConstants.DESCRIPTOR_SUFFIX;
             }
         } else {
             superClassName = _type.getSuperClass().getPackageName()
                     + "." + XMLConstants.DESCRIPTOR_PACKAGE + "."
                     + _type.getSuperClass().getLocalName() +  XMLConstants.DESCRIPTOR_SUFFIX;
         }
         return superClassName;
     }
 
     /**
      * Adds our default constructor.
      * @param extended true if we extend another class and thus need to call super()
      */
     private void addDefaultConstructor(final boolean extended) {
         addConstructor(createConstructor());
         JConstructor cons = getConstructor(0);
         JSourceCode jsc = cons.getSourceCode();
         jsc.add("super();");
 
         if (extended) {
             //-- add base class (for validation)
             jsc.add("setExtendsWithoutFlatten(");
             jsc.append("new ");
             jsc.append(getSuperClassQualifiedName());
             jsc.append("());");
         }
     }
 
     /**
      * Adds the methods we override from.
      * {@link org.exolab.castor.xml.util.XMLClassDescriptorImpl}
      */
     private void addXMLClassDescriptorImplOverrides() {
         //-- create isElementDefinition method
         JMethod getElementDefinition = new JMethod("isElementDefinition", JType.BOOLEAN,
                                "true if XML schema definition of this Class is that of a global\n"
                                + "element or element with anonymous type definition.");
         JSourceCode jsc = getElementDefinition.getSourceCode();
         jsc.add("return _elementDefinition;");
         addMethod(getElementDefinition);
     }
 
     /**
      * Adds the methods we override from.
      * {@link org.exolab.castor.xml.XMLClassDescriptor}
      */
     private void addXMLClassDescriptorOverrides() {
         JMethod method;
         JSourceCode jsc;
         //-- create getNameSpacePrefix method
         method = new JMethod("getNameSpacePrefix", SGTypes.STRING,
                              "the namespace prefix to use when marshaling as XML.");
 
         if (_config.useJava50()) {
             method.addAnnotation(new JAnnotation(new JAnnotationType("Override")));
         }
 
         jsc = method.getSourceCode();
         jsc.add("return _nsPrefix;");
         addMethod(method);
 
         //-- create getNameSpaceURI method
         method = new JMethod("getNameSpaceURI", SGTypes.STRING,
                              "the namespace URI used when marshaling and unmarshaling as XML.");
 
         if (_config.useJava50()) {
             method.addAnnotation(new JAnnotation(new JAnnotationType("Override")));
         }
 
         jsc = method.getSourceCode();
         jsc.add("return _nsURI;");
         addMethod(method);
 
         //-- create getValidator method
         method = new JMethod("getValidator", TYPE_VALIDATOR_CLASS,
                              "a specific validator for the class described"
                              + " by this ClassDescriptor.");
 
         if (_config.useJava50()) {
             method.addAnnotation(new JAnnotation(new JAnnotationType("Override")));
         }
 
         jsc = method.getSourceCode();
         jsc.add("return this;");
         addMethod(method);
 
         //-- create getXMLName method
         method = new JMethod("getXMLName", SGTypes.STRING,
                              "the XML Name for the Class being described.");
 
         if (_config.useJava50()) {
             method.addAnnotation(new JAnnotation(new JAnnotationType("Override")));
         }
 
         jsc = method.getSourceCode();
         jsc.add("return _xmlName;");
         addMethod(method);
     }
 
     /**
      * Adds the methods we override from.
      * {@link org.exolab.castor.mapping.ClassDescriptor}
      * @param extended true if we extend another class and thus need to call super()
      */
     private void addClassDescriptorOverrides(final boolean extended) {
         JSourceCode jsc;
 
         //-- create getAccessMode method
         JClass amClass = new JClass(MAPPING_ACCESS_MODE);
         JMethod getAccessMode = new JMethod("getAccessMode", amClass,
                                      "the access mode specified for this class.");
 
         if (_config.useJava50()) {
             getAccessMode.addAnnotation(new JAnnotation(new JAnnotationType("Override")));
         }
 
         jsc = getAccessMode.getSourceCode();
         jsc.add("return null;");
         addMethod(getAccessMode);
 
         //-- create getIdentity method
         JMethod getIdentity = new JMethod("getIdentity", FIELD_DESCRIPTOR_CLASS,
                                    "the identity field, null if this class has no identity.");
 
         if (_config.useJava50()) {
             getIdentity.addAnnotation(new JAnnotation(new JAnnotationType("Override")));
         }
 
         jsc = getIdentity.getSourceCode();
         if (extended) {
             jsc.add("if (_identity == null) {");
             jsc.indent();
             jsc.add("return super.getIdentity();");
             jsc.unindent();
             jsc.add("}");
         }
         jsc.add("return _identity;");
 
         //--don't add the type to the import list
         addMethod(getIdentity, false);
 
         //-- create getJavaClass method
         JMethod getJavaClass = new JMethod("getJavaClass", SGTypes.CLASS,
                                     "the Java class represented by this descriptor.");
 
         if (_config.useJava50()) {
             getJavaClass.addAnnotation(new JAnnotation(new JAnnotationType("Override")));
         }
 
         jsc = getJavaClass.getSourceCode();
         jsc.add("return ");
         jsc.append(classType(_type));
         jsc.append(";");
 
         //--don't add the type to the import list
         addMethod(getJavaClass, false);
     }
 
     /**
      * Returns the Class type (as a String) for the given XSType.
      *
      * @param jType
      *            the JType we are to return the class name of
      * @return the Class name (as a String) for the given XSType
      */
     private static String classType(final JType jType) {
         if (jType.isPrimitive()) {
             JPrimitiveType primitive = (JPrimitiveType) jType;
             return primitive.getWrapperName() + ".TYPE";
         }
         return jType.toString() + ".class";
     } //-- classType
 
 } //-- DescriptorJClass