/*   Copyright 2004 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.
 */

package org.apache.xmlbeans.impl.binding.compile;

import org.apache.xmlbeans.impl.binding.bts.*;
import org.apache.xmlbeans.impl.binding.tylar.TylarWriter;
import org.apache.xmlbeans.impl.binding.tylar.TylarConstants;
import org.apache.xmlbeans.impl.binding.tylar.ExplodedTylarImpl;
import org.apache.xmlbeans.impl.jam.*;
import org.apache.xmlbeans.impl.common.XMLChar;
import org.apache.xmlbeans.SchemaTypeSystem;
import org.apache.xmlbeans.XmlException;
import org.w3.x2001.xmlSchema.*;
import javax.xml.namespace.QName;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
import java.util.Collection;
import java.util.Iterator;
import java.io.IOException;
import java.io.StringWriter;


/**
 * Takes a set of Java source inputs and generates a set of XML schemas to
 * which those input should be bound, as well as a binding configuration file
 * which describes to the runtime subsystem how the un/marshalling should
 * be performed.
 *
 * @author Patrick Calahan <pcal@bea.com>
 */
public class Java2Schema extends BindingCompiler {

  // =========================================================================
  // Constants

  private static final String JAVA_URI_SCHEME      = "java:";
  private static final String JAVA_NAMESPACE_URI   = "language_builtins";
  private static final String JAVA_PACKAGE_PREFIX  = "java.";

  public static final String TAG_CT               = "xsdgen:complexType";
  public static final String TAG_CT_EXCLUDE       = TAG_CT+".exclude";
  public static final String TAG_CT_TYPENAME      = TAG_CT+".typeName";
  public static final String TAG_CT_TARGETNS      = TAG_CT+".targetNamespace";
  public static final String TAG_CT_ROOT          = TAG_CT+".rootElement";
  public static final String TAG_CT_IGNORESUPER   = TAG_CT+".ignoreSuper";

  private static final String TAG_EL               = "xsdgen:element";

  public static final String TAG_EL_NAME          = TAG_EL+".name";
  public static final String TAG_EL_NILLABLE      = TAG_EL+".nillable";
  public static final String TAG_EL_EXCLUDE       = TAG_EL+".exclude";
  public static final String TAG_EL_ASTYPE        = TAG_EL+".astype";

  public static final String TAG_AT               = "xsdgen:attribute";
  public static final String TAG_AT_NAME          = TAG_AT+".name";

  public static final String TAG_ISSETTER         = "xsdgen:isSetMethodFor";

  // this is the character that replaces invalid characters when creating new
  // xml names.
  private static final char SAFE_CHAR = '_';

  // =========================================================================
  // Variables

  // the bindings that we're building up
  private BindingFile mBindingFile;

  // the full loader: bindingFile + baseLoader
  private BindingLoader mLoader;

  // maps a targetnamespace (string) to a schemadocument that we are creating
  private Map mTns2Schemadoc = new HashMap();

  // the input classes
  private JClass[] mClasses;

  // =========================================================================
  // Constructors

  public Java2Schema(JClass[] classesToBind) {
    if (classesToBind == null) {
      throw new IllegalArgumentException("null classes");
    }
    mClasses = classesToBind;
  }

  // ========================================================================
  // BindingCompiler implementation

  /**
   * Does the binding work on the inputs passed to the constructor and writes
   * out the tylar.
   */
  protected void internalBind(TylarWriter writer) {
    mBindingFile = new BindingFile();
    mLoader = CompositeBindingLoader.forPath
            (new BindingLoader[] {mBindingFile, super.getBaseBindingLoader()});
    //This does the binding
    for(int i=0; i<mClasses.length; i++) {
      if (!getAnnotation(mClasses[i],TAG_CT_EXCLUDE,false)) {
        getBindingTypeFor(mClasses[i]);
      }
    }
    //
    SchemaDocument[] xsds = null;
    try {
      writer.writeBindingFile(mBindingFile);
      //REVIEW maybe we should just include the schema and let super class write it out?
      xsds = getGeneratedSchemaDocuments();
      for(int i=0; i<xsds.length; i++) {
        writer.writeSchema(xsds[i],"schema-"+i+".xsd");
      }
    } catch(IOException ioe) {
      logError(ioe);
    }
    SchemaTypeSystem sts = null;
    {
      try {
        sts = Schema2JavaTask.createSchemaTypeSystem(xsds);
        if (sts == null) {
          throw new IllegalStateException("createSchemaTypeSystem returned null");
        }
      } catch(XmlException xe) {
        ExplodedTylarImpl.showXsbError(xe,null,"write",TylarConstants.SHOW_XSB_ERRORS);
      }
      if (sts != null) {
        try {
          writer.writeSchemaTypeSystem(sts);
        } catch(IOException ioe) {
          ExplodedTylarImpl.showXsbError(ioe,null,"compile",TylarConstants.SHOW_XSB_ERRORS);
        }
      }
    }
  }

  // ========================================================================
  // Private methods

  private SchemaDocument.Schema findOrCreateSchema(String tns) {
    if (tns == null) throw new IllegalArgumentException();
    tns = tns.trim();
    SchemaDocument doc = (SchemaDocument)mTns2Schemadoc.get(tns);
    if (doc == null) {
      doc = SchemaDocument.Factory.newInstance();
      doc.addNewSchema().setTargetNamespace(tns);
      mTns2Schemadoc.put(tns,doc);
    }
    return doc.getSchema();
  }

  private SchemaDocument[] getGeneratedSchemaDocuments() {
    Collection list = mTns2Schemadoc.values();
    SchemaDocument[] out = new SchemaDocument[list.size()];
    list.toArray(out);
    return out;
  }


  /**
   * Returns a bts BindingType for the given JClass.  If such a type
   * has not yet been registered with the loader, it will be created.
   *
   * @param clazz Java type for which to return a binding.
   */
  private BindingType getBindingTypeFor(JClass clazz) {
    BindingTypeName btn = mLoader.lookupTypeFor(getJavaName(clazz));
    if (btn != null) {
      BindingType out = mLoader.getBindingType(btn);
      if (out != null) return out;
    }
    return createBindingTypeFor(clazz);
  }

  /**
   * Creates a bts BindingType for the given JClass and registers t with the
   * loader.  Note that this method assumes that a BindingType does not
   * already exist for the given JClass.
   *
   * @param clazz Java type for which to generate a binding.
   */
  private BindingType createBindingTypeFor(JClass clazz) {
    // create the schema type
    SchemaDocument.Schema schema = findOrCreateSchema(getTargetNamespace(clazz));
    TopLevelComplexType xsType = schema.addNewComplexType();
    String tns = getTargetNamespace(clazz);
    String xsdName = getAnnotation(clazz,TAG_CT_TYPENAME,clazz.getSimpleName());
    QName qname = new QName(tns,xsdName);
    xsType.setName(xsdName);
    // deal with inheritance - see if it extends anything
    JClass superclass = clazz.getSuperclass();
    // we have to remember whether we created an ExtensionType because that
    // is where the sequence of properties have to go - note that this
    // gets passed into the SchemaPropertyFacade created below.  It's
    // unfortunate that the SchemaDocument model does not allow us to deal
    // with this kind of thing in a more elegant and polymorphic way.
    ExtensionType extType = null;
    BindingType superBindingType = null;
    if (superclass != null && !superclass.isObjectType() &&
      !getAnnotation(clazz,TAG_CT_IGNORESUPER,false)) {
      // FIXME we're ignoring interfaces at the moment
      superBindingType = getBindingTypeFor(superclass);
      ComplexContentDocument.ComplexContent ccd = xsType.addNewComplexContent();
      extType = ccd.addNewExtension();
      extType.setBase(superBindingType.getName().getXmlName().getQName());
    }
    // create a binding type
    BindingTypeName btname = BindingTypeName.forPair(getJavaName(clazz),
                                                     XmlTypeName.forTypeNamed(qname));
    ByNameBean bindType = new ByNameBean(btname);
    mBindingFile.addBindingType(bindType,true,true);
    if (clazz.isPrimitiveType()) {
      // it's good to have registerd the dummy type, but don't go further
      logError("Unexpected simple type",clazz);
      return bindType;
    }

    //add super's props first
    if (superBindingType != null) {
      //REVIEW: will it ever be possible to have another type as the super type?
      //REVIEW: is copy by ref safe here?
      //TODO: deal with java->schema name collisions across inherited types
      ByNameBean super_type = (ByNameBean)superBindingType;
      for(Iterator itr = super_type.getProperties().iterator() ; itr.hasNext() ; ) {
        final QNameProperty prop = (QNameProperty)itr.next();
        bindType.addProperty(prop);
      }
      bindType.setAnyAttributeProperty(super_type.getAnyAttributeProperty());
      bindType.setAnyElementProperty(super_type.getAnyElementProperty());
    }

    String rootName = getAnnotation(clazz,TAG_CT_ROOT,null);
    if (rootName != null) {
      QName rootQName = new QName(tns, rootName);
      BindingTypeName docBtName =
              BindingTypeName.forPair(getJavaName(clazz),
                                      XmlTypeName.forGlobalName(XmlTypeName.ELEMENT, rootQName));
      SimpleDocumentBinding sdb = new SimpleDocumentBinding(docBtName);
      sdb.setTypeOfElement(btname.getXmlName());
      mBindingFile.addBindingType(sdb,true,true);
    }
    // run through the class' properties to populate the binding and xsdtypes
    SchemaPropertyFacade facade = new SchemaPropertyFacade(xsType,extType,bindType,tns);
    Map props2issetters = new HashMap();
    getIsSetters(clazz,props2issetters);
    bindProperties(clazz.getDeclaredProperties(),props2issetters,facade);
    facade.finish();
    // check to see if they want to create a root elements from this type
    JAnnotation[] anns = getNamedTags(clazz.getAllJavadocTags(),TAG_CT_ROOT);
    for(int i=0; i<anns.length; i++) {
      TopLevelElement root = schema.addNewElement();
      root.setName(makeNcNameSafe(anns[i].getValue
                                  (JAnnotation.SINGLE_VALUE_NAME).asString()));
      root.setType(qname);
      // FIXME still not entirely clear to me what we should do about
      // the binding file here
    }
    return bindType;
  }

  private void getIsSetters(JClass clazz, Map outPropname2jmethod) {
    JMethod[] methods = clazz.getDeclaredMethods();
    for(int i=0; i<methods.length; i++) {
      JAnnotation ann = methods[i].getAnnotation(TAG_ISSETTER);
      if (ann != null) {
        if (!methods[i].getReturnType().getQualifiedName().equals("boolean")) {
          logWarning("Method "+methods[i].getQualifiedName()+" is marked "+
                     TAG_ISSETTER+"\nbut it does not return boolean."+
                     "Ignoring.");
          continue;
        }
        if (methods[i].getParameters().length > 0) {
          logWarning("Method "+methods[i].getQualifiedName()+" is marked "+
                     TAG_ISSETTER+"\nbut takes arguments.  Ignoring.");
          continue;
        }
        JAnnotationValue propNameVal = ann.getValue(JAnnotation.SINGLE_VALUE_NAME);
        if (propNameVal == null) {
          logWarning("Method "+methods[i].getQualifiedName()+" is marked "+
                     TAG_ISSETTER+"\nbut but no property name is given.  Ignoring");
          continue;
        }
        outPropname2jmethod.put(propNameVal.asString(),methods[i]);
      }
    }
  }

  /**
   * Runs through a set of JProperties to creates schema and bts elements
   * to represent those properties.  Note that the details of manipulating the
   * schema and bts are encapsulated within the supplied SchemaPropertyFacade;
   * this method is only responsible for inspecting the properties and their
   * annotations and setting the correct attributes on the facade.
   *
   * @param props Array of JProperty objects to potentially be bound.
   * @param facade Allows us to create and manipulate properties,
   * hides the dirty work
   */
  private void bindProperties(JProperty[] props,
                              Map props2issetters,
                              SchemaPropertyFacade facade) {
    for(int i=0; i<props.length; i++) {
      if (getAnnotation(props[i],TAG_EL_EXCLUDE,false)) {
        logVerbose("Marked excluded, skipping",props[i]);
        continue;
      }
      if (props[i].getGetter() == null || props[i].getSetter() == null) {
        logVerbose("Does not have both getter and setter, skipping",props[i]);
        continue; // REVIEW this might have to change someday
      }
      String propName;
      { // determine the property name to use and set it
        propName = getAnnotation(props[i], TAG_AT_NAME, null);
        if (propName != null) {
          facade.newAttributeProperty(props[i]);
        } else {
          facade.newElementProperty(props[i]);
          propName = getAnnotation(props[i], TAG_EL_NAME,
                                   props[i].getSimpleName());
        }
        assert propName != null;
        facade.setSchemaName(propName);
      }
      { // determine the property type to use and set it
        JClass propType = null;
        String annotatedType = getAnnotation(props[i],TAG_EL_ASTYPE,null);
        if (annotatedType == null) {
          facade.setType(propType = props[i].getType());
        } else {
          if (props[i].getType().isArrayType()) {
            //THIS IS A QUICK GROSS HACK THAT SHOULD BE REMOVED.
            //IF SOMEONE WANTS TO AS TYPE AN ARRAY PROPERTY, THEY NEED
            //TO ASTYPE IT TO THE ARRAY TYPE THEMSELVES
            annotatedType = "[L"+annotatedType+";";
          }
          propType = props[i].getType().forName(annotatedType);
          if (propType.isUnresolvedType()) {
            logError("Could not find class named '"+
                    propType.getQualifiedName()+"'",props[i]);
          } else {
            facade.setType(propType);
          }
        }
      }
      { // set the getters and setters
        facade.setGetter(props[i].getGetter());
        facade.setSetter(props[i].getSetter());
      }
      {
        JMethod issetter = (JMethod)props2issetters.get(propName);
        if (issetter != null) facade.setIssetter(issetter);
      }
      { // determine if the property is nillable
        JAnnotation a = props[i].getAnnotation(TAG_EL_NILLABLE);
        if (a != null) {
          // if the tag is there but empty, set it to true.  is that weird?
          JAnnotationValue val = a.getValue(JAnnotation.SINGLE_VALUE_NAME);
          if (val == null || val.asString().trim().length() == 0) {
            facade.setNillable(true);
          } else {
            facade.setNillable(val.asBoolean());
          }
        }
      }
    }
  }


  /**
   * Returns a JavaTypeName for the given JClass.  Might want to pool these.
   */
  private JavaTypeName getJavaName(JClass jc) {
    return JavaTypeName.forString(jc.getQualifiedName());
  }

  /**
   * Returns the string value of a named annotation, or the provided default
   * if the annotation is not present.
   * REVIEW seems like having this functionality in jam_old would be nice
   */
  private String getAnnotation(JAnnotatedElement elem,
                               String annName,
                               String dflt) {
    //System.out.print("checking for "+annName+" on "+elem.getQualifiedName());
    JAnnotation ann = getAnnotation(elem,annName);
    if (ann == null) {
      //System.out.println("...no annotation");
      return dflt;
    }
    JAnnotationValue val = ann.getValue(JAnnotation.SINGLE_VALUE_NAME);
    if (val == null) {
      //System.out.println("...no value!!!");
      return dflt;
    }
    //System.out.println("\n\n\n...value of "+annName+" is "+val.asString()+"!!!!!!!!!");
    return val.asString();
  }

  /**
   * Returns the boolean value of a named annotation, or the provided default
   * if the annotation is not present.
   * REVIEW seems like having this functionality in jam_old would be nice
   */
  private boolean getAnnotation(JAnnotatedElement elem,
                                String annName,
                                boolean dflt) {
    //System.out.print("checking for "+annName+" on "+elem.getQualifiedName());
    JAnnotation ann = getAnnotation(elem,annName);
    if (ann == null) {
      //System.out.println("...no annotation");
      return dflt;
    }
    JAnnotationValue val = ann.getValue(JAnnotation.SINGLE_VALUE_NAME);
    if (val == null || val.asString().length() == 0) {
      //System.out.println("\n\n\n...no value, returning true!!!");
      //this is a little bit gross.  the logic here is that if the tag is
      //present but empty, it actually is a true value.  E.g., an empty
      //@exclude tag means "yes, do exclude."
      return true;
    }
    //System.out.println("\n\n\n...value of "+annName+" is "+val.asBoolean()+"!!!!!!!!!");
    return val.asBoolean();
  }

  //FIXME this is temporary until we get the tags/175 sorted out
  private JAnnotation getAnnotation(JAnnotatedElement e,
                                    String named) {
    JAnnotation[] tags = e.getAllJavadocTags();
    for(int i=0; i<tags.length; i++) {
      if (tags[i].getSimpleName().equals(named)) return tags[i];
    }
    return null;
  }

  /**
   * Returns a QName for the type bound to the given JClass.
   */
  private QName getQnameFor(JClass clazz) {
    getBindingTypeFor(clazz);  //ensure that we've bound it
    JavaTypeName jtn = JavaTypeName.forString(clazz.getQualifiedName());
    BindingTypeName btn = mLoader.lookupTypeFor(jtn);
    logVerbose("BindingTypeName is "+btn,clazz);
    BindingType bt = mLoader.getBindingType(btn);
    if (bt != null) return bt.getName().getXmlName().getQName();
    logError("could not get qname",clazz);
    return new QName("ERROR",clazz.getQualifiedName());
  }

  /**
   * Returns a target namespace that should be used for the given class.
   * This takes annotations into consideration.
   */
  private String getTargetNamespace(JClass clazz) {
    String val = getAnnotation(clazz,TAG_CT_TARGETNS,null);
    if (val != null) return val;
    // Ok, they didn't specify it in the markup, so we have to
    // synthesize it from the classname.
    String pkg_name;
    if (clazz.isPrimitiveType()) {
      pkg_name = JAVA_NAMESPACE_URI;
    } else {
      JPackage pkg = clazz.getContainingPackage();
      pkg_name = (pkg == null) ? "" : pkg.getQualifiedName();
      if (pkg_name.startsWith(JAVA_PACKAGE_PREFIX)) {
        pkg_name = JAVA_NAMESPACE_URI+'.'+
                pkg_name.substring(JAVA_PACKAGE_PREFIX.length());
      }
    }
    return JAVA_URI_SCHEME + pkg_name;
  }


  /**
   * Checks the given XML name to ensure that it is a valid XMLName according
   * to the XML 1.0 Recommendation.  If it is not, the name is mangled so
   * as to make it a valid name.  This should be called before setting the
   * name on every schema fragment we create.
   */
  private static String makeNcNameSafe(String name) {
    // it's probably pretty rare that a name isn't valid, so let's just do
    // an optimistic check first without writing out a new string.
    if (name == null || XMLChar.isValidNCName(name) || name.length() == 0) {
      return name;
    }
    // ok, we have to mangle it
    StringWriter out = new StringWriter();
    char ch = name.charAt(0);
    if(!XMLChar.isNCNameStart(ch)) {
      out.write(SAFE_CHAR);
    } else {
      out.write(ch);
    }
    for (int i=1; i < name.length(); i++ ) {
      ch = name.charAt(i);
       if (!XMLChar.isNCName(ch)) {
         out.write(ch);
       }
    }
    return out.toString();
  }

  /*

  private static boolean isXmlObj(JClass clazz) {
    try {
      JClass xmlObj = clazz.forName("org.apache.xmlbeans.XmlObject");
      return xmlObj.isAssignableFrom(clazz);
    } catch(Exception e) {
      e.printStackTrace(); //FIXME
      return false;
    }
  }
  */


  /**
   * Inner class which encapsulates the creation of schema properties and
   * property bindings and presents them as a unified interface, a kind of
   * 'virtual property.'  This is used by the bindProperties() method, and
   * allows that function to concentrate on inspecting the java types and
   * annotations. This class hides all of the dirty work associated with
   * constructing and initializing a BTS property and either an XSD element
   * or attribute.
   *
   * Note that in some sense, this class behaves as both a factory and a kind
   * of cursor.  It is capable of creating a new virtual property
   * on a given BTS/XSD type pair, and any operations on the facade will
   * apply to that property until the next property is created
   * (via newAttributeProperty or newElementProperty).
   *
   * This class really wouldn't be necessary if the SchemaDocument model
   * were a bit more user-friendly.
   */
  class SchemaPropertyFacade {

    // =======================================================================
    // Variables

    private TopLevelComplexType mXsType;
    private ExtensionType mExtensionType = null;
    private String mXsTargetNamespace;
    private LocalElement mXsElement = null; // exactly one of these two is
    private Attribute mXsAttribute = null;  // remains null
    private Group mXsSequence = null;
    private List mXsAttributeList = null;
    private ByNameBean mBtsType;
    private QNameProperty mBtsProp = null;
    private JElement mSrcContext = null;

    // =======================================================================
    // Constructors

    public SchemaPropertyFacade(TopLevelComplexType xsType,
                                ExtensionType extType, //may be null
                                ByNameBean bt,
                                String tns) {
      if (xsType == null) throw new IllegalArgumentException("null xsType");
      if (bt == null) throw new IllegalArgumentException("null bt");
      if (tns == null) throw new IllegalArgumentException("null tns");
      mXsType = xsType;
      mExtensionType = extType;
      mBtsType = bt;
      mXsTargetNamespace = tns;
    }

    // =======================================================================
    // Public methods

    /**
     * Creates a new element property and sets this facade represent it.
     * Note that either this method or newAttributeProperty must be called prior
     * to doing any work with the facade.  Also note that you need to
     * completely finish working with each property before moving onto
     * the next via newElementProperty or newAttributeProperty.
     * *
     * @param srcContext A JAM element that represents the java source
     * artifact that is being bound to the property.  This is used
     * only for error reporting purposes.
     */
    public void newElementProperty(JElement srcContext) {
      newBtsProperty();
      mSrcContext = srcContext;
      if (mXsSequence == null) {
        // nest it inside the extension element if they specified one,
        // otherwise just do it in the complexType
        mXsSequence = (mExtensionType != null) ?
          mExtensionType.addNewSequence() : mXsType.addNewSequence();
      }
      mXsElement = mXsSequence.addNewElement();
      mXsAttribute = null;
    }

    /**
     * Creates a new attribute property and sets this facade represent it.
     * Note that either this method or newElementProperty must be called prior
     * to doing any work with the facade.  Also note that you need to
     * completely finish working with each property before moving onto
     * the next via newElementProperty or newAttributeProperty.
     *
     * @param srcContext A JAM element that represents the java source
     * artifact that is being bound to the property.  This is used
     * only for error reporting purposes.
     */
    public void newAttributeProperty(JElement srcContext) {
      newBtsProperty();
      mBtsProp.setAttribute(true);
      mSrcContext = srcContext;
      mXsElement = null;
      if (mXsAttributeList == null) mXsAttributeList = new ArrayList();
      mXsAttributeList.add(mXsAttribute = Attribute.Factory.newInstance());
    }

    /**
     * Sets the name of this property (element or attribute) in the
     * generated schema.
     */
    public void setSchemaName(String name) {
      name = makeNcNameSafe(name);
      if (mXsElement != null) {
        mXsElement.setName(name);
      } else if (mXsAttribute != null) {
        mXsAttribute.setName(name);
      } else {
        throw new IllegalStateException();
      }
      mBtsProp.setQName(new QName(mXsTargetNamespace,name));
    }

    /**
     * Sets the name of the java getter for this property.
     */
    public void setGetter(JMethod g) {
      mBtsProp.setGetterName(MethodName.create(g));
    }

    /**
     * Sets the name of the java setter for this property.
     */
    public void setSetter(JMethod s) {
      mBtsProp.setSetterName(MethodName.create(s));
    }

    /**
     * Sets the name of the java setter for this property.
     */
    public void setIssetter(JMethod s) {
      mBtsProp.setIssetterName(MethodName.create(s));
    }

    /**
     * Sets the type of the property.  Currently handles arrays
     * correctly but not collections.
     */
    public void setType(JClass propType) {
      if (mXsElement != null) {
        if (propType.isArrayType()) {
          if (propType.getArrayDimensions() != 1) {
            logError("Multidimensional arrays NYI",mSrcContext); //FIXME
          }
          JClass componentType = propType.getArrayComponentType();
          mXsElement.setMaxOccurs("unbounded");
          mXsElement.setType(getQnameFor(componentType));
          mBtsProp.setMultiple(true);
          mBtsProp.setCollectionClass //FIXME
                  (JavaTypeName.forString(componentType.getQualifiedName()+"[]"));
          mBtsProp.setBindingType(getBindingTypeFor(componentType));
        } else {
          mXsElement.setType(getQnameFor(propType));
          mBtsProp.setBindingType(getBindingTypeFor(propType));
        }
      } else if (mXsAttribute != null) {
        if (propType.isArrayType()) {
          logError("Array properties cannot be mapped to xml attributes",
                  mSrcContext);
        } else {
          mXsAttribute.setType(getQnameFor(propType));
          mBtsProp.setBindingType(getBindingTypeFor(propType));
        }
      } else {
        throw new IllegalStateException();
      }
    }

    /**
     * Sets whether the property should be bound as nillable.
     */
    public void setNillable(boolean b) {
      if (mXsElement != null) {
        mXsElement.setNillable(b);
        mBtsProp.setNillable(b);
      } else if (mXsAttribute != null) {
        logError("Attributes cannot be nillable:",mSrcContext);
      } else {
        throw new IllegalStateException();
      }
    }

    /**
     * This method should always be called when finished building up
     * a type.  It is a hack around an xbeans bug in which the sequences and
     * attributes are output in the order in which they were added (the
     * schema for schemas says the attributes always have to go last).
     */
    public void finish() {
      addBtsProperty();
      if (mXsAttributeList != null) {
        Attribute[] array = new Attribute[mXsAttributeList.size()];
        mXsAttributeList.toArray(array);
        mXsType.setAttributeArray(array);
      }
    }

    // =======================================================================
    // Private methods

    /**
     * Adds the current bts property to the bts type.  This has to be called
     * for every property.  We do this last because ByNameBean won't
     * let us add more than one prop for same name (name is always blank
     * initially).
     */
    private void addBtsProperty() {
      if (mBtsProp != null && !mBtsType.hasProperty(mBtsProp))
          mBtsType.addProperty(mBtsProp);
    }

    /**
     * Initialize a new QName property in the bts type
     */
    private void newBtsProperty() {
      if (mBtsProp != null) addBtsProperty(); //if not 1st one, add old one
      mBtsProp = new QNameProperty();
    }
  }


  //this is temporary, will go away when we have our 175 story straight
  private static JAnnotation[] getNamedTags(JAnnotation[] tags,
                                            String named)
  {
    if (tags == null || tags.length == 0) return new JAnnotation[0];
    List list = new ArrayList();
    for(int i=0; i<tags.length; i++) {
      if (tags[i].getSimpleName().equals(named)) list.add(tags[i]);
    }
    JAnnotation[] out = new JAnnotation[list.size()];
    list.toArray(out);
    return out;
  }


}