/*

 * 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.codemodel.internal;

import java.util.ArrayList;

import java.util.List;

/**

 * JMethod invocation

 */

public final class JInvocation extends JExpressionImpl implements JStatement {

    /**

     * Object expression upon which this method will be invoked, or null if

     * this is a constructor invocation

     */

    private JGenerable object;

    /**

     * Name of the method to be invoked.

     * Either this field is set, or {@link #method}, or {@link #type} (in which case it's a

     * constructor invocation.)

     * This allows {@link JMethod#name(String) the name of the method to be changed later}.

     */

    private String name;

    private JMethod method;

    private boolean isConstructor = false;

    /**

     * List of argument expressions for this method invocation

     */

    private List<JExpression> args = new ArrayList<JExpression>();

    /**

     * If isConstructor==true, this field keeps the type to be created.

     */

    private JType type = null;

    /**

     * Invokes a method on an object.

     *

     * @param object

     *        JExpression for the object upon which

     *        the named method will be invoked,

     *        or null if none

     *

     * @param name

     *        Name of method to invoke

     */

    JInvocation(JExpression object, String name) {

        this( (JGenerable)object, name );

    }

    JInvocation(JExpression object, JMethod method) {

        this( (JGenerable)object, method );

    }

    /**

     * Invokes a static method on a class.

     */

    JInvocation(JClass type, String name) {

        this( (JGenerable)type, name );

    }

    JInvocation(JClass type, JMethod method) {

        this( (JGenerable)type, method );

    }

    private JInvocation(JGenerable object, String name) {

        this.object = object;

        if (name.indexOf('.') >= 0)

            throw new IllegalArgumentException("method name contains '.': " + name);

        this.name = name;

    }

    private JInvocation(JGenerable object, JMethod method) {

        this.object = object;

        this.method =method;

    }

    /**

     * Invokes a constructor of an object (i.e., creates

     * a new object.)

     *

     * @param c

     *      Type of the object to be created. If this type is

     *      an array type, added arguments are treated as array

     *      initializer. Thus you can create an expression like

     *      <code>new int[]{1,2,3,4,5}</code>.

     */

    JInvocation(JType c) {

        this.isConstructor = true;

        this.type = c;

    }

    /**

     *  Add an expression to this invocation's argument list

     *

     * @param arg

     *        Argument to add to argument list

     */

    public JInvocation arg(JExpression arg) {

        if(arg==null)   throw new IllegalArgumentException();

        args.add(arg);

        return this;

    }

    /**

     * Adds a literal argument.

     *

     * Short for {@code arg(JExpr.lit(v))}

     */

    public JInvocation arg(String v) {

        return arg(JExpr.lit(v));

    }

        /**

         * Returns all arguments of the invocation.

         * @return

         *      If there's no arguments, an empty array will be returned.

         */

        public JExpression[] listArgs() {

                return args.toArray(new JExpression[args.size()]);

        }

    public void generate(JFormatter f) {

        if (isConstructor && type.isArray()) {

            // [RESULT] new T[]{arg1,arg2,arg3,...};

            f.p("new").g(type).p('{');

        } else {

            if (isConstructor)

                f.p("new").g(type).p('(');

            else {

                String name = this.name;

                if(name==null)  name=this.method.name();

                if (object != null)

                    f.g(object).p('.').p(name).p('(');

                else

                    f.id(name).p('(');

            }

        }

        f.g(args);

        if (isConstructor && type.isArray())

            f.p('}');

        else

            f.p(')');

        if( type instanceof JDefinedClass && ((JDefinedClass)type).isAnonymous() ) {

            ((JAnonymousClass)type).declareBody(f);

        }

    }

    public void state(JFormatter f) {

        f.g(this).p(';').nl();

    }

}