/**
    * 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.commons.cli2.commandline;
  
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Properties;
  import java.util.Set;
  import java.util.StringTokenizer;
  
  import org.apache.commons.cli2.Option;
  import org.apache.commons.cli2.option.PropertyOption;
  
  /**
   * A CommandLine implementation using a java Properties instance, useful for
   * constructing a complex DefaultingCommandLine
   *
   * Options are keyed from their property name and presence in the Properties
   * instance is taken as presence in the CommandLine.  Argument values are taken
   * from the property value and are optionally separated using the separator
   * char, defined at construction time.  Switch values can be specified using a
   * simple value of <code>true</code> or <code>false</code>; obviously this means
   * that Switches with Arguments are not supported by this implementation.
   *
   * @see java.util.Properties
   * @see org.apache.commons.cli2.commandline.DefaultingCommandLine
   * @see org.apache.commons.cli2.Option#getPreferredName()
   */
  public class PropertiesCommandLine extends CommandLineImpl {
  
      private static final char NUL = '\0';
      private final Properties properties;
      private final Option root;
      private final char separator;
  
      /**
       * Creates a new PropertiesCommandLine using the specified root Option,
       * Properties instance.  The character 0 is used as the value separator.
       *
       * @param root the CommandLine's root Option
       * @param properties the Properties instance to get values from
       */
      public PropertiesCommandLine(final Option root, final Properties properties){
          this(root,properties,NUL);
      }
  
      /**
       * Creates a new PropertiesCommandLine using the specified root Option,
       * Properties instance and value separator.
       *
       * @param root the CommandLine's root Option
       * @param properties the Properties instance to get values from
       * @param separator the character to split argument values
       */
      public PropertiesCommandLine(final Option root, final Properties properties, final char separator){
          this.root = root;
          this.properties = properties;
          this.separator = separator;
      }
  
  
      public boolean hasOption(Option option) {
          if(option==null){
              return false;
          }
          else{
              return properties.containsKey(option.getPreferredName());
          }
      }
  
      public Option getOption(String trigger) {
          return root.findOption(trigger);
      }
  
      public List getValues(final Option option, final List defaultValues) {
          final String value = properties.getProperty(option.getPreferredName());
  
          if(value==null){
              return defaultValues;
          }
          else if(separator>NUL){
              final List values = new ArrayList();
             final StringTokenizer tokens = new StringTokenizer(value,String.valueOf(separator));
 
             while(tokens.hasMoreTokens()){
                 values.add(tokens.nextToken());
             }
 
             return values;
         }
         else{
             return Collections.singletonList(value);
         }
     }
 
     public Boolean getSwitch(final Option option, final Boolean defaultValue) {
         final String value = properties.getProperty(option.getPreferredName());
         if("true".equals(value)){
             return Boolean.TRUE;
         }
         else if("false".equals(value)){
             return Boolean.FALSE;
         }
         else{
             return defaultValue;
         }
     }
 
     public String getProperty(final String property) {
         return getProperty(new PropertyOption(), property);
     }
 
     public String getProperty(final Option option, final String property, final String defaultValue) {
         return properties.getProperty(property,defaultValue);
     }
 
 	public Set getProperties(final Option option) {
         return properties.keySet();
     }
 
     public Set getProperties() {
         return getProperties(new PropertyOption());
     }
 
     public List getOptions() {
         final List options = new ArrayList();
         final Iterator keys = properties.keySet().iterator();
         while(keys.hasNext()){
             final String trigger = (String)keys.next();
             final Option option = root.findOption(trigger);
             if(option!=null){
                 options.add(option);
             }
         }
         return Collections.unmodifiableList(options);
     }
 
     public Set getOptionTriggers() {
         final Set triggers = new HashSet();
         final Iterator options = getOptions().iterator();
         while(options.hasNext()){
             final Option option = (Option)options.next();
             triggers.addAll(option.getTriggers());
         }
         return Collections.unmodifiableSet(triggers);
     }
 }