/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright (c) 2005-2010 Oracle and/or its affiliates. All rights reserved.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common Development
 * and Distribution License("CDDL") (collectively, the "License").  You
 * may not use this file except in compliance with the License.  You can
 * obtain a copy of the License at
 * https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
 * or packager/legal/LICENSE.txt.  See the License for the specific
 * language governing permissions and limitations under the License.
 *
 * When distributing the software, include this License Header Notice in each
 * file and include the License file at packager/legal/LICENSE.txt.
 *
 * GPL Classpath Exception:
 * Oracle designates this particular file as subject to the "Classpath"
 * exception as provided by Oracle in the GPL Version 2 section of the License
 * file that accompanied this code.
 *
 * Modifications:
 * If applicable, add the following below the License Header, with the fields
 * enclosed by brackets [] replaced by your own identifying information:
 * "Portions Copyright [year] [name of copyright owner]"
 *
 * Contributor(s):
 * If you wish your version of this file to be governed by only the CDDL or
 * only the GPL Version 2, indicate your decision by adding "[Contributor]
 * elects to include this software in this distribution under the [CDDL or GPL
 * Version 2] license."  If you don't indicate a single choice of license, a
 * recipient has the option to distribute your version of this file under
 * either the CDDL, the GPL Version 2 or to extend the choice of license to
 * its licensees as provided above.  However, if you add GPL Version 2 code
 * and therefore, elected the GPL Version 2 license, then the option applies
 * only if the new code is made subject to such option by the copyright
 * holder.
 */

package com.sun.tools.txw2;

import com.sun.tools.txw2.builder.relaxng.SchemaBuilderImpl;
import com.sun.tools.txw2.model.Leaf;
import com.sun.tools.txw2.model.NodeSet;
import org.kohsuke.rngom.ast.util.CheckingSchemaBuilder;
import org.kohsuke.rngom.dt.CascadingDatatypeLibraryFactory;
import org.kohsuke.rngom.dt.builtin.BuiltinDatatypeLibraryFactory;
import org.kohsuke.rngom.parse.IllegalSchemaException;
import org.kohsuke.rngom.parse.Parseable;
import org.relaxng.datatype.DatatypeLibrary;
import org.relaxng.datatype.DatatypeLibraryFactory;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.net.URL;
import java.util.Enumeration;
import java.util.NoSuchElementException;
import java.util.Vector;

/**
 * @author Kohsuke Kawaguchi
 */
class RELAXNGLoader implements SchemaBuilder {
    private final Parseable parseable;

    public RELAXNGLoader(Parseable parseable) {
        this.parseable = parseable;
    }

    public NodeSet build(TxwOptions options) throws IllegalSchemaException {
        SchemaBuilderImpl stage1 = new SchemaBuilderImpl(options.codeModel);
        DatatypeLibraryLoader loader = new DatatypeLibraryLoader(getClass().getClassLoader());
        Leaf pattern = (Leaf)parseable.parse(new CheckingSchemaBuilder(stage1,options.errorListener,
            new CascadingDatatypeLibraryFactory(
                new BuiltinDatatypeLibraryFactory(loader),loader)));

        return new NodeSet(options,pattern);
    }

    /**
     * Copyright (c) 2001, Thai Open Source Software Center Ltd
     * All rights reserved.
     *
     * Redistribution and use in source and binary forms, with or without
     * modification, are permitted provided that the following conditions are
     * met:
     *
     *     Redistributions of source code must retain the above copyright
     *     notice, this list of conditions and the following disclaimer.
     *
     *     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.
     *
     *     Neither the name of the Thai Open Source Software Center Ltd nor
     *     the names of its contributors may be used to endorse or promote
     *     products derived from this software without specific prior written
     *     permission.
     *
     * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     * "AS IS" AND ANY EXPRESS 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 REGENTS OR
     * 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.
     */
    private static final class DatatypeLibraryLoader implements DatatypeLibraryFactory {
        private final Service service;

        private DatatypeLibraryLoader(ClassLoader cl) {
            service = new Service(DatatypeLibraryFactory.class,cl);
        }

        public DatatypeLibrary createDatatypeLibrary(String uri) {
            for (Enumeration e = service.getProviders();
                 e.hasMoreElements();) {
                DatatypeLibraryFactory factory
                        = (DatatypeLibraryFactory) e.nextElement();
                DatatypeLibrary library = factory.createDatatypeLibrary(uri);
                if (library != null)
                    return library;
            }
            return null;
        }

        private static class Service {
            private final Class serviceClass;
            private /*final*/ Enumeration configFiles;
            private Enumeration classNames = null;
            private final Vector providers = new Vector();
            private ClassLoader cl;

            private class ProviderEnumeration implements Enumeration {
                private int nextIndex = 0;

                public boolean hasMoreElements() {
                    return nextIndex < providers.size() || moreProviders();
                }

                public Object nextElement() {
                    try {
                        return providers.elementAt(nextIndex++);
                    } catch (ArrayIndexOutOfBoundsException e) {
                        throw new NoSuchElementException();
                    }
                }
            }

            public Service(Class cls, ClassLoader cl) {
                this.cl = cl;
                serviceClass = cls;
                String resName = "META-INF/services/" + serviceClass.getName();
                try {
                    configFiles = cl.getResources(resName);
                } catch (IOException e) {
                    configFiles = new Vector().elements();
                }
            }

            public Enumeration getProviders() {
                return new ProviderEnumeration();
            }

            synchronized private boolean moreProviders() {
                for (; ;) {
                    while (classNames == null) {
                        if (!configFiles.hasMoreElements())
                            return false;
                        classNames = parseConfigFile((URL) configFiles.nextElement());
                    }
                    while (classNames.hasMoreElements()) {
                        String className = (String) classNames.nextElement();
                        try {
                            Class cls = cl.loadClass(className);
                            Object obj = cls.newInstance();
                            if (serviceClass.isInstance(obj)) {
                                providers.addElement(obj);
                                return true;
                            }
                        }
                        catch (ClassNotFoundException e) {
                        }
                        catch (InstantiationException e) {
                        }
                        catch (IllegalAccessException e) {
                        }
                        catch (LinkageError e) {
                        }
                    }
                    classNames = null;
                }
            }

            private static final int START = 0;
            private static final int IN_NAME = 1;
            private static final int IN_COMMENT = 2;

            private static Enumeration parseConfigFile(URL url) {
                try {
                    InputStream in = url.openStream();
                    Reader r;
                    try {
                        r = new InputStreamReader(in, "UTF-8");
                    }
                    catch (UnsupportedEncodingException e) {
                        r = new InputStreamReader(in, "UTF8");
                    }
                    r = new BufferedReader(r);
                    Vector tokens = new Vector();
                    StringBuffer tokenBuf = new StringBuffer();
                    int state = START;
                    for (; ;) {
                        int n = r.read();
                        if (n < 0)
                            break;
                        char c = (char) n;
                        switch (c) {
                            case '\r':
                            case '\n':
                                state = START;
                                break;
                            case ' ':
                            case '\t':
                                break;
                            case '#':
                                state = IN_COMMENT;
                                break;
                            default:
                                if (state != IN_COMMENT) {
                                    state = IN_NAME;
                                    tokenBuf.append(c);
                                }
                                break;
                        }
                        if (tokenBuf.length() != 0 && state != IN_NAME) {
                            tokens.addElement(tokenBuf.toString());
                            tokenBuf.setLength(0);
                        }
                    }
                    if (tokenBuf.length() != 0)
                        tokens.addElement(tokenBuf.toString());
                    return tokens.elements();
                }
                catch (IOException e) {
                    return null;
                }
            }
        }

    }
}
