/*

 * Copyright (c) 2004, 2010, 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 sun.tools.jstat;

import java.io.*;

import java.net.*;

import java.util.*;

import java.util.regex.*;

import sun.jvmstat.monitor.Monitor;

import sun.jvmstat.monitor.VmIdentifier;

/**

 * Class for processing command line arguments and providing method

 * level access to arguments.

 *

 * @author Brian Doherty

 * @since 1.5

 */

public class Arguments {

    private static final boolean debug = Boolean.getBoolean("jstat.debug");

    private static final boolean showUnsupported =

            Boolean.getBoolean("jstat.showUnsupported");

    private static final String JVMSTAT_USERDIR = ".jvmstat";

    private static final String OPTIONS_FILENAME = "jstat_options";

    private static final String UNSUPPORTED_OPTIONS_FILENAME = "jstat_unsupported_options";

    private static final String ALL_NAMES = "\\w*";

    private Comparator<Monitor> comparator;

    private int headerRate;

    private boolean help;

    private boolean list;

    private boolean options;

    private boolean constants;

    private boolean constantsOnly;

    private boolean strings;

    private boolean timestamp;

    private boolean snap;

    private boolean verbose;

    private String specialOption;

    private String names;

    private OptionFormat optionFormat;

    private int count = -1;

    private int interval = -1;

    private String vmIdString;

    private VmIdentifier vmId;

    public static void printUsage(PrintStream ps) {

        ps.println("Usage: jstat -help|-options");

        ps.println("       jstat -<option> [-t] [-h<lines>] <vmid> [<interval> [<count>]]");

        ps.println();

        ps.println("Definitions:");

        ps.println("  <option>      An option reported by the -options option");

        ps.println("  <vmid>        Virtual Machine Identifier. A vmid takes the following form:");

        ps.println("                     <lvmid>[@<hostname>[:<port>]]");

        ps.println("                Where <lvmid> is the local vm identifier for the target");

        ps.println("                Java virtual machine, typically a process id; <hostname> is");

        ps.println("                the name of the host running the target Java virtual machine;");

        ps.println("                and <port> is the port number for the rmiregistry on the");

        ps.println("                target host. See the jvmstat documentation for a more complete");

        ps.println("                description of the Virtual Machine Identifier.");

        ps.println("  <lines>       Number of samples between header lines.");

        ps.println("  <interval>    Sampling interval. The following forms are allowed:");

        ps.println("                    <n>[\"ms\"|\"s\"]");

        ps.println("                Where <n> is an integer and the suffix specifies the units as ");

        ps.println("                milliseconds(\"ms\") or seconds(\"s\"). The default units are \"ms\".");

        ps.println("  <count>       Number of samples to take before terminating.");

        ps.println("  -J<flag>      Pass <flag> directly to the runtime system.");

        // undocumented options:

        //   -list [<vmid>]  - list counter names

        //   -snap <vmid>    - snapshot counter values as name=value pairs

        //   -name <pattern> - output counters matching given pattern

        //   -a              - sort in ascending order (default)

        //   -d              - sort in descending order

        //   -v              - verbose output  (-snap)

        //   -constants      - output constants with -name output

        //   -strings        - output strings with -name output

    }

    private static int toMillis(String s) throws IllegalArgumentException {

        String[] unitStrings = { "ms", "s" }; // ordered from most specific to

                                              // least specific

        String unitString = null;

        String valueString = s;

        for (int i = 0; i < unitStrings.length; i++) {

            int index = s.indexOf(unitStrings[i]);

            if (index > 0) {

                unitString = s.substring(index);

                valueString = s.substring(0, index);

                break;

            }

        }

        try {

            int value = Integer.parseInt(valueString);

            if (unitString == null || unitString.compareTo("ms") == 0) {

                return value;

            } else if (unitString.compareTo("s") == 0) {

                return value * 1000;

            } else {

                throw new IllegalArgumentException(

                        "Unknow time unit: " + unitString);

            }

        } catch (NumberFormatException e) {

            throw new IllegalArgumentException(

                    "Could not convert interval: " + s);

        }

    }

    public Arguments(String[] args) throws IllegalArgumentException {

        int argc = 0;

        if (args.length < 1) {

            throw new IllegalArgumentException("invalid argument count");

        }

        if ((args[0].compareTo("-?") == 0)

                || (args[0].compareTo("-help") == 0)) {

            help = true;

            return;

        } else if (args[0].compareTo("-options") == 0) {

            options = true;

            return;

        } else if (args[0].compareTo("-list") == 0) {

            list = true;

            if (args.length > 2) {

              throw new IllegalArgumentException("invalid argument count");

            }

            // list can take one arg - a vmid - fall through for arg processing

            argc++;

        }

        for ( ; (argc < args.length) && (args[argc].startsWith("-")); argc++) {

            String arg = args[argc];

            if (arg.compareTo("-a") == 0) {

                comparator = new AscendingMonitorComparator();

            } else if (arg.compareTo("-d") == 0) {

                comparator =  new DescendingMonitorComparator();

            } else if (arg.compareTo("-t") == 0) {

                timestamp = true;

            } else if (arg.compareTo("-v") == 0) {

                verbose = true;

            } else if ((arg.compareTo("-constants") == 0)

                       || (arg.compareTo("-c") == 0)) {

                constants = true;

            } else if ((arg.compareTo("-strings") == 0)

                       || (arg.compareTo("-s") == 0)) {

                strings = true;

            } else if (arg.startsWith("-h")) {

                String value;

                if (arg.compareTo("-h") != 0) {

                    value = arg.substring(2);

                } else {

                    argc++;

                    if (argc >= args.length) {

                        throw new IllegalArgumentException(

                                "-h requires an integer argument");

                    }

                    value = args[argc];

                }

                try {

                    headerRate = Integer.parseInt(value);

                } catch (NumberFormatException e) {

                    headerRate = -1;

                }

                if (headerRate < 0) {

                    throw new IllegalArgumentException(

                            "illegal -h argument: " + value);

                }

            } else if (arg.startsWith("-name")) {

                if (arg.startsWith("-name=")) {

                    names = arg.substring(7);

                } else {

                    argc++;

                    if (argc >= args.length) {

                        throw new IllegalArgumentException(

                                "option argument expected");

                    }

                    names = args[argc];

                }

            } else {

                /*

                 * there are scenarios here: special jstat_options file option

                 * or the rare case of a negative lvmid. The negative lvmid

                 * can occur in some operating environments (such as Windows

                 * 95/98/ME), so we provide for this case here by checking if

                 * the argument has any numerical characters. This assumes that

                 * there are no special jstat_options that contain numerical

                 * characters in their name.

                 */

                // extract the lvmid part of possible lvmid@host.domain:port

                String lvmidStr = null;

                int at_index = args[argc].indexOf('@');

                if (at_index < 0) {

                    lvmidStr = args[argc];

                } else {

                    lvmidStr = args[argc].substring(0, at_index);

                }

                // try to parse the lvmid part as an integer

                try {

                    int vmid = Integer.parseInt(lvmidStr);

                    // it parsed, assume a negative lvmid and continue

                    break;

                } catch (NumberFormatException nfe) {

                    // it didn't parse. check for the -snap or jstat_options

                    // file options.

                    if ((argc == 0) && (args[argc].compareTo("-snap") == 0)) {

                        snap = true;

                    } else if (argc == 0) {

                        specialOption = args[argc].substring(1);

                    } else {

                        throw new IllegalArgumentException(

                                "illegal argument: " + args[argc]);

                    }

                }

            }

        }

        // prevent 'jstat <pid>' from being accepted as a valid argument

        if (!(specialOption != null || list || snap || names != null)) {

            throw new IllegalArgumentException("-<option> required");

        }

        switch (args.length - argc) {

        case 3:

            if (snap) {

                throw new IllegalArgumentException("invalid argument count");

            }

            try {

                count = Integer.parseInt(args[args.length-1]);

            } catch (NumberFormatException e) {

                throw new IllegalArgumentException("illegal count value: "

                                                   + args[args.length-1]);

            }

            interval = toMillis(args[args.length-2]);

            vmIdString = args[args.length-3];

            break;

        case 2:

            if (snap) {

                throw new IllegalArgumentException("invalid argument count");

            }

            interval = toMillis(args[args.length-1]);

            vmIdString = args[args.length-2];

            break;

        case 1:

            vmIdString = args[args.length-1];

            break;

        case 0:

            if (!list) {

                throw new IllegalArgumentException("invalid argument count");

            }

            break;

        default:

            throw new IllegalArgumentException("invalid argument count");

        }

        // set count and interval to their default values if not set above.

        if (count == -1 && interval == -1) {

            // default is for a single sample

            count = 1;

            interval = 0;

        }

        // validate arguments

        if (comparator == null) {

            comparator = new AscendingMonitorComparator();

        }

        // allow ',' characters to separate names, convert to '|' chars

        names = (names == null) ? ALL_NAMES : names.replace(',', '|');

        // verify that the given pattern parses without errors

        try {

            Pattern pattern = Pattern.compile(names);

        } catch (PatternSyntaxException e) {

            throw new IllegalArgumentException("Bad name pattern: "

                                               + e.getMessage());

        }

        // verify that the special option is valid and get it's formatter

        if (specialOption != null) {

            OptionFinder finder = new OptionFinder(optionsSources());

            optionFormat = finder.getOptionFormat(specialOption, timestamp);

            if (optionFormat == null) {

                throw new IllegalArgumentException("Unknown option: -"

                                                   + specialOption);

            }

        }

        // verify that the vm identifier is valied

        try {

            vmId = new VmIdentifier(vmIdString);

        } catch (URISyntaxException e) {

            IllegalArgumentException iae = new IllegalArgumentException(

                    "Malformed VM Identifier: " + vmIdString);

            iae.initCause(e);

            throw iae;

        }

    }

    public Comparator<Monitor> comparator() {

        return comparator;

    }

    public boolean isHelp() {

        return help;

    }

    public boolean isList() {

        return list;

    }

    public boolean isSnap() {

        return snap;

    }

    public boolean isOptions() {

        return options;

    }

    public boolean isVerbose() {

        return verbose;

    }

    public boolean printConstants() {

        return constants;

    }

    public boolean isConstantsOnly() {

        return constantsOnly;

    }

    public boolean printStrings() {

        return strings;

    }

    public boolean showUnsupported() {

        return showUnsupported;

    }

    public int headerRate() {

        return headerRate;

    }

    public String counterNames() {

        return names;

    }

    public VmIdentifier vmId() {

        return vmId;

    }

    public String vmIdString() {

        return vmIdString;

    }

    public int sampleInterval() {

        return interval;

    }

    public int sampleCount() {

        return count;

    }

    public boolean isTimestamp() {

        return timestamp;

    }

    public boolean isSpecialOption() {

        return specialOption != null;

    }

    public String specialOption() {

        return specialOption;

    }

    public OptionFormat optionFormat() {

        return optionFormat;

    }

    public List<URL> optionsSources() {

        List<URL> sources = new ArrayList<URL>();

        int i = 0;

        String filename = OPTIONS_FILENAME;

        try {

            String userHome = System.getProperty("user.home");

            String userDir = userHome + "/" + JVMSTAT_USERDIR;

            File home = new File(userDir + "/" + filename);

            sources.add(home.toURI().toURL());

        } catch (Exception e) {

            if (debug) {

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

                e.printStackTrace();

            }

            throw new IllegalArgumentException("Internal Error: Bad URL: "

                                               + e.getMessage());

        }

        URL u = this.getClass().getResource("resources/" + filename);

        assert u != null;

        sources.add(u);

        if (showUnsupported) {

            u = this.getClass().getResource("resources/" +  UNSUPPORTED_OPTIONS_FILENAME);

            assert u != null;

            sources.add(u);

        }

        return sources;

    }

}