/**
    * 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.Arrays;
  import java.util.Collections;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Set;
  import java.util.StringTokenizer;
  import java.util.prefs.BackingStoreException;
  import java.util.prefs.Preferences;
  
  import org.apache.commons.cli2.Option;
  import org.apache.commons.cli2.option.PropertyOption;
  
  /**
   * A CommandLine implementation using the Preferences API, useful when
   * constructing a complex DefaultingCommandLine
   *
   * This implementation uses the children of a single preference node to populate
   * the CommandLine.  Options are keyed from their preferred name and presence in
   * the Preferences object is taken as presence in the CommandLine.  Argument
   * values are taken from the Preference 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.prefs.Preferences
   * @see org.apache.commons.cli2.commandline.DefaultingCommandLine
   * @see org.apache.commons.cli2.Option#getPreferredName()
   */
  public class PreferencesCommandLine extends CommandLineImpl {
  
      private static final char NUL = '\0';
      private final Preferences preferences;
      private final Option root;
      private final char separator;
  
      /**
       * Creates a new PreferencesCommandLine using the specified root Option and
       * Preferences node.  Argument values will be separated using the char 0.
       *
       * @param root the CommandLine's root Option
       * @param preferences the Preferences node to get values from
       */
      public PreferencesCommandLine(final Option root, final Preferences preferences){
          this(root,preferences,NUL);
      }
  
      /**
       * Creates a new PreferencesCommandLine using the specified root Option,
       * Preferences node and value separator.
       *
       * @param root the CommandLine's root Option
       * @param preferences the Preferences node to get values from
       * @param separator the character to split argument values
       */
      public PreferencesCommandLine(final Option root, final Preferences preferences, final char separator){
          this.root = root;
          this.preferences = preferences;
          this.separator = separator;
      }
  
      public boolean hasOption(Option option) {
          if(option==null){
              return false;
          }
          else{
              try {
                  return Arrays.asList(preferences.keys()).contains(option.getPreferredName());
              } catch (BackingStoreException e) {
                  return false;
              }
          }
      }
  
      public Option getOption(String trigger) {
          return root.findOption(trigger);
      }
  
      public List getValues(final Option option, final List defaultValues) {
         final String value = preferences.get(option.getPreferredName(),null);
 
         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 = preferences.get(option.getPreferredName(),null);
         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 preferences.get(property, defaultValue);
     }
 
 	public Set getProperties(final Option option) {
         try {
             return new HashSet(Arrays.asList(preferences.keys()));
         } catch (BackingStoreException e) {
             return Collections.EMPTY_SET;
         }
     }
 
     public Set getProperties() {
         return getProperties(new PropertyOption());
     }
 
     public List getOptions() {
         try {
             final List options = new ArrayList();
             final Iterator keys = Arrays.asList(preferences.keys()).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);
         } catch (BackingStoreException e) {
             return Collections.EMPTY_LIST;
         }
     }
 
     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);
     }
 }