/*

 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.

 * 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;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

import java.io.PrintStream;

import java.util.Iterator;

import com.sun.codemodel.internal.CodeWriter;

import com.sun.codemodel.internal.JCodeModel;

import com.sun.codemodel.internal.writer.ZipCodeWriter;

import com.sun.istack.internal.NotNull;

import com.sun.istack.internal.Nullable;

import com.sun.tools.internal.xjc.generator.bean.BeanGenerator;

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

import com.sun.tools.internal.xjc.outline.Outline;

import com.sun.tools.internal.xjc.reader.gbind.Expression;

import com.sun.tools.internal.xjc.reader.gbind.Graph;

import com.sun.tools.internal.xjc.reader.internalizer.DOMForest;

import com.sun.tools.internal.xjc.reader.xmlschema.ExpressionBuilder;

import com.sun.tools.internal.xjc.reader.xmlschema.parser.XMLSchemaInternalizationLogic;

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

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

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

import com.sun.tools.internal.xjc.writer.SignatureWriter;

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

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

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

import org.xml.sax.SAXException;

import org.xml.sax.SAXParseException;

/**

 * Command Line Interface of XJC.

 */

public class Driver {

    public static void main(final String[] args) throws Exception {

        // use the platform default proxy if available.

        // see sun.net.spi.DefaultProxySelector for details.

        try {

            System.setProperty("java.net.useSystemProxies","true");

        } catch (SecurityException e) {

            // failing to set this property isn't fatal

        }

        if( Util.getSystemProperty(Driver.class,"noThreadSwap")!=null )

            _main(args);    // for the ease of debugging

        // run all the work in another thread so that the -Xss option

        // will take effect when compiling a large schema. See

        // http://developer.java.sun.com/developer/bugParade/bugs/4362291.html

        final Throwable[] ex = new Throwable[1];

        Thread th = new Thread() {

            @Override

            public void run() {

                try {

                    _main(args);

                } catch( Throwable e ) {

                    ex[0]=e;

                }

            }

        };

        th.start();

        th.join();

        if(ex[0]!=null) {

            // re-throw

            if( ex[0] instanceof Exception )

                throw (Exception)ex[0];

            else

                throw (Error)ex[0];

        }

    }

    private static void _main( String[] args ) throws Exception {

        try {

            System.exit(run( args, System.out, System.out ));

        } catch (BadCommandLineException e) {

            // there was an error in the command line.

            // print usage and abort.

            if(e.getMessage()!=null) {

                System.out.println(e.getMessage());

                System.out.println();

            }

            usage(e.getOptions(),false);

            System.exit(-1);

        }

    }

    /**

     * Performs schema compilation and prints the status/error into the

     * specified PrintStream.

     *

     * <p>

     * This method could be used to trigger XJC from other tools,

     * such as Ant or IDE.

     *

     * @param    args

     *      specified command line parameters. If there is an error

     *      in the parameters, {@link BadCommandLineException} will

     *      be thrown.

     * @param    status

     *      Status report of the compilation will be sent to this object.

     *      Useful to update users so that they will know something is happening.

     *      Only ignorable messages should be sent to this stream.

     *

     *      This parameter can be null to suppress messages.

     *

     * @param    out

     *      Various non-ignorable output (error messages, etc)

     *      will go to this stream.

     *

     * @return

     *      If the compiler runs successfully, this method returns 0.

     *      All non-zero values indicate an error. The error message

     *      will be sent to the specified PrintStream.

     */

    public static int run(String[] args, final PrintStream status, final PrintStream out)

        throws Exception {

        class Listener extends XJCListener {

            ConsoleErrorReporter cer = new ConsoleErrorReporter(out==null?new PrintStream(new NullStream()):out);

            @Override

            public void generatedFile(String fileName, int count, int total) {

                message(fileName);

            }

            @Override

            public void message(String msg) {

                if(status!=null)

                    status.println(msg);

            }

            public void error(SAXParseException exception) {

                cer.error(exception);

            }

            public void fatalError(SAXParseException exception) {

                cer.fatalError(exception);

            }

            public void warning(SAXParseException exception) {

                cer.warning(exception);

            }

            public void info(SAXParseException exception) {

                cer.info(exception);

            }

        }

        return run(args,new Listener());

    }

    /**

     * Performs schema compilation and prints the status/error into the

     * specified PrintStream.

     *

     * <p>

     * This method could be used to trigger XJC from other tools,

     * such as Ant or IDE.

     *

     * @param    args

     *        specified command line parameters. If there is an error

     *        in the parameters, {@link BadCommandLineException} will

     *        be thrown.

     * @param    listener

     *      Receives messages from XJC reporting progress/errors.

     *

     * @return

     *      If the compiler runs successfully, this method returns 0.

     *      All non-zero values indicate an error. The error message

     *      will be sent to the specified PrintStream.

     */

    public static int run(String[] args, @NotNull final XJCListener listener) throws BadCommandLineException {

        // recognize those special options before we start parsing options.

        for (String arg : args) {

            if (arg.equals("-version")) {

                listener.message(Messages.format(Messages.VERSION));

                return -1;

            }

            if (arg.equals("-fullversion")) {

                listener.message(Messages.format(Messages.FULLVERSION));

                return -1;

            }

        }

        final OptionsEx opt = new OptionsEx();

        opt.setSchemaLanguage(Language.XMLSCHEMA);  // disable auto-guessing

        try {

            opt.parseArguments(args);

        } catch (WeAreDone _) {

            return -1;

        } catch(BadCommandLineException e) {

            e.initOptions(opt);

            throw e;

        }

        // display a warning if the user specified the default package

        // this should work, but is generally a bad idea

        if(opt.defaultPackage != null && opt.defaultPackage.length()==0) {

            listener.message(Messages.format(Messages.WARNING_MSG, Messages.format(Messages.DEFAULT_PACKAGE_WARNING)));

        }

        // set up the context class loader so that the user-specified classes

        // can be loaded from there

        final ClassLoader contextClassLoader = SecureLoader.getContextClassLoader();

        SecureLoader.setContextClassLoader(opt.getUserClassLoader(contextClassLoader));

        // parse a grammar file

        //-----------------------------------------

        try {

            if( !opt.quiet ) {

                listener.message(Messages.format(Messages.PARSING_SCHEMA));

            }

            final boolean[] hadWarning = new boolean[1];

            ErrorReceiver receiver = new ErrorReceiverFilter(listener) {

                @Override

                public void info(SAXParseException exception) {

                    if(opt.verbose)

                        super.info(exception);

                }

                @Override

                public void warning(SAXParseException exception) {

                    hadWarning[0] = true;

                    if(!opt.quiet)

                        super.warning(exception);

                }

                @Override

                public void pollAbort() throws AbortException {

                    if(listener.isCanceled())

                        throw new AbortException();

                }

            };

            if( opt.mode==Mode.FOREST ) {

                // dump DOM forest and quit

                ModelLoader loader  = new ModelLoader( opt, new JCodeModel(), receiver );

                try {

                    DOMForest forest = loader.buildDOMForest(new XMLSchemaInternalizationLogic());

                    forest.dump(System.out);

                    return 0;

                } catch (SAXException e) {

                    // the error should have already been reported

                } catch (IOException e) {

                    receiver.error(e);

                }

                return -1;

            }

            if( opt.mode==Mode.GBIND ) {

                try {

                    XSSchemaSet xss = new ModelLoader(opt, new JCodeModel(), receiver).loadXMLSchema();

                    Iterator<XSComplexType> it = xss.iterateComplexTypes();

                    while (it.hasNext()) {

                        XSComplexType ct =  it.next();

                        XSParticle p = ct.getContentType().asParticle();

                        if(p==null)     continue;

                        Expression tree = ExpressionBuilder.createTree(p);

                        System.out.println("Graph for "+ct.getName());

                        System.out.println(tree.toString());

                        Graph g = new Graph(tree);

                        System.out.println(g.toString());

                        System.out.println();

                    }

                    return 0;

                } catch (SAXException e) {

                    // the error should have already been reported

                }

                return -1;

            }

            Model model = ModelLoader.load( opt, new JCodeModel(), receiver );

            if (model == null) {

                listener.message(Messages.format(Messages.PARSE_FAILED));

                return -1;

            }

            if( !opt.quiet ) {

                listener.message(Messages.format(Messages.COMPILING_SCHEMA));

            }

            switch (opt.mode) {

            case SIGNATURE :

                try {

                    SignatureWriter.write(

                        BeanGenerator.generate(model,receiver),

                        new OutputStreamWriter(System.out));

                    return 0;

                } catch (IOException e) {

                    receiver.error(e);

                    return -1;

                }

            case CODE :

            case DRYRUN :

            case ZIP :

                {

                    // generate actual code

                    receiver.debug("generating code");

                    {// don't want to hold outline in memory for too long.

                        Outline outline = model.generateCode(opt,receiver);

                        if(outline==null) {

                            listener.message(

                                Messages.format(Messages.FAILED_TO_GENERATE_CODE));

                            return -1;

                        }

                        listener.compiled(outline);

                    }

                    if( opt.mode == Mode.DRYRUN )

                        break;  // enough

                    // then print them out

                    try {

                        CodeWriter cw;

                        if( opt.mode==Mode.ZIP ) {

                            OutputStream os;

                            if(opt.targetDir.getPath().equals("."))

                                os = System.out;

                            else

                                os = new FileOutputStream(opt.targetDir);

                            cw = opt.createCodeWriter(new ZipCodeWriter(os));

                        } else

                            cw = opt.createCodeWriter();

                        if( !opt.quiet ) {

                            cw = new ProgressCodeWriter(cw,listener, model.codeModel.countArtifacts());

                        }

                        model.codeModel.build(cw);

                    } catch (IOException e) {

                        receiver.error(e);

                        return -1;

                    }

                    break;

                }

            default :

                assert false;

            }

            if(opt.debugMode) {

                try {

                    new FileOutputStream(new File(opt.targetDir,hadWarning[0]?"hadWarning":"noWarning")).close();

                } catch (IOException e) {

                    receiver.error(e);

                    return -1;

                }

            }

            return 0;

        } catch( StackOverflowError e ) {

            if(opt.verbose)

                // in the debug mode, propagate the error so that

                // the full stack trace will be dumped to the screen.

                throw e;

            else {

                // otherwise just print a suggested workaround and

                // quit without filling the user's screen

                listener.message(Messages.format(Messages.STACK_OVERFLOW));

                return -1;

            }

        }

    }

    public static String getBuildID() {

        return Messages.format(Messages.BUILD_ID);

    }

    /**

     * Operation mode.

     */

    private static enum Mode {

        // normal mode. compile the code

        CODE,

        // dump the signature of the generated code

        SIGNATURE,

        // dump DOMForest

        FOREST,

        // same as CODE but don't produce any Java source code

        DRYRUN,

        // same as CODE but pack all the outputs into a zip and dumps to stdout

        ZIP,

        // testing a new binding mode

        GBIND

    }

    /**

     * Command-line arguments processor.

     *

     * <p>

     * This class contains options that only make sense

     * for the command line interface.

     */

    static class OptionsEx extends Options

    {

        /** Operation mode. */

        protected Mode mode = Mode.CODE;

        /** A switch that determines the behavior in the BGM mode. */

        public boolean noNS = false;

        /** Parse XJC-specific options. */

        @Override

        public int parseArgument(String[] args, int i) throws BadCommandLineException {

            if (args[i].equals("-noNS")) {

                noNS = true;

                return 1;

            }

            if (args[i].equals("-mode")) {

                i++;

                if (i == args.length)

                    throw new BadCommandLineException(

                        Messages.format(Messages.MISSING_MODE_OPERAND));

                String mstr = args[i].toLowerCase();

                for( Mode m : Mode.values() ) {

                    if(m.name().toLowerCase().startsWith(mstr) && mstr.length()>2) {

                        mode = m;

                        return 2;

                    }

                }

                throw new BadCommandLineException(

                    Messages.format(Messages.UNRECOGNIZED_MODE, args[i]));

            }

            if (args[i].equals("-help")) {

                usage(this,false);

                throw new WeAreDone();

            }

            if (args[i].equals("-private")) {

                usage(this,true);

                throw new WeAreDone();

            }

            return super.parseArgument(args, i);

        }

    }

    /**

     * Used to signal that we've finished processing.

     */

    private static final class WeAreDone extends BadCommandLineException {}

    /**

     * Prints the usage screen and exits the process.

     *

     * @param opts

     *      If the parsing of options have started, set a partly populated

     *      {@link Options} object.

     */

    public static void usage( @Nullable Options opts, boolean privateUsage ) {

        System.out.println(Messages.format(Messages.DRIVER_PUBLIC_USAGE));

        if (privateUsage) {

            System.out.println(Messages.format(Messages.DRIVER_PRIVATE_USAGE));

        }

        if( opts!=null && !opts.getAllPlugins().isEmpty()) {

            System.out.println(Messages.format(Messages.ADDON_USAGE));

            for (Plugin p : opts.getAllPlugins()) {

                System.out.println(p.getUsage());

            }

        }

    }

}