/**
 * 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.sqoop.shell.utils;

import jline.ConsoleReader;

import org.apache.commons.cli.CommandLine;
import org.apache.commons.lang.StringUtils;
import org.apache.sqoop.common.Direction;
import org.apache.sqoop.model.InputEditable;
import org.apache.sqoop.model.MBooleanInput;
import org.apache.sqoop.model.MLink;
import org.apache.sqoop.model.MEnumInput;
import org.apache.sqoop.model.MConfig;
import org.apache.sqoop.model.MInput;
import org.apache.sqoop.model.MIntegerInput;
import org.apache.sqoop.model.MLongInput;
import org.apache.sqoop.model.MMapInput;
import org.apache.sqoop.model.MJob;
import org.apache.sqoop.model.MNamedElement;
import org.apache.sqoop.model.MStringInput;
import org.apache.sqoop.model.MValidatedElement;
import org.apache.sqoop.validation.Message;
import org.apache.sqoop.validation.Status;

import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
import java.util.ResourceBundle;

import static org.apache.sqoop.shell.ShellEnvironment.*;

/**
 * Convenient methods for retrieving user input and CLI options.
 */
public final class ConfigFiller {

  /**
   * Internal input that will be reused for loading names for link and
   * job objects.
   */
  private static MStringInput nameInput = new MStringInput("object-name", false, InputEditable.ANY, StringUtils.EMPTY, (short)25);

  /**
   * Fill job object based on CLI options.
   *
   * @param line Associated console reader object
   * @param job Job that user is suppose to fill in
   * @return True if we filled all inputs, false if user has stopped processing
   * @throws IOException
   */
  public static boolean fillJob(CommandLine line,
                                MJob job)
                                throws IOException {

    job.setName(line.getOptionValue("name"));
    return fillJobConfig(line,
                     job.getFromJobConfig().getConfigs(),
                     job.getToJobConfig().getConfigs(),
                     job.getDriverConfig().getConfigs());
  }

  /**
   * Fill link object based on CLI options.
   *
   * @param line Associated command line options
   * @param link Link that user is suppose to fill in
   * @return True if we filled all inputs, false if user has stopped processing
   * @throws IOException
   */
  public static boolean fillLink(CommandLine line, MLink link) throws IOException {

    link.setName(line.getOptionValue("name"));
    return fillLinkConfig(line, link.getConnectorLinkConfig().getConfigs());
  }

  /**
   * Load CLI options for link configs
   *
   * @param line CLI options container
   * @param linkConfig from config to read or edit
   * @return
   * @throws IOException
   */
  public static boolean fillLinkConfig(CommandLine line,
                                  List<MConfig> linkConfig)
                                      throws IOException {
    return fillConfigs("link", linkConfig, line);
  }

  /**
   * Load CLI options for job configs
   *
   * @param line CLI options container
   * @param fromConfig from config to read or edit
   * @param toConfig to config to read or edit
   * @param driverConfig driver config to read or edit
   * @return
   * @throws IOException
   */
  public static boolean fillJobConfig(CommandLine line,
                                  List<MConfig> fromConfig,
                                  List<MConfig> toConfig,
                                  List<MConfig> driverConfig)
                                      throws IOException {
    return fillConfigs("from", fromConfig, line)
        && fillConfigs("to", toConfig, line)
        && fillConfigs("driver", driverConfig, line);
  }

  /**
   * Load all CLI options for a list of configs.
   *
   * @param prefix placed at the beginning of the CLI option key
   * @param configs Forms to read or edit
   * @param line CLI options container
   * @return
   * @throws IOException
   */
  static boolean fillConfigs(String prefix, List<MConfig> configs, CommandLine line)
      throws IOException {
    for (MConfig config : configs) {
      if (!fillConfig(prefix, config, line)) {
        return false;
      }
    }
    return true;
  }

  /**
   * Load all CLI options for a particular config.
   *
   * @param prefix placed at the beginning of the CLI option key
   * @param config Config to read or edit
   * @param line CLI options container
   * @return
   * @throws IOException
   */
  @SuppressWarnings("rawtypes")
  static boolean fillConfig(String prefix, MConfig config, CommandLine line) throws IOException {
    for (MInput input : config.getInputs()) {
      if (!fillInput(prefix, input, line)) {
        return false;
      }
    }
    return true;
  }

  /**
   * Load CLI option.
   * Chooses the appropriate 'fill' method to use based on input type.
   *
   * Keys for CLI options are automatically created from the 'prefix' argument
   * and 'input' argument: <prefix>-<config name>-<input name>
   *
   * @param prefix placed at the beginning of the CLI option key
   * @param input Input that we should read or edit
   * @param line CLI options container
   * @return
   * @throws IOException
   */
  @SuppressWarnings("rawtypes")
  public static boolean fillInput(String prefix, MInput input, CommandLine line) throws IOException {
    // Based on the input type, let's perconfig specific load
    switch (input.getType()) {
    case STRING:
      return fillInputString(prefix, (MStringInput) input, line);
    case INTEGER:
      return fillInputInteger(prefix, (MIntegerInput) input, line);
    case LONG:
      return fillInputLong(prefix, (MLongInput) input, line);
    case BOOLEAN:
      return fillInputBoolean(prefix, (MBooleanInput) input, line);
    case MAP:
      return fillInputMap(prefix, (MMapInput) input, line);
    case ENUM:
      return fillInputEnum(prefix, (MEnumInput) input, line);
    default:
      println("Unsupported data type " + input.getType());
      return true;
    }
  }

  /**
   * Load CLI option for enum type.
   *
   * Currently only supports numeric values.
   *
   * @param prefix placed at the beginning of the CLI option key
   * @param input Input that we should read or edit
   * @param line CLI options container
   * @return
   * @throws IOException
   */
  private static boolean fillInputEnum(String prefix,
                                       MEnumInput input,
                                       CommandLine line)
                                       throws IOException {
    String opt = ConfigOptions.getOptionKey(prefix, input);
    if (line.hasOption(opt)) {
      String value = line.getOptionValue(opt);
      int index = java.util.Arrays.asList(input.getValues()).indexOf(value);

      if(index < 0) {
        errorMessage(input, String.format("Invalid option %s. Please use one of %s.", value, StringUtils.join(input.getValues(), ", ")));
        return false;
      }

      input.setValue(value);
    } else {
      input.setEmpty();
    }
    return true;
  }

  /**
   * Load CLI options for map type.
   *
   * Parses Key-Value pairs that take the config "<key>=<value>&<key>=<value>&...".
   *
   * @param prefix placed at the beginning of the CLI option key
   * @param input Input that we should read or edit
   * @param line CLI options container
   * @return
   * @throws IOException
   */
  private static boolean fillInputMap(String prefix,
                                      MMapInput input,
                                      CommandLine line)
                                      throws IOException {
    String opt = ConfigOptions.getOptionKey(prefix, input);
    if (line.hasOption(opt)) {
      String value = line.getOptionValue(opt);
      Map<String, String> values = new HashMap<String, String>();
      String[] entries = value.split("&");
      for (String entry : entries) {
        if (entry.contains("=")) {
          String[] keyValue = entry.split("=");
          values.put(keyValue[0], keyValue[1]);
        } else {
          errorMessage(input, "Don't know what to do with " + entry);
          return false;
        }
      }
      input.setValue(values);
    } else {
      input.setEmpty();
    }
    return true;
  }

  /**
   * Load integer input from CLI option.
   *
   * @param prefix placed at the beginning of the CLI option key
   * @param input Input that we should read or edit
   * @param line CLI options container
   * @return
   * @throws IOException
   */
  private static boolean fillInputInteger(String prefix,
                                          MIntegerInput input,
                                          CommandLine line)
                                          throws IOException {
    String opt = ConfigOptions.getOptionKey(prefix, input);
    if (line.hasOption(opt)) {
      try {
        input.setValue(Integer.valueOf(line.getOptionValue(ConfigOptions.getOptionKey(prefix, input))));
      } catch (NumberFormatException ex) {
        errorMessage(input, "Input is not valid integer number");
        return false;
      }
    } else {
      input.setEmpty();
    }
    return true;
  }

  /**
   * Load long input from CLI option.
   *
   * @param prefix
   *          placed at the beginning of the CLI option key
   * @param input
   *          Input that we should read or edit
   * @param line
   *          CLI options container
   * @return
   * @throws IOException
   */
  private static boolean fillInputLong(String prefix, MLongInput input, CommandLine line) throws IOException {
    String opt = ConfigOptions.getOptionKey(prefix, input);
    if (line.hasOption(opt)) {
      try {
        input.setValue(Long.valueOf(line.getOptionValue(ConfigOptions.getOptionKey(prefix, input))));
      } catch (NumberFormatException ex) {
        errorMessage(input, "Input is not a valid long ");
        return false;
      }
    } else {
      input.setEmpty();
    }
    return true;
  }

  /**
   * Load string input from CLI option.
   *
   * @param prefix placed at the beginning of the CLI option key
   * @param input Input that we should read or edit
   * @param line CLI options container
   * @return
   * @throws IOException
   */
  public static boolean fillInputString(String prefix,
                                        MStringInput input,
                                        CommandLine line)
                                        throws IOException {
    String opt = ConfigOptions.getOptionKey(prefix, input);
    if (line.hasOption(opt)) {
      String value = line.getOptionValue(ConfigOptions.getOptionKey(prefix, input));
      if(value.length() > input.getMaxLength()) {
        errorMessage(input, "Size of input exceeds allowance for this input"
          + " field. Maximal allowed size is " + input.getMaxLength());
      }
      input.setValue(value);
    } else {
      input.setEmpty();
    }
    return true;
  }

  /**
   * Load boolean input from CLI option.
   *
   * @param prefix placed at the beginning of the CLI option key
   * @param input Input that we should read or edit
   * @param line CLI options container
   * @return
   * @throws IOException
   */
  public static boolean fillInputBoolean(String prefix,
                                         MBooleanInput input,
                                         CommandLine line)
                                         throws IOException {
    String opt = ConfigOptions.getOptionKey(prefix, input);
    if (line.hasOption(opt)) {
      input.setValue(Boolean.valueOf(line.getOptionValue(ConfigOptions.getOptionKey(prefix, input))));
    } else {
      input.setEmpty();
    }
    return true;
  }

  /**
   * Fill link object based on user input.
   *
   * @param reader Associated console reader object
   * @param link Link that user is suppose to fill in
   * @param linkConfigBundle Connector resource bundle
   * @return True if we filled all inputs, false if user has stopped processing
   * @throws IOException
   */
  public static boolean fillLinkWithBundle(ConsoleReader reader, MLink link, ResourceBundle linkConfigBundle)
      throws IOException {

    link.setName(getName(reader, link.getName()));
    return fillLinkConfigWithBundle(reader, link.getConnectorLinkConfig().getConfigs(), linkConfigBundle);
  }

  /**
   * Fill job object based on user input.
   *
   * @param reader Associated console reader object
   * @param job Job that user is suppose to fill in
   * @param fromConfigBundle Connector resource bundle
   * @param driverConfigBundle Driver config resource bundle
   * @return True if we filled all inputs, false if user has stopped processing
   * @throws IOException
   */
  public static boolean fillJobWithBundle(ConsoleReader reader,
                                MJob job,
                                ResourceBundle fromConfigBundle,
                                ResourceBundle toConfigBundle,
                                ResourceBundle driverConfigBundle)
                                throws IOException {

    job.setName(getName(reader, job.getName()));

    return fillJobConfigWithBundle(reader,
                     job.getFromJobConfig().getConfigs(),
                     fromConfigBundle,
                     job.getToJobConfig().getConfigs(),
                     toConfigBundle,
                     job.getDriverConfig().getConfigs(),
                     driverConfigBundle);
  }
  public static boolean fillLinkConfigWithBundle(ConsoleReader reader,
                                  List<MConfig> linkConfig,
                                  ResourceBundle linkConfigBundle) throws IOException {


    if(!fillConfigsWithBundle(linkConfig, reader, linkConfigBundle)) {
      return false;
    }
    return true;
  }

  public static boolean fillJobConfigWithBundle(ConsoleReader reader,
                                  List<MConfig> fromConfig,
                                  ResourceBundle fromConfigBundle,
                                  List<MConfig> toConfig,
                                  ResourceBundle toConfigBundle,
                                  List<MConfig> driverConfig,
                                  ResourceBundle driverConfigBundle) throws IOException {


    // Job From config
    if(!fillConfigsWithBundle(fromConfig, reader, fromConfigBundle)) {
      return false;
    }
    // Job To config
    if(!fillConfigsWithBundle(toConfig, reader, toConfigBundle)) {
      return false;
    }
    // Job Driver config
    if(!fillConfigsWithBundle(driverConfig, reader, driverConfigBundle)) {
      return false;
    }

    return true;
  }

  public static boolean fillConfigsWithBundle(List<MConfig> configs, ConsoleReader reader,
      ResourceBundle configBundle) throws IOException {
    for (MConfig config : configs) {
      if (!fillConfigWithBundle(config, reader, configBundle)) {
        return false;
      }
    }

    return true;
  }

  @SuppressWarnings("rawtypes")
  public static boolean fillConfigWithBundle(MConfig config, ConsoleReader reader, ResourceBundle bundle)
      throws IOException {
    println("");
    println(bundle.getString(config.getLabelKey()));

    // Print out config validation
    printValidationMessage(config, false);
    println("");

    for (MInput input : config.getInputs()) {
      if(!fillInputWithBundle(input, reader, bundle)) {
        return false;
      }
    }

    return true;
  }

  @SuppressWarnings("rawtypes")
  static boolean fillInputWithBundle(MInput input, ConsoleReader reader, ResourceBundle bundle)
      throws IOException {
    // Print out validation
    printValidationMessage(input, false);

    // Based on the input type, let's perconfig specific load
    switch (input.getType()) {
      case STRING:
        return fillInputStringWithBundle((MStringInput) input, reader, bundle);
      case INTEGER:
        return fillInputInteger((MIntegerInput) input, reader, bundle);
      case LONG:
        return fillInputLong((MLongInput) input, reader, bundle);
      case BOOLEAN:
        return fillInputBooleanWithBundle((MBooleanInput) input, reader, bundle);
      case MAP:
        return fillInputMapWithBundle((MMapInput) input, reader, bundle);
      case ENUM:
        return fillInputEnumWithBundle((MEnumInput) input, reader, bundle);
      default:
        println("Unsupported data type " + input.getType());
        return true;
    }
  }

  /**
   * Load user input for enum type.
   *
   * Print out numbered list of all available options and let user choose one
   * item from that.
   *
   * @param input Input that we should read or edit
   * @param reader Associated console reader
   * @param bundle Resource bundle
   * @return True if user with to continue with loading addtional inputs
   * @throws IOException
   */
  private static boolean fillInputEnumWithBundle(MEnumInput input,
                                       ConsoleReader reader,
                                       ResourceBundle bundle)
                                       throws IOException {
    // Prompt in enum case
    println(bundle.getString(input.getLabelKey()) + ": ");

    // Indexes
    int i = -1;
    int lastChoice = -1;

    // Print out all values as a numbered list
    for(String value : input.getValues()) {
      i++;

      println("  " + i  + " : " + value);

      // Only show last choice if not sensitive
      if(!input.isEmpty() && value.equals(input.getValue()) && !input.isSensitive()) {
        lastChoice = i;
      }
    }

    // Prompt
    reader.printString("Choose: ");

    // Fill previously filled index when available
    if(lastChoice != -1) {
      reader.putString(Integer.toString(lastChoice));
    }

    reader.flushConsole();
    String userTyped;
    if(input.isSensitive()) {
      userTyped = reader.readLine('*');
    } else {
      userTyped = reader.readLine();
    }

    if (userTyped == null) {
      return false;
    } else if (userTyped.isEmpty()) {
      input.setEmpty();
    } else {
      Integer index;
      try {
        index = Integer.valueOf(userTyped);

        if(index < 0 || index >= input.getValues().length) {
          errorMessage("Invalid index");
          return fillInputEnumWithBundle(input, reader, bundle);
        }

        input.setValue(input.getValues()[index]);
      } catch (NumberFormatException ex) {
        errorMessage("Input is not valid integer number");
        return fillInputEnumWithBundle(input, reader, bundle);
      }
    }

    return true;
  }

  /**
   * Load user input for map type.
   *
   * This implementation will load one map entry at the time. Current flows is
   * as follows: if user did not enter anything (empty input) finish loading
   * and return from function. If user specified input with equal sign (=),
   * lets add new key value pair. Otherwise consider entire input as a key name
   * and try to remove it from the map.
   *
   * Please note that following code do not supports equal sign in property
   * name. It's however perfectly fine to have equal sign in value.
   *
   * @param input Input that we should read or edit
   * @param reader Associated console reader
   * @param bundle Resource bundle
   * @return True if user wish to continue with loading additional inputs
   * @throws IOException
   */
  private static boolean fillInputMapWithBundle(MMapInput input,
                                      ConsoleReader reader,
                                      ResourceBundle bundle)
                                      throws IOException {
    // Special prompt in Map case
    println(bundle.getString(input.getLabelKey()) + ": ");

    // Internal loading map
    Map<String, String> values = input.getValue();
    if(values == null) {
      values = new HashMap<String, String>();
    }

    String userTyped;

    while(true) {
      // Print all current items in each iteration
      // However do not printout if this input contains sensitive information.
      println("There are currently " + values.size() + " values in the map:");
      if (!input.isSensitive()) {
        for(Map.Entry<String, String> entry : values.entrySet()) {
          println(entry.getKey() + " = " + entry.getValue());
        }
      }

      // Special prompt for Map entry
      reader.printString("entry# ");
      reader.flushConsole();

      if(input.isSensitive()) {
        userTyped = reader.readLine('*');
      } else {
        userTyped = reader.readLine();
      }

      if(userTyped == null) {
        // Finish loading and return back to Sqoop shell
        return false;
      } else if(userTyped.isEmpty()) {
        // User has finished loading data to Map input, either set input empty
        // if there are no entries or propagate entries to the input
        if(values.size() == 0) {
          input.setEmpty();
        } else {
          input.setValue(values);
        }
        return true;
      } else {
        // User has specified regular input, let's check if it contains equals
        // sign. Save new entry (or update existing one) if it does. Otherwise
        // try to remove entry that user specified.
        if(userTyped.contains("=")) {
          String []keyValue = userTyped.split("=", 2);
          values.put(handleUserInput(keyValue[0]), handleUserInput(keyValue[1]));
        } else {
          String key = handleUserInput(userTyped);
          if(values.containsKey(key)) {
            values.remove(key);
          } else {
            errorMessage("Don't know what to do with " + userTyped);
          }
        }
      }

    }
  }

  /**
   * Handle special cases in user input.
   *
   * Preserve null and empty values, remove whitespace characters before and
   * after loaded string and de-quote the string if it's quoted (to preserve
   * spaces for example).
   *
   * @param input String loaded from user
   * @return Unquoted transconfiged string
   */
  private static String handleUserInput(String input) {
    // Preserve null and empty values
    if(input == null) {
      return null;
    }
    if(input.isEmpty()) {
      return input;
    }

    // Removes empty characters at the begging and end of loaded string
    input = input.trim();

    int lastIndex = input.length() - 1;
    char first = input.charAt(0);
    char last = input.charAt(lastIndex);

    // Remove quoting if present
    if(first == '\'' && last == '\'') {
      input = input.substring(1, lastIndex);
    } else if(first == '"' && last == '"') {
      input =  input.substring(1, lastIndex);
    }

    // Return final string
    return input;
  }

  private static boolean fillInputInteger(MIntegerInput input,
                                          ConsoleReader reader,
                                          ResourceBundle bundle)
                                          throws IOException {
    generatePrompt(reader, bundle, input);

    // Fill already filled data when available
    // However do not printout if this input contains sensitive information.
    if(!input.isEmpty() && !input.isSensitive()) {
      reader.putString(input.getValue().toString());
    }

    // Get the data
    String userTyped;
    if(input.isSensitive()) {
      userTyped = reader.readLine('*');
    } else {
      userTyped = reader.readLine();
    }

    if (userTyped == null) {
      return false;
    } else if (userTyped.isEmpty()) {
      input.setEmpty();
    } else {
      Integer value;
      try {
        value = Integer.valueOf(userTyped);
        input.setValue(value);
      } catch (NumberFormatException ex) {
        errorMessage("Input is not valid integer number");
        return fillInputInteger(input, reader, bundle);
      }

      input.setValue(Integer.valueOf(userTyped));
    }

    return true;
  }

  private static boolean fillInputLong(MLongInput input, ConsoleReader reader, ResourceBundle bundle) throws IOException {
    generatePrompt(reader, bundle, input);

    if (!input.isEmpty() && !input.isSensitive()) {
      reader.putString(input.getValue().toString());
    }

    // Get the data
    String userTyped;
    if (input.isSensitive()) {
      userTyped = reader.readLine('*');
    } else {
      userTyped = reader.readLine();
    }

    if (userTyped == null) {
      return false;
    } else if (userTyped.isEmpty()) {
      input.setEmpty();
    } else {
      Long value;
      try {
        value = Long.valueOf(userTyped);
        input.setValue(value);
      } catch (NumberFormatException ex) {
        errorMessage("Input is not a valid long");
        return fillInputLong(input, reader, bundle);
      }

      input.setValue(Long.valueOf(userTyped));
    }

    return true;
  }

  /**
   * Load string input from the user.
   *
   * @param input Input that we should load in
   * @param reader Associated console reader
   * @param bundle Resource bundle for this input
   * @return
   * @throws IOException
   */
  static boolean fillInputStringWithBundle(MStringInput input,
                                        ConsoleReader reader,
                                        ResourceBundle bundle)
                                        throws IOException {
    generatePrompt(reader, bundle, input);

    // Fill already filled data when available
    // However do not printout if this input contains sensitive information.
    if(!input.isEmpty() && !input.isSensitive()) {
      reader.putString(input.getValue());
    }

    // Get the data
    String userTyped;
    if(input.isSensitive()) {
       userTyped = reader.readLine('*');
    } else {
      userTyped = reader.readLine();
    }

    if (userTyped == null) {
      // Propagate end of loading process
      return false;
    } else if (userTyped.isEmpty()) {
      // Empty input in case that nothing was given
      input.setEmpty();
    } else {
      // Set value that user has entered
      input.setValue(userTyped);

      // Check that it did not exceeds maximal allowance for given input
      if(userTyped.length() > input.getMaxLength()) {
        errorMessage("Size of input exceeds allowance for this input"
          + " field. Maximal allowed size is " + input.getMaxLength());
        return fillInputStringWithBundle(input, reader, bundle);
      }
    }

    return true;
  }

  /**
   * Load boolean input from the user.
   *
   * @param input Input that we should load in
   * @param reader Associated console reader
   * @param bundle Resource bundle for this input
   * @return
   * @throws IOException
   */
  static boolean fillInputBooleanWithBundle(MBooleanInput input,
                                         ConsoleReader reader,
                                         ResourceBundle bundle)
                                         throws IOException {
    generatePrompt(reader, bundle, input);

    // Fill already filled data when available
    // However do not printout if this input contains sensitive information.
    if(!input.isEmpty() && !input.isSensitive()) {
      reader.putString(input.getValue().toString());
    }

    // Get the data
    String userTyped;
    if(input.isSensitive()) {
       userTyped = reader.readLine('*');
    } else {
      userTyped = reader.readLine();
    }

    if (userTyped == null) {
      // Propagate end of loading process
      return false;
    } else if (userTyped.isEmpty()) {
      // Empty input in case that nothing was given
      input.setEmpty();
    } else {
      // Set value that user has entered
      input.setValue(Boolean.valueOf(userTyped));
    }

    return true;
  }

  @SuppressWarnings("rawtypes")
  static void generatePrompt(ConsoleReader reader, ResourceBundle bundle, MInput input)
      throws IOException {
    reader.printString(bundle.getString(input.getLabelKey()) + ": ");
    reader.flushConsole();
  }

  static String getName(ConsoleReader reader, String name) throws IOException {
    if (name == null) {
      nameInput.setEmpty();
    } else {
      nameInput.setValue(name);
    }

    fillInputStringWithBundle(nameInput, reader, getResourceBundle());

    return nameInput.getValue();
  }

  /**
   * Print validation message in cases that it's not in state "OK"
   *
   * @param element Validated element
   */
  static void printValidationMessage(MValidatedElement element, boolean includeInputPrefix) {
    if(element.getValidationStatus() == Status.getDefault()) {
      return;
    }

    for(Message message : element.getValidationMessages())
    switch (message.getStatus()) {
      case ERROR:
        if (includeInputPrefix) {
          errorMessage(element, message.getMessage());
        } else {
          errorMessage(message.getMessage());
        }
        break;
      case WARNING:
        if (includeInputPrefix) {
          warningMessage(element, message.getMessage());
        } else {
          warningMessage(message.getMessage());
        }
        break;
      default:
        // Simply ignore all other states for the moment
        break;
    }
  }

  static void errorMessage(String message) {
    println("Error message: @|red " + message + " |@");
  }

  static void errorMessage(MNamedElement input, String message) {
    print(input.getName());
    print(": ");
    errorMessage(message);
  }

  static void warningMessage(String message) {
    println("Warning message: @|yellow " + message + " |@");
  }

  static void warningMessage(MNamedElement input, String message) {
    print(input.getName());
    print(": ");
    warningMessage(message);
  }

  public static void errorIntroduction() {
    println("\n @|red There are issues with entered data, please revise your input:|@");
  }

  // link object has the connector link config
  public static void printLinkValidationMessages(MLink link) {
    for (MConfig config : link.getConnectorLinkConfig().getConfigs()) {
      for (MInput<?> input : config.getInputs()) {
        printValidationMessage(input, true);
      }
    }
  }

  // job has the from/to and the driver config
  public static void printJobValidationMessages(MJob job) {
    for (MConfig config : job.getFromJobConfig().getConfigs()) {
      for (MInput<?> input : config.getInputs()) {
        printValidationMessage(input, true);
      }
    }

    for (MConfig config : job.getToJobConfig().getConfigs()) {
      for (MInput<?> input : config.getInputs()) {
        printValidationMessage(input, true);
      }
    }

    for (MConfig config : job.getDriverConfig().getConfigs()) {
      for (MInput<?> input : config.getInputs()) {
        printValidationMessage(input, true);
      }
    }
  }

  private ConfigFiller() {
    // Do not instantiate
  }
}