/**

  * Copyright 2010, CSIRO Australia.

  *

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  *

  *         http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 package au.csiro.netcdf;

 import java.io.BufferedReader;

 import java.io.FileReader;

 import java.io.IOException;

 import java.io.PrintWriter;

 import java.io.StringWriter;

 import org.apache.commons.cli.BasicParser;

 import org.apache.commons.cli.CommandLine;

 import org.apache.commons.cli.HelpFormatter;

 import org.apache.commons.cli.Option;

 import org.apache.commons.cli.OptionBuilder;

 import org.apache.commons.cli.Options;

 import org.apache.commons.cli.ParseException;

 import au.csiro.netcdf.cli.Command;

 import au.csiro.netcdf.cli.CommandLineOptionsComparator;

 import au.csiro.netcdf.util.CSVTokenizer;

 import au.csiro.netcdf.util.Util;

 /**

  * The <strong>ncextractcsv</strong> command reads a specified column of data from a comma separated 

  * file and then writes this column to standard output.

  * <br/>

  * 

  * Copyright 2010, CSIRO Australia 

  * All rights reserved.

  * 

  * @author $Author: robertbridle $ on 18/03/2010

  * @version $Revision: 84 $ $Date: 2010-08-25 15:56:46 +1000 (Wed, 25 Aug 2010) $ $Id: CSVExtract.java 6525

  *          2010-03-17 23:39:33Z che256 $

  */

 public class NcCSVExtract implements Command

 {

     /**

      * The command name

      */

     public static final String EXTRACT_COMMAND_NAME = "ncextractcsv";

     /**

      * The name of the command line option used for specifying the input csv file name.

      */

     public static final String INPUT_FILE = "inputFileName";

     /**

      * The name of the command line option used for specifying the index of the column.

      */

     public static final String COLUMN_INDEX = "columnIndex";

     /**

      * The name of the command line option used for specifying the start row.

      */

     public static final String START_ROW = "startRow";

     /**

      * The name of the command line option used for specifying the end row.

      */

     public static final String END_ROW = "endRow";

     /**

      * Command options

      */

     private Options options = null;

     /**

      * Constructor

      */

     public NcCSVExtract()

     {

         this.options = createOptions();        

     }

     /**

      * Create the command line options for this CSVExtract command.

      * 

      * @return the command line options for this command.

      */

     @Override

     @SuppressWarnings("static-access")

     public Options createOptions()

     {

         Option fileName = OptionBuilder.withArgName("file").hasArg().withDescription(

                 "1: the filename of csv file to read.").isRequired(true).withLongOpt(INPUT_FILE).create("i");

         Option columnIndex = OptionBuilder.withArgName("integer").hasArg().withDescription(

                 "2: the column index from the csv file to read.").isRequired(true).withLongOpt(COLUMN_INDEX)

                 .create("c");

         Option startRow = OptionBuilder.withArgName("integer").hasArg().withDescription(

                 "3: the row to read from. OPTIONAL, if not specified row 0 is used.").isRequired(false).withLongOpt(

                 START_ROW).create("s");

         Option endRow = OptionBuilder.withArgName("integer").hasArg().withDescription(

                 "4: the row to read to. OPTIONAL, if not specified the last row in the csv file is used.").isRequired(

                 false).withLongOpt(END_ROW).create("e");

         Options options = new Options();

         options.addOption(fileName);

         options.addOption(columnIndex);

         options.addOption(startRow);

         options.addOption(endRow);

         return options;

     }

     /**

      * Run the CSVExtract command.

      * 

      * @param args

      *            command line arguments.

      * @throws ParseException

      *             thrown if the command line arguments can not be parsed.

      * @throws IOException

      *             thrown if netCDF can to be written to or read from.

      */

     @Override

     public void execute(String[] args) throws ParseException, IOException

     {

         // parse the command line arguments

         CommandLine parsedCommandLine = new BasicParser().parse(options, args);

         String filename = parsedCommandLine.getOptionValue(INPUT_FILE);

         int numRecords = Util.fastFileLineCounter(filename);

         int columnIndex = getIntValueByName(parsedCommandLine, COLUMN_INDEX);

         int rowCount = 0;

         int startRow = parsedCommandLine.hasOption(START_ROW) ? getIntValueByName(parsedCommandLine, START_ROW) : 0;

         int endRow = parsedCommandLine.hasOption(END_ROW) ? getIntValueByName(parsedCommandLine, END_ROW) : numRecords;

         endRow = (endRow > numRecords) ? numRecords : endRow;

         BufferedReader input = new BufferedReader(new FileReader(filename));

         try

         {

             String line = null;

             while ((line = input.readLine()) != null)

             {

                 // only read the required lines

                 if (rowCount >= startRow && rowCount <= endRow)

                 {

                     String[] values = new CSVTokenizer(line).getAllColumns();

                     String value = "";

                     try

                     {

                         value = values[columnIndex];

                     }

                     catch (ArrayIndexOutOfBoundsException ex)

                     {

                         throw new ParseException("incorrect column index");

                     }

                     System.out.println(value);

                     rowCount++;

                 }

                 else

                 {

                     rowCount++;

                     continue;

                 }

             }

         }

         finally

         {

             input.close();

         }

     }

     /**

      * @return the command name for this command.

      */

     @Override

     public String getCommandName()

     {

         return EXTRACT_COMMAND_NAME;

     }

     /**

      * Determine if this command is valid, check its syntax. Required options: inputFileName, columnIndex Type check:

      * columnIndex, startRow, endRow can only be integer

      * 

      * @param commandLine command line arguments.

      * @return error if found.

      */

     @Override

     public String validCommand(String[] commandLine)

     {

         StringBuffer errorMsg = new StringBuffer();

         CommandLine parsedCommandLine = null;

         // check required options are provided

         try

         {

             parsedCommandLine = new BasicParser().parse(options, commandLine);

         }

         catch (ParseException ex)

         {

             return ex.getMessage();

         }

         // check command name

         String commandName = parsedCommandLine.getArgs()[0];

         if (!getCommandName().equals(commandName))

         {

             return commandName + " is not a valid command.";

         }

         // check if specified file exist

         String fileName = parsedCommandLine.getOptionValue(INPUT_FILE);

         if (!Util.fileExists(fileName))

         {

             return fileName + " does not exist.";

         }

         // validate file type

         if (!".csv".equalsIgnoreCase(Util.getFileExtension(fileName)))

         {

             return fileName + " is not a csv file.";

         }

         // check required types:

         // i.e. columnIndex, startRow and endRow are of integer type

         int index = getIntValueByName(parsedCommandLine, COLUMN_INDEX);

         if (index == -1)

         {

             errorMsg.append("ColumnIndex has to be a number.");

         }

         if (parsedCommandLine.hasOption(START_ROW))

         {

             index = getIntValueByName(parsedCommandLine, START_ROW);

             if (index == -1)

             {

                 errorMsg.append(" startRow has to be a number.");

             }

         }

         if (parsedCommandLine.hasOption(END_ROW))

         {

             index = getIntValueByName(parsedCommandLine, END_ROW);

             if (index == -1)

             {

                 errorMsg.append(" endRow has to be a number.");

             }

         }

         return errorMsg.toString();

     }

     /**

      * @return the usage for this command.

      */

     @Override

     public String getUsageString()

     {

         // generate the help/usage statement

         String header = "Extract a block of data from a CSV file. The data can then "

                 + "be piped into the ncwritevar command to add the data to a variable in a netCDF file.";

         String footer = "\nExample: extract -inputFileName modeldata.csv -columnIndex 1 -startRow 2\n"

                 + "Will write the data contained in the second column of the modeldata.csv file to stdout, "

                 + "but ignoring the first 2 lines. ";

         StringWriter sw = new StringWriter();

         HelpFormatter formatter = new HelpFormatter();

         formatter.setOptionComparator(new CommandLineOptionsComparator());

         formatter.printHelp(new PrintWriter(sw), PRINT_WIDTH, EXTRACT_COMMAND_NAME, header, options, 0, 1, footer);

         return sw.toString();

     }

     /**

      * Return integer value of an option using specified name

      * "-1" is returned if option name or value is not valid

      * 

      * @param parsedCommandLine Commandline object

      * @param opName option name

      * @return int value

      */

     private int getIntValueByName(CommandLine parsedCommandLine, String opName)

     {

         String str = (parsedCommandLine.hasOption(opName)) ? parsedCommandLine.getOptionValue(opName) : "";

         if (Util.validateNumber(str))

         {

             return Integer.valueOf(str);

         }

         return -1;

     }

 }