/*
* The Apache Software License, Version 1.1
*
*
* Copyright (c) 2003 The Apache Software Foundation.  All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
*
* 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 end-user documentation included with the redistribution,
*    if any, must include the following acknowledgment:
*       "This product includes software developed by the
*        Apache Software Foundation (http://www.apache.org/)."
*    Alternately, this acknowledgment may appear in the software itself,
*    if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Apache" and "Apache Software Foundation" must
*    not be used to endorse or promote products derived from this
*    software without prior written permission. For written
*    permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache
*    XMLBeans", nor may "Apache" appear in their name, without prior
*    written permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``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 THE APACHE SOFTWARE FOUNDATION 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.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation and was
* originally based on software copyright (c) 2003 BEA Systems
* Inc., <http://www.bea.com/>. For more information on the Apache Software
* Foundation, please see <http://www.apache.org/>.
*/

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

import org.apache.xmlbeans.impl.binding.bts.BindingFile;
import org.apache.xmlbeans.impl.binding.bts.BindingType;
import org.apache.xmlbeans.impl.binding.bts.BindingLoader;
import org.apache.xmlbeans.impl.binding.bts.XmlName;
import org.apache.xmlbeans.impl.binding.bts.JavaName;
import org.apache.xmlbeans.impl.binding.bts.ByNameBean;
import org.apache.xmlbeans.impl.binding.bts.QNameProperty;
import org.apache.xmlbeans.impl.binding.bts.SimpleBindingType;
import org.apache.xmlbeans.impl.binding.bts.BindingTypeName;
import org.apache.xmlbeans.impl.binding.compile.BindingFileGenerator;
import org.apache.xmlbeans.impl.binding.compile.JavaCodeGenerator;
import org.apache.xmlbeans.impl.binding.compile.JavaCodePrinter;
import org.apache.xmlbeans.impl.common.NameUtil;
import org.apache.xmlbeans.SchemaType;
import org.apache.xmlbeans.SchemaTypeSystem;
import org.apache.xmlbeans.SchemaProperty;
import org.apache.xmlbeans.SchemaLocalAttribute;
import org.apache.xmlbeans.XmlObject;
import org.apache.xmlbeans.XmlOptions;
import org.apache.xmlbeans.soap.SOAPArrayType;
import org.apache.xmlbeans.soap.SchemaWSDLArrayType;

import javax.xml.namespace.QName;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Map;
import java.util.LinkedHashMap;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
import java.util.HashMap;
import java.util.Collections;
import java.util.AbstractCollection;
import java.util.List;
import java.math.BigInteger;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.io.IOException;

/**
 * This is the "JAXRPC-style" Schema-to-bts compiler.
 */ 
public class JAXRPCSchemaBinder implements JavaCodeGenerator, BindingFileGenerator, SchemaToJavaResult
{
    private Set usedNames = new HashSet();
    private SchemaTypeSystem sts;
    private Map scratchFromXmlName = new LinkedHashMap();
    private Map scratchFromSchemaType = new HashMap(); // for convenience
    private Map scratchFromJavaNameString = new HashMap(); // for printing
    private BindingLoader path;
    private int structureCount;
    private BindingFile bindingFile = new BindingFile();

    private JAXRPCSchemaBinder(SchemaTypeSystem sts, BindingLoader path)
    {
        this.sts = sts;
        this.path = path;
    }
    
    /**
     * Generates a binding for the given set of schema types.
     * 
     * Defer to any previously defined bindings on the BindingLoader path
     * supplied.
     */
    public static SchemaToJavaResult bind(SchemaTypeSystem sts, BindingLoader path)
    {
        JAXRPCSchemaBinder binder = new JAXRPCSchemaBinder(sts, path);
        binder.bind();
        return binder;
    }
    
    /**
     * Computes the binding.
     */ 
    private void bind()
    {
        // Every type or global element or global attribute is dropped into
        // one of a number of categories.  (See Scratch constants.)
        //
        // Based on the category, a java class is either defined or found
        // that maches with the schema type.
        //
        // The phases work as follows:
        //
        // 1. categorize and allocate Scratches
        // 2. write or find java names for each xml type
        // 3. allocate binding types for each scratch (done in the same pass as 2)
        // 4. fill in the java getter/setter structure of any complex types
        
        
        // 1. categorize and allocate Scratches
        createScratchArea();
        
        // 2. write or find java names for each xml type
        // 3. allocate binding types for each scratch (done in the same pass as 2)
        for (Iterator i = scratchIterator(); i.hasNext(); )
        {
            Scratch scratch = (Scratch)i.next(); 
            resolveJavaName(scratch);
            createBindingType(scratch);
        }
        
        // 4. fill in the java getter/setter structure of any complex types
        for (Iterator i = scratchIterator(); i.hasNext(); )
        {
            resolveJavaStructure((Scratch)i.next());
        }
    }

    /**
     * This function goes through all relevant schema types, plus soap
     * array types, and creates a scratch area for each.  Each
     * scratch area is also marked at this time with an XmlName,
     * a schema type, and a category.
     */ 
    private void createScratchArea()
    {
        for (Iterator i = allTypeIterator(); i.hasNext(); )
        {
            SchemaType sType = (SchemaType)i.next();
            XmlName xmlName = XmlName.forSchemaType(sType);
            Scratch scratch;
            
            if (sType.isSimpleType())
            {
                // simple types are atomic
                // todo: what about simple content, custom codecs, etc?
                scratch = new Scratch(sType, xmlName, Scratch.ATOMIC_TYPE);
            }
            else if (sType.isDocumentType())
            {
                scratch = new Scratch(sType, XmlName.forGlobalName(XmlName.ELEMENT, sType.getDocumentElementName()), Scratch.ELEMENT);
            }
            else if (sType.isAttributeType())
            {
                scratch = new Scratch(sType, XmlName.forGlobalName(XmlName.ATTRIBUTE, sType.getDocumentElementName()), Scratch.ATTRIBUTE);
            }
            else if (isSoapArray(sType))
            {
                scratch = new Scratch(sType, xmlName, Scratch.SOAPARRAY_REF);
                xmlName = soapArrayTypeName(sType);
                scratch.setAsIf(xmlName);
                
                // soap arrays unroll like this
                while (xmlName.getComponentType() == XmlName.SOAP_ARRAY)
                {
                    scratch = new Scratch(null, xmlName, Scratch.SOAPARRAY);
                    scratchFromXmlName.put(xmlName, scratch);
                    xmlName = xmlName.getOuterComponent();
                }
            }
            else if (isLiteralArray(sType))
            {
                scratch = new Scratch(sType, xmlName, Scratch.LITERALARRAY_TYPE);
            }
            else
            {
                scratch = new Scratch(sType, xmlName, Scratch.STRUCT_TYPE);
            }
            
            scratchFromXmlName.put(xmlName, scratch);
            scratchFromSchemaType.put(sType, scratch);
            
        }
    }
    
    /**
     * Computes a JavaName for each scratch.  Notice that structures and
     * atoms can be computed directly, but arrays, elements, etc, need
     * to defer to other scratch areas, so this is a resolution
     * process that occurs in dependency order.
     */ 
    private void resolveJavaName(Scratch scratch)
    {
        // already resolved (we recurse to do in dependency order)
        if (scratch.getJavaName() != null)
            return;
        
        switch (scratch.getCategory())
        {
            case Scratch.ATOMIC_TYPE:
                {
                    resolveSimpleScratch(scratch);
                    return;
                }
                
            case Scratch.STRUCT_TYPE:
                {
                    structureCount += 1;
                    JavaName javaName = pickUniqueJavaName(scratch.getSchemaType());
                    scratch.setJavaName(javaName);
                    scratchFromJavaNameString.put(javaName.toString(), scratch);
                    return;
                }
                
            case Scratch.LITERALARRAY_TYPE:
                {
                    SchemaType itemType = getLiteralArrayItemType(scratch.getSchemaType());
                    Scratch itemScratch = scratchForSchemaType(itemType);
                    resolveJavaName(itemScratch);
                    scratch.setJavaName(JavaName.forArray(itemScratch.getJavaName(), 1));
                    return;
                }
                
            case Scratch.SOAPARRAY_REF:
                {
                    XmlName soapArrayName = scratch.getAsIf();
                    Scratch arrayScratch = scratchForXmlName(soapArrayName);
                    resolveJavaName(arrayScratch);
                    scratch.setJavaName(arrayScratch.getJavaName());
                    scratch.setAsIf(arrayScratch.getXmlName());
                    return;
                }
                
            case Scratch.SOAPARRAY:
                {
                    XmlName arrayName = scratch.getXmlName();
                    XmlName itemName = arrayName.getOuterComponent();
                    Scratch itemScratch = scratchForXmlName(itemName);
                    resolveJavaName(itemScratch);
                    scratch.setJavaName(JavaName.forArray(itemScratch.getJavaName(), arrayName.getNumber()));
                    return;
                }
                
            case Scratch.ELEMENT:
            case Scratch.ATTRIBUTE:
                {
                    SchemaType contentType = scratch.getSchemaType().getProperties()[0].getType();
                    Scratch contentScratch = scratchForSchemaType(contentType);
                    resolveJavaName(contentScratch);
                    scratch.setJavaName(contentScratch.getJavaName());
                    scratch.setAsIf(contentScratch.getXmlName());
                    return;
                }
                
            default:
                throw new IllegalStateException("Unrecognized category");
        }
    }

    /**
     * Computes a BindingType for a scratch.
     */ 
    private void createBindingType(Scratch scratch)
    {
        assert(scratch.getBindingType() == null);
        
        BindingTypeName btName = BindingTypeName.forPair(scratch.getJavaName(), scratch.getXmlName());
        
        switch (scratch.getCategory())
        {
            case Scratch.ATOMIC_TYPE:
            case Scratch.ELEMENT:
            case Scratch.SOAPARRAY_REF:
            case Scratch.ATTRIBUTE:
                SimpleBindingType simpleResult = new SimpleBindingType(btName);
                simpleResult.setAsIfXmlType(scratch.getAsIf());
                scratch.setBindingType(simpleResult);
                bindingFile.addBindingType(simpleResult, shouldBeFromJavaDefault(btName), true);
                break;
                
            case Scratch.STRUCT_TYPE:
                ByNameBean byNameResult = new ByNameBean(btName);
                scratch.setBindingType(byNameResult);
                bindingFile.addBindingType(byNameResult, true, true);
                break;
                
            case Scratch.LITERALARRAY_TYPE:
                throw new UnsupportedOperationException();
                
            case Scratch.SOAPARRAY:
                throw new UnsupportedOperationException();
                
            default:
                throw new IllegalStateException("Unrecognized category");
        }
    }
    
    /**
     * Returns true if the given btName would be the first (unique)
     * default java->xml binding to be entered in the java-to-type or
     * java-to-element tables.
     */ 
    private boolean shouldBeFromJavaDefault(BindingTypeName btName)
    {
        JavaName jName = btName.getJavaName();
        XmlName xName = btName.getXmlName();
        if (xName.isSchemaType())
        {
            return (bindingFile.lookupTypeFor(jName) == null &&
                    path.lookupTypeFor(jName) == null);
        }
        if (xName.getComponentType() == XmlName.ELEMENT)
        {
            return (bindingFile.lookupElementFor(jName) == null &&
                    path.lookupElementFor(jName) == null);
        }
        return false;
    }

    /**
     * Now we resolve the structural aspects (property names) for each
     * scratch.
     * 
     * todo: understand how we want inheritance to work
     */ 
    private void resolveJavaStructure(Scratch scratch)
    {
        if (scratch.getCategory() != Scratch.STRUCT_TYPE)
            return;
        
        if (scratch.isStructureResolved())
            return;
        
        scratch.setStructureResolved(true);
        
        SchemaType baseType = scratch.getSchemaType().getBaseType();
        Collection baseProperties = null;
        if (baseType != null)
            baseProperties = extractProperties(baseType);
        if (baseProperties == null)
            baseProperties = Collections.EMPTY_LIST;
        
        // sort properties based on QName attr/elt
        Map seenAttrProps = new HashMap();
        Map seenEltProps = new HashMap();
        Set seenMethodNames = new HashSet();
        seenMethodNames.add("getClass");
        
        for (Iterator i = baseProperties.iterator(); i.hasNext(); )
        {
            QNameProperty prop = (QNameProperty)i.next();
            if (prop.isAttribute())
                seenAttrProps.put(prop.getQName(), prop);
            else
                seenEltProps.put(prop.getQName(), prop);
            
            // todo: probably this collision avoidance should be using Java introspection instead
            if (prop.getGetterName() != null)
                seenMethodNames.add(prop.getGetterName());
            if (prop.getSetterName() != null)
                seenMethodNames.add(prop.getSetterName());
        }
        
        // now deal with remaining props
        SchemaProperty[] props = scratch.getSchemaType().getProperties();
        for (int i = 0; i < props.length; i++)
        {
            QNameProperty prop = (QNameProperty)(props[i].isAttribute() ? seenAttrProps : seenEltProps).get(props[i].getName());
            if (prop != null)
            {
                // already seen property: verify multiplicity looks cool
                if (prop.isMultiple() != isMultiple(props[i]))
                {
                    // todo: signal nicer error
                    throw new IllegalStateException("Can't change multiplicity");
                }
                
                // todo: think about optionality and nillability too
            }
            else
            {
                SchemaType sType = props[i].getType();
                BindingType bType = bindingTypeForSchemaType(sType);
                
                String propName = pickUniquePropertyName(props[i].getName(), seenMethodNames);
                String getter = "get" + propName;
                String setter = "set" + propName;
                boolean isMultiple = isMultiple(props[i]);
                JavaName collection = null;
                if (isMultiple)
                    collection = JavaName.forArray(bType.getName().getJavaName(), 1);
                
                prop = new QNameProperty();
                prop.setQName(props[i].getName());
                prop.setAttribute(props[i].isAttribute());
                prop.setSetterName(setter);
                prop.setGetterName(getter);
                prop.setCollectionClass(collection);
                prop.setBindingType(bType);
                prop.setNillable(props[i].hasNillable() != SchemaProperty.NEVER);
                prop.setOptional(isOptional(props[i]));
                prop.setMultiple(isMultiple);
            }
            scratch.addQNameProperty(prop);
        }
    }
    
    /**
     * Picks a property name without colliding with names of
     * previously picked getters and setters.
     */ 
    private String pickUniquePropertyName(QName name, Set seenMethodNames)
    {
        String baseName = NameUtil.upperCamelCase(name.getLocalPart());
        String propName = baseName;
        for (int i = 1; ; i += 1)
        {
            String getter = "get" + propName;
            String setter = "set" + propName;
            
            if (!seenMethodNames.contains(getter) &&
                    !seenMethodNames.contains(setter))
            {
                seenMethodNames.add(getter);
                seenMethodNames.add(setter);
                return propName;
            }
            propName = baseName + i;
        }
    }

    /**
     * True if the given SchemaProperty has maxOccurs > 1
     */ 
    private static boolean isMultiple(SchemaProperty prop)
    {
        return (prop.getMaxOccurs() == null || prop.getMaxOccurs().compareTo(BigInteger.ONE) > 0);
    }
    
    /**
     * True if the given SchemaProperty has minOccurs < 1
     */ 
    private static boolean isOptional(SchemaProperty prop)
    {
        return (prop.getMinOccurs().signum() == 0);
    }
    
    /**
     * Returns a collection of QNameProperties for a given schema type that
     * may either be on the path or the current scratch area.
     */ 
    private Collection extractProperties(SchemaType sType)
    {
        // case 1: it's in the current area
        Scratch scratch = scratchForSchemaType(sType);
        if (scratch != null)
        {
            resolveJavaStructure(scratch);
            return scratch.getQNameProperties();
        }
        
        // case 2: it's in the path
        BindingType bType = path.getBindingType(path.lookupPojoFor(XmlName.forSchemaType(sType)));
        if (!(bType instanceof ByNameBean))
        {
            return null;
        }
        Collection result = new ArrayList();
        ByNameBean bnb = (ByNameBean)bType;
        for (Iterator i = bnb.getProperties().iterator(); i.hasNext(); )
        {
            result.add(i.next());
        }
        
        return result;
    }
    
    /**
     * True for a schema type that is a SOAP array.
     */ 
    private static boolean isSoapArray(SchemaType sType)
    {
        // SOAP Array definition must be put on the compiletime classpath
        while (sType != null)
        {
            String signature = XmlName.forSchemaType(sType).toString();
            
            // captures both SOAP 1.1 and SOAP 1.2+
            if (signature.equals("t=Array@http://schemas.xmlsoap.org/soap/encoding/") ||
                    signature.startsWith("t=Array@http://www.w3.org/")
                    && signature.endsWith("/soap-encoding"))
                return true;
            sType = sType.getBaseType();
        }
        return false;
    }
    
    private static final QName arrayType = new QName("http://schemas.xmlsoap.org/soap/encoding/", "arrayType");
    
    /**
     * Returns an XmlName describing a SOAP array.
     */ 
    private static XmlName soapArrayTypeName(SchemaType sType)
    {
        // first, look for wsdl:arrayType default - this will help us with multidimensional arrays
        SOAPArrayType defaultArrayType = null;
        SchemaLocalAttribute attr = sType.getAttributeModel().getAttribute(arrayType);
        if (attr != null)
            defaultArrayType = ((SchemaWSDLArrayType)attr).getWSDLArrayType();
        
        // method 1: trust wsdl:arrayType
        if (defaultArrayType != null)
            return XmlName.forSoapArrayType(defaultArrayType);
        
        // method 2: SOAP 1.2 equivalent?
        // todo: track what do WSDLs do in the world of SOAP 1.2.
        
        // method 3: look at the type of a unique element.
        SchemaType itemType = XmlObject.type;
        SchemaProperty[] props = sType.getElementProperties();
        if (props.length == 1)
            itemType = props[0].getType();
        
        return XmlName.forNestedNumber(XmlName.SOAP_ARRAY, 1, XmlName.forSchemaType(itemType));
    }
    
    /**
     * Climbs the structure of a schema type to find the namespace within
     * which it was defined.
     */ 
    private String findContainingNamespace(SchemaType sType)
    {
        for (;;)
        {
            if (sType.isDocumentType())
                return sType.getDocumentElementName().getNamespaceURI();
            else if (sType.isAttributeType())
                return sType.getAttributeTypeAttributeName().getNamespaceURI();
            else if (sType.getName() != null)
                return sType.getName().getNamespaceURI();
            sType = sType.getOuterType();
        }
    }

    /**
     * Picks a unique fully-qualified Java class name for the given schema
     * type.  Uses and updates the "usedNames" set.
     */ 
    private JavaName pickUniqueJavaName(SchemaType sType)
    {
        QName qname = null;
        while (qname == null)
        {
            if (sType.isDocumentType())
                qname = sType.getDocumentElementName();
            else if (sType.isAttributeType())
                qname = sType.getAttributeTypeAttributeName();
            else if (sType.getName() != null)
                qname = sType.getName();
            else if (sType.getContainerField() != null)
            {
                qname = sType.getContainerField().getName();
                if (qname.getNamespaceURI().length() == 0)
                    qname = new QName(findContainingNamespace(sType), qname.getLocalPart());
            }
            sType = sType.getOuterType();
        }
        
        String baseName = NameUtil.getClassNameFromQName(qname);
        String pickedName = baseName;
        
        for (int i = 1; usedNames.contains(pickedName); i += 1)
            pickedName = baseName + i;
        
        usedNames.add(pickedName);
        
        return JavaName.forString(pickedName);
    }

    /**
     * Resolves an atomic scratch all at once, including its
     * JavaName and basedOn fields.
     * 
     * This resolution method sets up a scratch so that is
     * is "based on" another binding type.  It finds the
     * underlying binding type by climing the base type
     * chain, and grabbing the first hit.
     */ 
    private void resolveSimpleScratch(Scratch scratch)
    {
        assert(scratch.getCategory() == Scratch.ATOMIC_TYPE);
                
        if (scratch.getJavaName() != null)
            return;
        
        SchemaType baseType = scratch.getSchemaType().getBaseType();
        while (baseType != null)
        {
            // find a base type within this type system
            Scratch basedOnScratch = scratchForSchemaType(baseType);
            if (basedOnScratch != null)
            {
                if (basedOnScratch.getCategory() != Scratch.ATOMIC_TYPE)
                    throw new IllegalStateException("Atomic types should only inherit from atomic types");
                resolveSimpleScratch(basedOnScratch);
                scratch.setJavaName(basedOnScratch.getJavaName());
                scratch.setAsIf(basedOnScratch.getXmlName());
                return;
            }
            
            // or if not within this type system, find the base type on the path
            XmlName treatAs = XmlName.forSchemaType(baseType);
            BindingType basedOnBinding = path.getBindingType(path.lookupPojoFor(treatAs));
            if (basedOnBinding != null)
            {
                scratch.setJavaName(basedOnBinding.getName().getJavaName());
                scratch.setAsIf(treatAs);
                return;
            }
            
            // or go to the next base type up
            baseType = baseType.getBaseType();
        }
        
        // builtin at least should give us xs:anyType
        throw new IllegalStateException("Builtin binding type loader is not on path.");
    }
    
    /**
     * Looks on both the path and in the current scratch area for
     * the binding type corresponding to the given schema type.  Must
     * be called after all the binding types have been created.
     */ 
    private BindingType bindingTypeForSchemaType(SchemaType sType)
    {
        Scratch scratch = scratchForSchemaType(sType);
        if (scratch != null)
            return scratch.getBindingType();
        return path.getBindingType(path.lookupPojoFor(XmlName.forSchemaType(sType)));
    }

    /**
     * Returns the scratch area for a given schema type.  Notice that
     * SOAP arrays have an XmlName but not a schema type.
     */ 
    private Scratch scratchForSchemaType(SchemaType sType)
    {
        return (Scratch)scratchFromSchemaType.get(sType);
    }
    
    /**
     * Returns the scratch area for a given XmlName.
     */ 
    private Scratch scratchForXmlName(XmlName xmlName)
    {
        return (Scratch)scratchFromXmlName.get(xmlName);
    }

    /**
     * Returns the scratch area for a given JavaName.  Notice that only
     * structures generate a java class, so not non-strucuture scratch areas
     * cannot be referenced this way.
     */ 
    private Scratch scratchForJavaNameString(String javaName)
    {
        return (Scratch)scratchFromJavaNameString.get(javaName);
    }
    
    /**
     * Extracts the schema type for the array items for a literal array.
     */ 
    private static SchemaType getLiteralArrayItemType(SchemaType sType)
    {
        // consider: must the type be named "ArrayOf..."?
        
        if (sType.isSimpleType() || sType.getContentType() == SchemaType.SIMPLE_CONTENT)
            return null;
        SchemaProperty[] prop = sType.getProperties();
        if (prop.length != 1 || prop[0].isAttribute())
            return null;
        BigInteger max = prop[0].getMaxOccurs();
        if (max != null && max.compareTo(BigInteger.ONE) <= 0)
            return null;
        return prop[0].getType();
    }

    /**
     * True if the given schema type is interpreted as a .NET-style
     * array.
     */ 
    private static boolean isLiteralArray(SchemaType sType)
    {
        return getLiteralArrayItemType(sType) != null;
    }
    
    /**
     * Scratch area corresponding to a schema type, used for the binding
     * computation.
     */ 
    private static class Scratch
    {
        Scratch(SchemaType schemaType, XmlName xmlName, int category)
        {
            this.schemaType = schemaType;
            this.xmlName = xmlName;
            this.category = category;
        }
        
        private BindingType bindingType;
        private SchemaType schemaType; // may be null
        private JavaName javaName;
        private XmlName xmlName;

        private int category;

        // atomic types get a treatAs
        private XmlName asIf;
        private boolean isStructureResolved;

        // categories of Scratch, established at ctor time
        public static final int ATOMIC_TYPE = 1;
        public static final int STRUCT_TYPE = 2;
        public static final int LITERALARRAY_TYPE = 3;
        public static final int SOAPARRAY_REF = 4;
        public static final int SOAPARRAY = 5;
        public static final int ELEMENT = 6;
        public static final int ATTRIBUTE = 7;

        public int getCategory()
        {
            return category;
        }

        public JavaName getJavaName()
        {
            return javaName;
        }

        public void setJavaName(JavaName javaName)
        {
            this.javaName = javaName;
        }

        public BindingType getBindingType()
        {
            return bindingType;
        }

        public void setBindingType(BindingType bindingType)
        {
            this.bindingType = bindingType;
        }

        public SchemaType getSchemaType()
        {
            return schemaType;
        }

        public XmlName getXmlName()
        {
            return xmlName;
        }

        public void setXmlName(XmlName xmlName)
        {
            this.xmlName = xmlName;
        }

        public XmlName getAsIf()
        {
            return asIf;
        }

        public void setAsIf(XmlName xmlName)
        {
            this.asIf = xmlName;
        }
        
        public void addQNameProperty(QNameProperty prop)
        {
            if (!(bindingType instanceof ByNameBean))
                throw new IllegalStateException();
            ((ByNameBean)bindingType).addProperty(prop);
        }
        
        public Collection getQNameProperties()
        {
            if (!(bindingType instanceof ByNameBean))
                throw new IllegalStateException();
            return ((ByNameBean)bindingType).getProperties();
        }

        public boolean isStructureResolved()
        {
            return this.isStructureResolved;
        }
        
        public void setStructureResolved(boolean isStructureResolved)
        {
            this.isStructureResolved = isStructureResolved;
        }
    }
    
    /**
     * Returns an iterator for all the Scratch's
     */ 
    private Iterator scratchIterator()
    {
        return scratchFromXmlName.values().iterator();
    }
    
    /**
     * Returns an iterator for all the schema types
     */ 
    private Iterator allTypeIterator()
    {
        class AllTypeIterator implements Iterator
        {
            int index;
            List allSeenTypes;
            
            AllTypeIterator(SchemaTypeSystem sts)
            {
                allSeenTypes = new ArrayList();
                allSeenTypes.addAll(Arrays.asList(sts.documentTypes()));
                allSeenTypes.addAll(Arrays.asList(sts.attributeTypes()));
                allSeenTypes.addAll(Arrays.asList(sts.globalTypes()));
                index = 0;
            }
            
            public boolean hasNext()
            {
                return index < allSeenTypes.size();
            }

            public Object next()
            {
                SchemaType next = (SchemaType)allSeenTypes.get(index);
                allSeenTypes.addAll(Arrays.asList(next.getAnonymousTypes()));
                index += 1;
                return next;
            }

            public void remove()
            {
                throw new UnsupportedOperationException();
            }
        }
        
        return new AllTypeIterator(sts);
    }
    
    /**
     * Iterates over all the top-level Java class names generated
     * by this binding.  Used by getToplevelClasses.
     */ 
    private class TopLevelClassNameIterator implements Iterator
    {
        private final Iterator si = scratchIterator();
        private Scratch next = nextStructure();
        
        public boolean hasNext()
        {
            return next != null;
        }

        public Object next()
        {
            // todo: need to strip off x= from xmlobject name
            String result = next.getJavaName().toString();
            next = nextStructure();
            return result;
        }

        private Scratch nextStructure()
        {
            while (si.hasNext())
            {
                Scratch scratch = (Scratch)si.next();
                if (scratch.getCategory() == Scratch.STRUCT_TYPE)
                    return scratch;
            }
            return null;
        }

        public void remove()
        {
            throw new UnsupportedOperationException();
        }
    }


    /**
     * Returns a collection of fully-qualified Java class name strings
     * generated by this binding.
     */
    public Collection getToplevelClasses()
    {
        return new AbstractCollection()
        {
            public Iterator iterator()
            {
                return new TopLevelClassNameIterator();
            }
    
            public int size()
            {
                return structureCount;
            }
        };
    }

    /**
     * Prints the Java source code for the given generated java class name.
     */
    public void printSourceCode(String topLevelClassName, OutputStream output) throws IOException
    {
        Scratch scratch = scratchForJavaNameString(topLevelClassName);
        if (scratch == null)
            throw new IllegalArgumentException();
        Writer writer = new OutputStreamWriter(output);
        ScratchCodePrinter printer = new ScratchCodePrinter(scratch, writer);
        printer.print();
        writer.flush();
    }
    
    /**
     * Handles the printing for one generated java class.
     */
    private class ScratchCodePrinter extends JavaCodePrinter
    {
        private Scratch scratch;

        ScratchCodePrinter(Scratch scratch, Writer writer)
        {
            super(writer);
            assert(scratch.getCategory() == Scratch.STRUCT_TYPE);
            this.scratch = scratch;
        }
        
        private void print() throws IOException
        {
            JavaName javaName = scratch.getJavaName();
            
            String packageName = javaName.getPackage();
            String shortClassName = javaName.getShortClassName();
            BindingType baseType = bindingTypeForSchemaType(scratch.getSchemaType().getBaseType());
            String baseJavaname = null;
            if (baseType != null)
            {
                baseJavaname = baseType.getName().getJavaName().toString();
                if (baseJavaname.equals("java.lang.Object"))
                    baseJavaname = null;
            }
            
            line("package " + packageName);
            line();
            javadoc("Generated from schema type " + scratch.getXmlName());
            line("class " + shortClassName + (baseJavaname != null ? " extends " + baseJavaname : ""));
            startBlock();
            
            Collection props = scratch.getQNameProperties();
            Map fieldNames = new HashMap();
            Set seenFieldNames = new HashSet();
            
            // pick field names
            for (Iterator i = props.iterator(); i.hasNext(); )
            {
                QNameProperty prop = (QNameProperty)i.next();
                fieldNames.put(prop, pickUniqueFieldName(prop.getGetterName(), seenFieldNames));
            }
            
            // print private fields
            for (Iterator i = props.iterator(); i.hasNext(); )
            {
                QNameProperty prop = (QNameProperty)i.next();
                JavaName jType = prop.getTypeName().getJavaName();
                if (prop.getCollectionClass() != null)
                    jType = prop.getCollectionClass();
                
                line("private " + jType.toString() + " " + fieldNames.get(prop) + ";");
            }
            
            // print getters and setters
            for (Iterator i = props.iterator(); i.hasNext(); )
            {
                QNameProperty prop = (QNameProperty)i.next();
                JavaName jType = prop.getTypeName().getJavaName();
                if (prop.getCollectionClass() != null)
                    jType = prop.getCollectionClass();
                String fieldName = (String)fieldNames.get(prop);
                
                line();
                line("public " + jType.toString() + " " + prop.getGetterName() + "()");
                startBlock();
                line("return " + fieldName + ";");
                endBlock();
                line();
                line("public void " + prop.getSetterName() + "(" + jType.toString() + " " + fieldName + ")");
                startBlock();
                line("this." + fieldName + " = " + fieldName + ";");
                endBlock();
            }
            
            endBlock();
        }
        
        private String pickUniqueFieldName(String getter, Set seenNames)
        {
            String baseName;
            
            if (getter.length() > 3 && getter.startsWith("get"))
                baseName = Character.toLowerCase(getter.charAt(3)) + getter.substring(4);
            else
                baseName = "field";
            
            String fieldName = baseName;
            for (int i = 1; seenNames.contains(fieldName); i += 1)
                fieldName = baseName + i;
            
            seenNames.add(fieldName);
            return fieldName;
        }
    }

    /**
     * Prints the binding file generated by this binding.
     */ 
    public void printBindingFile(OutputStream output) throws IOException
    {
        bindingFile.write().save(output, new XmlOptions().setSavePrettyPrint());
    }

    /**
     * Returns a BindingFileGenerator for this SchemaToJavaResult.
     */ 
    public BindingFileGenerator getBindingFileGenerator()
    {
        return this;
    }

    /**
     * Returns the JavaCodeGenerator for this SchemaToJavaResult.
     */ 
    public JavaCodeGenerator getJavaCodeGenerator()
    {
        return this;
    }
}