/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package com.sun.tools.internal.xjc.reader.dtd;

import java.io.IOException;

import java.util.Collections;

import java.util.HashMap;

import java.util.Map;

import java.util.Stack;

import javax.xml.namespace.QName;

import com.sun.codemodel.internal.JClass;

import com.sun.codemodel.internal.JCodeModel;

import com.sun.codemodel.internal.JDefinedClass;

import com.sun.codemodel.internal.JPackage;

import com.sun.tools.internal.xjc.AbortException;

import com.sun.tools.internal.xjc.ErrorReceiver;

import com.sun.tools.internal.xjc.Options;

import com.sun.tools.internal.xjc.model.CAttributePropertyInfo;

import com.sun.tools.internal.xjc.model.CBuiltinLeafInfo;

import com.sun.tools.internal.xjc.model.CClassInfo;

import com.sun.tools.internal.xjc.model.CPropertyInfo;

import com.sun.tools.internal.xjc.model.Model;

import com.sun.tools.internal.xjc.model.TypeUse;

import com.sun.tools.internal.xjc.model.TypeUseFactory;

import com.sun.tools.internal.xjc.model.CDefaultValue;

import com.sun.tools.internal.xjc.reader.ModelChecker;

import com.sun.tools.internal.xjc.reader.Ring;

import com.sun.tools.internal.xjc.reader.dtd.bindinfo.BIAttribute;

import com.sun.tools.internal.xjc.reader.dtd.bindinfo.BIElement;

import com.sun.tools.internal.xjc.reader.dtd.bindinfo.BIInterface;

import com.sun.tools.internal.xjc.reader.dtd.bindinfo.BindInfo;

import com.sun.tools.internal.xjc.util.CodeModelClassFactory;

import com.sun.tools.internal.xjc.util.ErrorReceiverFilter;

import com.sun.xml.internal.bind.api.impl.NameConverter;

import com.sun.xml.internal.dtdparser.DTDHandlerBase;

import com.sun.xml.internal.dtdparser.DTDParser;

import com.sun.xml.internal.dtdparser.InputEntity;

import com.sun.xml.internal.xsom.XmlString;

import com.sun.istack.internal.SAXParseException2;

import org.xml.sax.EntityResolver;

import org.xml.sax.InputSource;

import org.xml.sax.Locator;

import org.xml.sax.SAXException;

import org.xml.sax.SAXParseException;

import org.xml.sax.helpers.LocatorImpl;

/**

 * Parses DTD grammar along with binding information into BGM.

 *

 * @author

 *    <a href="mailto:kohsuke.kawaguchi@sun.com">Kohsuke KAWAGUCHI</a>

 */

public class TDTDReader extends DTDHandlerBase

{

    /**

     * Parses DTD grammar and a binding information into BGM.

     *

     * <p>

     * This method is just a utility method that covers 80% of the use

     * cases.

     *

     * @param    bindingInfo

     *        binding information file, if any. Can be null.

     */

    public static Model parse(

        InputSource dtd,

        InputSource bindingInfo,

        ErrorReceiver errorReceiver,

        Options opts) {

        try {

            // set up a ring

            final Ring old = Ring.begin();

            try {

                ErrorReceiverFilter ef = new ErrorReceiverFilter(errorReceiver);

                JCodeModel cm = new JCodeModel();

                Model model = new Model(opts,cm,NameConverter.standard,opts.classNameAllocator,null);

                Ring.add(cm);

                Ring.add(model);

                Ring.add(ErrorReceiver.class,ef);

                TDTDReader reader = new TDTDReader( ef, opts, bindingInfo);

                DTDParser parser = new DTDParser();

                parser.setDtdHandler(reader);

                if( opts.entityResolver!=null )

                    parser.setEntityResolver(opts.entityResolver);

                try {

                    parser.parse(dtd);

                } catch (SAXParseException e) {

                    return null; // this error was already handled by GrammarReaderController

                }

                Ring.get(ModelChecker.class).check();

                if(ef.hadError())   return null;

                else                return model;

            } finally {

                Ring.end(old);

            }

        } catch (IOException e) {

            errorReceiver.error(new SAXParseException2(e.getMessage(),null,e));

            return null;

        } catch (SAXException e) {

            errorReceiver.error(new SAXParseException2(e.getMessage(),null,e));

            return null;

        } catch (AbortException e) {

            // parsing was aborted but the error was already reported

            return null;

        }

    }

    protected TDTDReader(ErrorReceiver errorReceiver, Options opts, InputSource _bindInfo)

        throws AbortException {

        this.entityResolver = opts.entityResolver;

        this.errorReceiver = new ErrorReceiverFilter(errorReceiver);

        bindInfo = new BindInfo(model,_bindInfo, this.errorReceiver);

        classFactory = new CodeModelClassFactory(errorReceiver);

    }

    private final EntityResolver entityResolver;

    /**

     * binding information.

     *

     * <p>

     * This is always non-null even if no binding information was specified.

     * (In that case, a dummy object will be provided.)

     */

    final BindInfo bindInfo;

    final Model model = Ring.get(Model.class);

    private final CodeModelClassFactory classFactory;

    private final ErrorReceiverFilter errorReceiver;

    /**

     * Element name to its content model definition.

     */

    private final Map<String,Element> elements = new HashMap<String,Element>();

    public void startDTD(InputEntity entity) throws SAXException {

    }

    public void endDTD() throws SAXException {

        // bind them all.

        // we need to know how elements are referencing each other before we do this,

        // so this can be only done at the endDTD method

        for( Element e : elements.values() )

            e.bind();

        // if there was an error by now, just abort.

        if (errorReceiver.hadError())

            return;

        processInterfaceDeclarations();

        // check XJC extensions and realize them

        model.serialVersionUID = bindInfo.getSerialVersionUID();

        if(model.serialVersionUID!=null)

            model.serializable=true;

        model.rootClass = bindInfo.getSuperClass();

        model.rootInterface = bindInfo.getSuperInterface();

// TODO: do we need to reimplement them?

//        // performs annotation

//        Annotator.annotate(model, this);

//        FieldCollisionChecker.check( model, this );

        processConstructorDeclarations();

    }

    /** Processes interface declarations. */

    private void processInterfaceDeclarations() {

        Map<String,InterfaceAcceptor> fromName = new HashMap<String,InterfaceAcceptor>();

        // first, create empty InterfaceItem declaration for all interfaces

        Map<BIInterface,JClass> decls = new HashMap<BIInterface,JClass>();

        for( BIInterface decl : bindInfo.interfaces() ) {

            final JDefinedClass intf = classFactory.createInterface(

                                bindInfo.getTargetPackage(), decl.name(), copyLocator() );

            decls.put(decl,intf);

            fromName.put(decl.name(),new InterfaceAcceptor() {

                public void implement(JClass c) {

                    intf._implements(c);

                }

            });

        }

        for( final CClassInfo ci : model.beans().values() ) {

            fromName.put(ci.getName(),new InterfaceAcceptor() {

                public void implement(JClass c) {

                    ci._implements(c);

                }

            });

        }

        // traverse the interface declarations again

        // and populate its expression according to the members attribute.

        for( Map.Entry<BIInterface,JClass> e : decls.entrySet() ) {

            BIInterface decl = e.getKey();

            JClass c = e.getValue();

            for (String member : decl.members()) {

                InterfaceAcceptor acc = fromName.get(member);

                if (acc == null) {

                    // there is no such class/interface

                    // TODO: error location

                    error(decl.getSourceLocation(),

                            Messages.ERR_BINDINFO_NON_EXISTENT_INTERFACE_MEMBER,

                            member);

                    continue;

                }

                acc.implement(c);

            }

        }

        // TODO: check the cyclic interface definition

    }

    private static interface InterfaceAcceptor {

        void implement( JClass c );

    }

    JPackage getTargetPackage() {

        return bindInfo.getTargetPackage();

    }

    /**

     * Creates constructor declarations as specified in the

     * binding information.

     *

     * <p>

     * Also checks that the binding file does not contain

     * declarations for non-existent elements.

     */

    private void processConstructorDeclarations() {

        for( BIElement decl: bindInfo.elements() ) {

            Element e = elements.get(decl.name());

            if(e==null) {

                error(decl.getSourceLocation(),

                    Messages.ERR_BINDINFO_NON_EXISTENT_ELEMENT_DECLARATION,decl.name());

                continue;   // continue to process next declaration

            }

            if(!decl.isClass())

                // only element-class declaration has constructor definitions

                continue;

            decl.declareConstructors(e.getClassInfo());

        }

    }

    public void attributeDecl(String elementName, String attributeName, String attributeType, String[] enumeration, short attributeUse, String defaultValue) throws SAXException {

        getOrCreateElement(elementName).attributes.add(

            createAttribute(elementName, attributeName, attributeType, enumeration, attributeUse, defaultValue)

        );

    }

    protected CPropertyInfo createAttribute(

        String elementName, String attributeName, String attributeType,

        String[] enums, short attributeUse, String defaultValue )

            throws SAXException {

        boolean required = attributeUse==USE_REQUIRED;

        // get the attribute-property declaration

        BIElement edecl = bindInfo.element(elementName);

        BIAttribute decl=null;

        if(edecl!=null)     decl=edecl.attribute(attributeName);

        String propName;

        if(decl==null)  propName = model.getNameConverter().toPropertyName(attributeName);

        else            propName = decl.getPropertyName();

        QName qname = new QName("",attributeName);

        // if no declaration is specified, just wrap it by

        // a FieldItem and let the normalizer handle its content.

        TypeUse use;

        if(decl!=null && decl.getConversion()!=null)

            use = decl.getConversion().getTransducer();

        else

            use = builtinConversions.get(attributeType);

        CPropertyInfo r = new CAttributePropertyInfo(

            propName, null,null/*TODO*/, copyLocator(), qname, use, null, required );

        if(defaultValue!=null)

            r.defaultValue = CDefaultValue.create( use, new XmlString(defaultValue) );

        return r;

    }

    Element getOrCreateElement( String elementName ) {

        Element r = elements.get(elementName);

        if(r==null) {

            r = new Element(this,elementName);

            elements.put(elementName,r);

        }

        return r;

    }

    public void startContentModel(String elementName, short contentModelType) throws SAXException {

        assert modelGroups.isEmpty();

        modelGroups.push(new ModelGroup());

    }

    public void endContentModel(String elementName, short contentModelType) throws SAXException {

        assert modelGroups.size()==1;

        Term term = modelGroups.pop().wrapUp();

        Element e = getOrCreateElement(elementName);

        e.define( contentModelType, term, copyLocator() );

    }

    private final Stack<ModelGroup> modelGroups = new Stack<ModelGroup>();

    public void startModelGroup() throws SAXException {

        modelGroups.push(new ModelGroup());

    }

    public void endModelGroup(short occurence) throws SAXException {

        Term t = Occurence.wrap( modelGroups.pop().wrapUp(), occurence );

        modelGroups.peek().addTerm(t);

    }

    public void connector(short connectorType) throws SAXException {

        modelGroups.peek().setKind(connectorType);

    }

    // TODO: for now, we just ignore all the content model specification

    // and treat it as (A,B,C,....)

    public void childElement(String elementName, short occurence) throws SAXException {

        Element child = getOrCreateElement(elementName);

        modelGroups.peek().addTerm( Occurence.wrap( child, occurence ) );

        child.isReferenced = true;

    }

    /**

     * Mutable {@link Locator} instance that points to

     * the current source line.

     * <p>

     * Use {@link #copyLocator()} to get a immutable clone.

     */

    private Locator locator;

    public void setDocumentLocator(Locator loc) {

        this.locator = loc;

    }

    /**

     * Creates a snapshot of the current {@link #locator} values.

     */

    private Locator copyLocator(){

        return new LocatorImpl(locator);

    }

//

//

// builtin datatype handling

//

//

    /** Transducers for the built-in types. Read-only. */

    private static final Map<String,TypeUse> builtinConversions;

    static {

        // list of datatypes which have built-in conversions.

        // note that although xs:token and xs:normalizedString are not

        // specified in the spec, they need to be here because they

        // have different whitespace normalization semantics.

        Map<String,TypeUse> m = new HashMap<String,TypeUse>();

        m.put("CDATA",      CBuiltinLeafInfo.NORMALIZED_STRING);

        m.put("ENTITY",     CBuiltinLeafInfo.TOKEN);

        m.put("ENTITIES",   CBuiltinLeafInfo.STRING.makeCollection());

        m.put("NMTOKEN",    CBuiltinLeafInfo.TOKEN);

        m.put("NMTOKENS",   CBuiltinLeafInfo.STRING.makeCollection());

        m.put("ID",         CBuiltinLeafInfo.ID);

        m.put("IDREF",      CBuiltinLeafInfo.IDREF);

        m.put("IDREFS",     TypeUseFactory.makeCollection(CBuiltinLeafInfo.IDREF));

        m.put("ENUMERATION",CBuiltinLeafInfo.TOKEN);

        builtinConversions = Collections.unmodifiableMap(m);

    }

//

//

// error related utility methods

//

//

    public void error(SAXParseException e) throws SAXException {

        errorReceiver.error(e);

    }

    public void fatalError(SAXParseException e) throws SAXException {

        errorReceiver.fatalError(e);

    }

    public void warning(SAXParseException e) throws SAXException {

        errorReceiver.warning(e);

    }

    protected final void error( Locator loc, String prop, Object... args ) {

        errorReceiver.error(loc,Messages.format(prop,args));

    }

}