/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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 org.apache.oodt.cas.cli;

//OODT static imports
import static org.apache.oodt.cas.cli.util.CmdLineUtils.asAdvancedOption;
import static org.apache.oodt.cas.cli.util.CmdLineUtils.determineFailedValidation;
import static org.apache.oodt.cas.cli.util.CmdLineUtils.determineRequired;
import static org.apache.oodt.cas.cli.util.CmdLineUtils.findFirstActionOption;
import static org.apache.oodt.cas.cli.util.CmdLineUtils.findHelpOption;
import static org.apache.oodt.cas.cli.util.CmdLineUtils.findPerformAndQuitOptions;
import static org.apache.oodt.cas.cli.util.CmdLineUtils.findPrintSupportedActionsOption;
import static org.apache.oodt.cas.cli.util.CmdLineUtils.handlePerformAndQuitOption;
import static org.apache.oodt.cas.cli.util.CmdLineUtils.isAdvancedOption;

//JDK imports
import java.util.HashSet;
import java.util.List;
import java.util.Set;

//Apache imports
import org.apache.commons.lang.Validate;

//OODT imports
import org.apache.oodt.cas.cli.action.CmdLineAction.ActionMessagePrinter;
import org.apache.oodt.cas.cli.action.store.CmdLineActionStore;
import org.apache.oodt.cas.cli.action.store.spring.SpringCmdLineActionStoreFactory;
import org.apache.oodt.cas.cli.construct.CmdLineConstructor;
import org.apache.oodt.cas.cli.construct.StdCmdLineConstructor;
import org.apache.oodt.cas.cli.exception.CmdLineActionException;
import org.apache.oodt.cas.cli.exception.CmdLineActionExecutionException;
import org.apache.oodt.cas.cli.exception.CmdLineActionStoreException;
import org.apache.oodt.cas.cli.exception.CmdLineConstructionException;
import org.apache.oodt.cas.cli.exception.CmdLineOptionStoreException;
import org.apache.oodt.cas.cli.exception.CmdLineParserException;
import org.apache.oodt.cas.cli.option.ActionCmdLineOption;
import org.apache.oodt.cas.cli.option.CmdLineOption;
import org.apache.oodt.cas.cli.option.CmdLineOptionInstance;
import org.apache.oodt.cas.cli.option.HelpCmdLineOption;
import org.apache.oodt.cas.cli.option.PrintSupportedActionsCmdLineOption;
import org.apache.oodt.cas.cli.option.store.CmdLineOptionStore;
import org.apache.oodt.cas.cli.option.store.spring.SpringCmdLineOptionStoreFactory;
import org.apache.oodt.cas.cli.option.validator.CmdLineOptionValidator;
import org.apache.oodt.cas.cli.parser.CmdLineParser;
import org.apache.oodt.cas.cli.parser.StdCmdLineParser;
import org.apache.oodt.cas.cli.presenter.CmdLinePresenter;
import org.apache.oodt.cas.cli.presenter.StdCmdLinePresenter;
import org.apache.oodt.cas.cli.printer.CmdLinePrinter;
import org.apache.oodt.cas.cli.printer.StdCmdLinePrinter;
import org.apache.oodt.cas.cli.util.CmdLineIterable;
import org.apache.oodt.cas.cli.util.CmdLineUtils;
import org.apache.oodt.cas.cli.util.ParsedArg;

//Google imports
import com.google.common.collect.Lists;

/**
 * A highly configurable utility class which supports parsing and handling of
 * command line arguments via its action driven design. After parsing the
 * command line arguments it will check for required arguments not specified,
 * validate the arguments, run the arguments handlers and then invoke the
 * specified action. It also supports print out help messages and printing
 * supported actions.
 * 
 * @author bfoster (Brian Foster)
 */
public class CmdLineUtility {

   private boolean debugMode;
   private CmdLineParser parser;
   private CmdLineConstructor constructor;
   private CmdLineOptionStore optionStore;
   private CmdLineActionStore actionStore;
   private CmdLinePrinter printer;
   private CmdLinePresenter presenter;

   public CmdLineUtility() {
      parser = new StdCmdLineParser();
      constructor = new StdCmdLineConstructor();
      optionStore = new SpringCmdLineOptionStoreFactory().createStore();
      actionStore = new SpringCmdLineActionStoreFactory().createStore();
      printer = new StdCmdLinePrinter();
      presenter = new StdCmdLinePresenter();

      debugMode = Boolean.getBoolean("org.apache.oodt.cas.cli.debug");
   }

   public CmdLineOptionStore getOptionStore() {
      return optionStore;
   }

   public void setOptionStore(CmdLineOptionStore optionStore) {
      this.optionStore = optionStore;
   }

   public CmdLineActionStore getActionStore() {
      return actionStore;
   }

   public void setActionStore(CmdLineActionStore actionStore) {
      this.actionStore = actionStore;
   }

   public CmdLinePrinter getPrinter() {
      return printer;
   }

   public void setPrinter(CmdLinePrinter printer) {
      this.printer = printer;
   }

   public CmdLinePresenter getPresenter() {
      return presenter;
   }

   public void setPresenter(CmdLinePresenter presenter) {
      this.presenter = presenter;
   }

   public void printOptionHelp(CmdLineArgs cmdLineArgs) {
      presenter.presentOptionHelp(printer.printOptionsHelp(cmdLineArgs
            .getSupportedOptions()));
   }

   public void printActionHelp(CmdLineArgs cmdLineArgs) {
      Validate.notEmpty(cmdLineArgs.getHelpOptionInst().getValues());

      presenter.presentActionHelp(printer.printActionHelp(
            CmdLineUtils.findAction(cmdLineArgs.getHelpOptionInst().getValues()
                  .get(0), cmdLineArgs.getSupportedActions()),
            cmdLineArgs.getSupportedOptions()));
   }

   public void printActionsHelp(CmdLineArgs cmdLineArgs) {
      presenter.presentActionsHelp(printer.printActionsHelp(cmdLineArgs
            .getSupportedActions()));
   }

   public void printActionMessages(List<String> messages) {
      presenter.presentActionMessage(printer.printActionMessages(messages));
   }

   public void printValidationErrors(List<CmdLineOptionValidator.Result> results) {
      presenter.presentErrorMessage(printer
            .printOptionValidationErrors(results));
   }

   public void printMissingRequiredOptionsError(
         Set<CmdLineOption> missingOptions) {
      presenter.presentErrorMessage(printer
            .printRequiredOptionsMissingError(missingOptions));
   }

   public void printErrorMessage(String errorMessage) {
      presenter.presentErrorMessage(errorMessage);
   }

   /**
    * Parses given command line arguments, then checks for help and print
    * supported actions options, prints them out if found, otherwise performs
    * execution on the arguments - see execute(CmdLineArgs).
    * 
    * @param args
    *           The who will be parsed and executed.
    */
   public void run(String[] args) {
      try {
         CmdLineArgs cmdLineArgs = parse(args);
         if (cmdLineArgs.getSpecifiedOptions().isEmpty()) {
            printOptionHelp(cmdLineArgs);
         } else if (!handleHelp(cmdLineArgs)
               && !handlePrintSupportedActions(cmdLineArgs)) {
            execute(cmdLineArgs);
         }
      } catch (Exception e) {
         if (debugMode) {
            throw new RuntimeException(e);
         }
         printErrorMessage(e.getMessage());
      }
   }

   /**
    * Parses the given command line arguments and converts it to
    * {@link CmdLineArgs}.
    * 
    * @param args
    *           The command line arguments to parse.
    * @return The parsed command line arguments in {@link CmdLineArgs} form.
    * @throws IOException
    *            On error parsing command line arguments.
    * @throws CmdLineConstructionException
    *            On error constructing command line arguments.
    * @throws CmdLineOptionStoreException
    */
   public CmdLineArgs parse(String[] args) throws CmdLineParserException,
         CmdLineActionStoreException, CmdLineConstructionException,
         CmdLineOptionStoreException {
      Validate.notNull(parser);
      Validate.notNull(optionStore);

      // Load supported options.
      Set<CmdLineOption> validOptions = optionStore.loadSupportedOptions();
      initializeHandlers(validOptions);

      // Insure help options is present if required.
      if (findHelpOption(validOptions) == null) {
         validOptions.add(new HelpCmdLineOption());
      }

      // Insure action options are present if required.
      if (findFirstActionOption(validOptions) == null) {
         validOptions.add(new ActionCmdLineOption());
      }

      // Insure print supported actions option is present if required.
      if (findPrintSupportedActionsOption(validOptions) == null) {
         validOptions.add(new PrintSupportedActionsCmdLineOption());
      }

      // Parse command line arguments.
      return new CmdLineArgs(actionStore.loadSupportedActions(), validOptions,
            constructor.construct(
                  new CmdLineIterable<ParsedArg>(parser.parse(args)),
                  validOptions));
   }

   /**
    * Initializes each {@link CmdLineOptionHandler} with their assigned
    * {@link CmdLineOption}.
    * 
    * @param options
    */
   public void initializeHandlers(Set<CmdLineOption> options) {
      for (CmdLineOption option : options) {
         if (isAdvancedOption(option)
               && asAdvancedOption(option).getHandler() != null) {
            asAdvancedOption(option).getHandler().initialize(option);
         }
      }
   }

   /**
    * Checks if help option was specified and if so prints out help.
    * 
    * @param cmdLineArgs
    *           The {@link CmdLineArgs} which will be checked for help option
    * @return True if help was printed, false otherwise
    */
   public boolean handleHelp(CmdLineArgs cmdLineArgs) {
      if (cmdLineArgs.getHelpOptionInst() != null) {
         if (cmdLineArgs.getHelpOptionInst().getValues().isEmpty()) {
            printOptionHelp(cmdLineArgs);
         } else {
            printActionHelp(cmdLineArgs);
         }
         return true;
      }
      return false;
   }

   /**
    * Checks if print supported actions option was specified and if so prints
    * out supported actions.
    * 
    * @param cmdLineArgs
    *           The {@link CmdLineArgs} which will be checked for print
    *           supported action options
    * @return True if supported actions was printed, false otherwise
    */
   public boolean handlePrintSupportedActions(CmdLineArgs cmdLineArgs) {
      if (cmdLineArgs.getPrintSupportedActionsOptionInst() != null) {
         printActionsHelp(cmdLineArgs);
         return true;
      }
      return false;
   }

   /**
    * Checks if required options are set and validation passes, then runs
    * handlers and executes its action.
    * 
    * @param cmdLineArgs
    *           The {@link CmdLineArgs} for which execution processing will be
    *           run.
    */
   public void execute(CmdLineArgs cmdLineArgs)
         throws CmdLineActionExecutionException, CmdLineActionException {
      Set<CmdLineOptionInstance> performAndQuitOptions = findPerformAndQuitOptions(cmdLineArgs
            .getSpecifiedOptions());
      if (!performAndQuitOptions.isEmpty()) {
         for (CmdLineOptionInstance option : performAndQuitOptions) {
            handlePerformAndQuitOption(option);
         }
         return;
      }

      if (cmdLineArgs.getActionOptionInst() == null) {
         throw new CmdLineActionExecutionException(
               "Must specify an action option!");
      }
      Set<CmdLineOption> requiredOptionsNotSet = check(cmdLineArgs);
      if (!requiredOptionsNotSet.isEmpty()) {
         printMissingRequiredOptionsError(requiredOptionsNotSet);
         return;
      }

      List<CmdLineOptionValidator.Result> failedValidationResults = determineFailedValidation(validate(cmdLineArgs));
      if (!failedValidationResults.isEmpty()) {
         printValidationErrors(failedValidationResults);
         return;
      }

      handle(cmdLineArgs);

      ActionMessagePrinter printer = new ActionMessagePrinter();
      cmdLineArgs.getSpecifiedAction().execute(printer);
      printActionMessages(printer.getPrintedMessages());
   }

   /**
    * Checks for required options which are not set and returns the ones it
    * finds.
    * 
    * @param cmdLineArgs
    *           The {@link CmdLineArgs} which will be check for required
    *           options.
    * @return The required {@link CmdLineOption}s not specified.
    */
   public static Set<CmdLineOption> check(CmdLineArgs cmdLineArgs) {
      Set<CmdLineOption> requiredOptions = determineRequired(
            cmdLineArgs.getSpecifiedAction(), cmdLineArgs.getSupportedOptions());
      HashSet<CmdLineOption> requiredOptionsNotSet = new HashSet<CmdLineOption>(
            requiredOptions);
      for (CmdLineOptionInstance specifiedOption : cmdLineArgs
            .getSpecifiedOptions()) {
         requiredOptionsNotSet.remove(specifiedOption.getOption());
      }
      return requiredOptionsNotSet;
   }

   /**
    * Runs validation on {@link CmdLineArgs} and returns the validation results.
    * 
    * @param cmdLineArgs
    *           The {@link CmdLineArgs} which will be validated.
    * @return The {@link CmdLineOptionValidator.Result}s generated when running
    *         {@link CmdLineOptionValidator}s.
    */
   public static List<CmdLineOptionValidator.Result> validate(
         CmdLineArgs cmdLineArgs) {
      Validate.notNull(cmdLineArgs);

      List<CmdLineOptionValidator.Result> results = Lists.newArrayList();
      for (CmdLineOptionInstance optionInst : cmdLineArgs.getSpecifiedOptions()) {
         results.addAll(CmdLineUtils.validate(optionInst));
      }
      return results;
   }

   /**
    * Runs the {@link CmdLineOptionHandler}s for {@link CmdLineArgs} given.
    * 
    * @param cmdLineArgs
    *           The {@link CmdLineArgs} whose option handlers will be run.
    */
   public static void handle(CmdLineArgs cmdLineArgs) {
      for (CmdLineOptionInstance option : cmdLineArgs.getSpecifiedOptions()) {
         CmdLineUtils.handle(cmdLineArgs.getSpecifiedAction(), option);
      }
   }
}