/*
    * $Id: Registry.java 125 2008-11-04 07:18:28Z arnep $
    */
   package net.sf.ovanttasks.ovnative.win32;
   
   import java.math.BigDecimal;
   import java.math.BigInteger;
   import java.util.ArrayList;
   import java.util.Iterator;
  import java.util.List;
  
  /**
   * Registry accesses the Windows Registry.
   * Read/write/test/create/delete are supported for both data and subtrees.
   * 
   * @author lars.gersmann@roxes.com
   * @author arnep@users.sf.net
   */
  public class Registry implements Iterable<Registry> {
  
      public class SubKeyIterator implements Iterator<Registry> {
  
          final private String[] keys;
          private int subKeyIndex = 0;
  
          public SubKeyIterator(String[] keys) {
              this.keys = keys;
          }
  
          public boolean hasNext() {
              return subKeyIndex < keys.length;
          }
  
          public Registry next() {
              return openSubKey(keys[subKeyIndex++]);
          }
  
          public void remove() {
              throw new UnsupportedOperationException();
          }
      }    // Key access rights
      public static final int KEY_QUERY_VALUE = 1;
      public static final int KEY_SET_VALUE = 2;
      public static final int KEY_CREATE_SUB_KEY = 4;
      public static final int KEY_ENUMERATE_SUB_KEYS = 8;
      public static final int KEY_NOTIFY = 16;
      public static final int KEY_CREATE_LINK = 32;
      public static final int KEY_WRITE = 0x20006;
      public static final int KEY_EXECUTE = 0x20019;
      public static final int KEY_READ = 0x20019;
      public static final int KEY_ALL_ACCESS = 0xf003f;
      public static final int HKEY_CLASSES_ROOT = 0x80000000;
      public static final int HKEY_CURRENT_USER = 0x80000001;
      public static final int HKEY_LOCAL_MACHINE = 0x80000002;
      public static final int HKEY_USERS = 0x80000003;
      public static final int HKEY_PERFORMANCE_DATA = 0x80000004;
      public static final int HKEY_PERFORMANCE_TEXT = 0x80000050;
      public static final int HKEY_PERFORMANCE_NLSTEXT = 0x80000060;
      public static final int HKEY_CURRENT_CONFIG = 0x80000005;
      public static final int HKEY_DYN_DATA = 0x80000006;
      /**
       * No value type
       */
      public static final int REG_NONE = 0;
      /**
       * Unicode null terminated string
       * 
       */
      public static final int REG_SZ = 1;
      /**
       * Unicode nul terminated string (with environment variable references)
       */
      public static final int REG_EXPAND_SZ = 2;
      /**
       * Free form binary
       */
      public static final int REG_BINARY = 3;
      /**
       * 32-bit number
       */
      public static final int REG_DWORD = 4;
      /**
       * 32-bit number (same as REG_DWORD)
       */
      public static final int REG_DWORD_LITTLE_ENDIAN = 4;
      /**
       * 32-bit number
       */
      public static final int REG_DWORD_BIG_ENDIAN = 5;
      /**
       * Symbolic Link (unicode)
       */
      public static final int REG_LINK = 6;
      /**
       * Multiple Unicode strings
       */
      public static final int REG_MULTI_SZ = 7;
      /**
       * Resource list in the resource mapped to struct _CM_RESOURCE_LIST from winddk.h
      * TODO implement
      */
     public static final int REG_RESOURCE_LIST = 8;
     /**
      * Resource list in the hardware description
      * TODO implement
      */
     public static final int REG_FULL_RESOURCE_DESCRIPTOR = 9;
     /** 64-bitnumber        
      * TODO implement
      */
     public static final int REG_RESOURCE_REQUIREMENTS_LIST = 10,  REG_QWORD = 11;
     /** 64-bit number (same as REG_QWORD)
      * TODO implement
      */
     public static final int REG_QWORD_LITTLE_ENDIAN = 11;
 
     // YES THIS exists in the registry !!
     // at least RegEdt32.exe (W2k) knows this 1448
     public static String getHKeyName(int hKey) {
         switch (hKey) {
             case HKEY_CLASSES_ROOT:
                 return "HKEY_CLASSES_ROOT";
             case HKEY_CURRENT_USER:
                 return "HKEY_CURRENT_USER";
             case HKEY_LOCAL_MACHINE:
                 return "HKEY_LOCAL_MACHINE";
             case HKEY_USERS:
                 return "HKEY_USERS";
             case HKEY_PERFORMANCE_DATA:
                 return "HKEY_PERFORMANCE_DATA";
             case HKEY_PERFORMANCE_TEXT:
                 return "HKEY_PERFORMANCE_TEXT";
             case HKEY_PERFORMANCE_NLSTEXT:
                 return "HKEY_PERFORMANCE_NLSTEXT";
             case HKEY_CURRENT_CONFIG:
                 return "HKEY_CURRENT_CONFIG";
             case HKEY_DYN_DATA:
                 return "HKEY_DYN_DATA";
             default:
                 throw new Win32Exception("hKey " + hKey + " is unknown.");
         }
     }
 
     public static String getValueTypeName(int valueType) {
         switch (valueType) {
             case REG_NONE:
                 return "REG_NONE";
             case REG_SZ:
                 return "REG_SZ";
             case REG_EXPAND_SZ:
                 return "REG_EXPAND_SZ";
             case REG_BINARY:
                 return "REG_BINARY";
             case REG_DWORD:
                 return "REG_DWORD";
             case REG_DWORD_BIG_ENDIAN:
                 return "REG_DWORD_BIG_ENDIAN";
             case REG_LINK:
                 return "REG_LINK";
             case REG_MULTI_SZ:
                 return "REG_MULTI_SZ";
             case REG_RESOURCE_LIST:
                 return "REG_RESOURCE_LIST";
             case REG_FULL_RESOURCE_DESCRIPTOR:
                 return "REG_FULL_RESOURCE_DESCRIPTOR";
             case REG_RESOURCE_REQUIREMENTS_LIST:
                 return "REG_RESOURCE_REQUIREMENTS_LIST";
             case REG_QWORD:
                 return "REG_QWORD";
             default:
                 throw new Win32Exception("valueType " + valueType + " is unknown.");
 
         }
     }
 
     public static int parseHKeyName(String name) {
         if (name.equals("HKEY_CLASSES_ROOT")) {
             return HKEY_CLASSES_ROOT;
         } else if (name.equals("HKEY_CURRENT_USER")) {
             return HKEY_CURRENT_USER;
         } else if (name.equals("HKEY_LOCAL_MACHINE")) {
             return HKEY_LOCAL_MACHINE;
         } else if (name.equals("HKEY_USERS")) {
             return HKEY_USERS;
         } else if (name.equals("HKEY_PERFORMANCE_DATA")) {
             return HKEY_PERFORMANCE_DATA;
         } else if (name.equals("HKEY_PERFORMANCE_TEXT")) {
             return HKEY_PERFORMANCE_TEXT;
         } else if (name.equals("HKEY_PERFORMANCE_NLSTEXT")) {
             return HKEY_PERFORMANCE_NLSTEXT;
         } else if (name.equals("HKEY_CURRENT_CONFIG")) {
             return HKEY_CURRENT_CONFIG;
         } else if (name.equals("HKEY_DYN_DATA")) {
             return HKEY_DYN_DATA;
         } else {
             throw new Win32Exception("Parsing hKey failed : hKey " + name + " is unknown.");
         }
     }
 
     public static int parseValueTypeName(String name) {
         if (name.equals("REG_NONE")) {
             return REG_NONE;
         } else if (name.equals("REG_SZ")) {
             return REG_SZ;
         } else if (name.equals("REG_EXPAND_SZ")) {
             return REG_EXPAND_SZ;
         } else if (name.equals("REG_BINARY")) {
             return REG_BINARY;
         } else if (name.equals("REG_DWORD")) {
             return REG_DWORD;
         } else if (name.equals("REG_DWORD_BIG_ENDIAN")) {
             return REG_DWORD_BIG_ENDIAN;
         } else if (name.equals("REG_DWORD_LITTLE_ENDIAN")) {
             return REG_DWORD_LITTLE_ENDIAN;
         } else if (name.equals("REG_MULTI_SZ")) {
             return REG_MULTI_SZ;
         } else if (name.equals("REG_RESOURCE_LIST")) {
             return REG_RESOURCE_LIST;
         } else if (name.equals("REG_FULL_RESOURCE_DESCRIPTOR")) {
             return REG_FULL_RESOURCE_DESCRIPTOR;
         } else if (name.equals("REG_RESOURCE_REQUIREMENTS_LIST")) {
             return REG_RESOURCE_REQUIREMENTS_LIST;
         } else if (name.equals("REG_QWORD")) {
             return REG_QWORD;
         } else if (name.equals("REG_QWORD_LITTLE_ENDIAN")) {
             return REG_QWORD_LITTLE_ENDIAN;
         } else {
             throw new Win32Exception("Parsing valueType failed : valueType " + name + " is unknown.");
         }
     }
     private final int hKey;
     private final String subKey;
 
     public Registry(int hKey) {
         OvNativeLibLoader.loadLib();
         this.hKey = hKey;
         this.subKey = "";
     }
 
     public Registry(int hKey, String subKey) {
         OvNativeLibLoader.loadLib();
         this.hKey = hKey;
         this.subKey = subKey;
     }
 
     public Registry(Registry reg, String subKey) {
         OvNativeLibLoader.loadLib();
         this.hKey = reg.hKey;
         this.subKey = reg.subKey.length() > 0
                 ? reg.subKey + "\\" + subKey
                 : subKey;
     }
 
     public void create() throws Win32Exception {
         create(subKey, hKey);
     }
 
     private native void create(String subKey, int hKey) throws Win32Exception;
 
     /**
      * Create a new subKey as child of this subKey.
      * 
      * @param subKeyName
      *            the name of the subkey to create
      * @return the new created registry object
      * @throws Win32Exception
      */
     public Registry createSubKey(String subKeyName) throws Win32Exception {
         Registry result = new Registry(getHKey(), getSubKey() + "\\" + subKeyName);
         result.create();
         return result;
     }
 
     public void delete() throws Win32Exception {
         delete(subKey, hKey);
     }
 
     private native void delete(String subKey, int hKey) throws Win32Exception;
 
     /**
      * Deletes the subKey if it exists
      * 
      * @param subKeyName
      */
     public void deleteSubKey(String subKeyName) {
         openSubKey(subKeyName).delete();
     }
 
     public void deleteValue(String name) throws Win32Exception {
         deleteValue(subKey, hKey, name);
     }
 
     private native void deleteValue(String subKey, int hKey, String name)
             throws Win32Exception;
 
     @Override
     public boolean equals(Object other) {
         if (other instanceof Registry) {
             Registry otherRegistry = (Registry) other;
             return (this.getHKey() == otherRegistry.getHKey()) && this.getSubKey().equals(otherRegistry.getSubKey());
         } else {
             return false;
         }
     }
 
     @Override
     public int hashCode() {
         int hash = 5;
         hash = 23 * hash + this.hKey;
         hash = 23 * hash + (this.subKey != null ? this.subKey.hashCode() : 0);
         return hash;
     }
 
     /*
      * Key might exists, but cant be opend for read
      *     @Deprecated Use canOpenWith(KEY_XXX)
      */
     @Deprecated
     public boolean exists() {
         return canOpenWith(KEY_READ);
     }
 
     private native boolean canOpenWith(String subKey, int hKey, int flags);
 
     public boolean canOpenWith(int flags) {
         return canOpenWith(subKey, hKey, flags);
     }
 
     public BigDecimal getBigDecimalValue(String name) {
         return new BigDecimal(getStringValue(name));
     }
 
     public BigInteger getBigIntegerValue(String name) {
         return new BigInteger(getStringValue(name));
     }
 
     public boolean getBooleanValue(String name) throws Win32Exception {
         return getREG_DWORD_Value(subKey, hKey, name) != 0;
     }
 
     public byte[] getByteArrayValue(String name) {
         return getREG_BINARY_Value(subKey, hKey, name);
     }
 
     public byte getByteValue(String name) {
         return (byte) getREG_DWORD_Value(subKey, hKey, name);
     }
 
     /**
      * internal storage format is Double.toString
      * 
      * @param name
      * @return
      */
     public double getDoubleValue(String name) {
         return Double.parseDouble(getStringValue(name));
     }
 
     public String getExpandableString(String name, boolean doExpand)
             throws Win32Exception {
         String value = getREG_X_SZ_Value(subKey, hKey, name, REG_EXPAND_SZ);
         if (doExpand) {
             return Win32.expandEnvironmentStrings(value);
         } else {
             return value;
         }
     }
 
     /**
      * internal storage format Float.toString
      * 
      * @param name
      * @return
      * @throws Win32Exception 
      */
     public float getFloatValue(String name) throws Win32Exception {
         return Float.parseFloat(getStringValue(name));
     }
 
     public int getHKey() {
         return hKey;
     }
 
     public int getIntValue(String name) {
         return getREG_DWORD_Value(subKey, hKey, name);
     }
 
     /**
      * internal storage format Long.toString
      * 
      * @param name
      * @return
      */
     public long getLongValue(String name) {
         return Long.parseLong(getStringValue(name));
     }
 
     private native byte[] getREG_BINARY_Value(String subKey, int hKey,
             String name);
 
     private native int getREG_DWORD_Value(String subKey, int hKey, String name);
 
     private native String getREG_X_SZ_Value(String subKey, int hKey,
             String name, int type);
 
     public short getShortValue(String name) {
         return (short) getREG_DWORD_Value(subKey, hKey, name);
     }
 
     /**
      * if it is an REG_EXPAND_SZ should it be expanded??
      * 
      * @param name
      * @return
      */
     public String getStringValue(String name) {
         return getREG_X_SZ_Value(subKey, hKey, name, REG_SZ);
     }
 
     public String[] getMultiStringValue(String name) {
         List<String> result = new ArrayList<String>();
         String s = getREG_X_SZ_Value(subKey, hKey, name, REG_MULTI_SZ);
         int oldPos = 0;
         for (int i = 0; i < s.length(); i++) {
             if (s.charAt(i) == (char) 0) {
                 result.add(s.substring(oldPos, i));
                 oldPos = i + 1;
             }
         }
         return result.toArray(new String[result.size()]);
     }
 
     public String getSubKey() {
         return subKey;
     }
 
     public int getValueType(String name) {
         return getValueType(subKey, hKey, name);
     }
 
     private native int getValueType(String subKey, int hKey, String name);
 
     public boolean hasSubKey(String name) {
         Registry reg = new Registry(this, name);
         return reg.exists();
     }
 
     public boolean hasSubKeys() throws Win32Exception {
         return hasSubKeys(subKey, hKey);
     }
 
     private native boolean hasSubKeys(String subKey, int hKey)
             throws Win32Exception;
 
     public boolean hasValue(String name) throws Win32Exception {
         return hasValue(subKey, hKey, name);
     }
 
     private native boolean hasValue(String subKey, int hKey, String name)
             throws Win32Exception;
 
     public boolean hasValues() throws Win32Exception {
         return hasValues(subKey, hKey);
     }
 
     private native boolean hasValues(String subKey, int hKey)
             throws Win32Exception;
 
     /**
      * Opens a child subKey of this subKey. You must check, if you can open the
      * key with {@link #canOpenWith(String, int, int)} and the appropirate flag
      * from the KEY_* constants. the Key might exists, but you have no right to
      * read the key.
      * 
      * @param subKeyName
      *            the name of the subkey to open
      * @return the opend registry object
      * @throws Win32Exception
      */
     public Registry openSubKey(String subKeyName) throws Win32Exception {
         Registry result = new Registry(getHKey(), getSubKey() + (getSubKey().length() > 0 ? "\\" : "") + subKeyName);
         return result;
     }
 
     public void setExpandableString(String name, String value)
             throws Win32Exception {
         setREG_X_SZ_Value(subKey, hKey, name, value, value.length(),
                 REG_EXPAND_SZ);
     }
 
     private native void setREG_BINARY_Value(String subKey, int hKey,
             String name, byte[] value) throws Win32Exception;
 
     private native void setREG_DWORD_Value(String subKey, int hKey,
             String name, int value) throws Win32Exception;
 
     private native void setREG_X_SZ_Value(String subKey, int hKey, String name,
             String value, int length, int type) throws Win32Exception;
 
     public void setValue(String name, BigDecimal value) {
         setValue(name, value.toString());
     }
 
     public void setValue(String name, BigInteger value) {
         setValue(name, value.toString());
     }
 
     public void setValue(String name, boolean value) throws Win32Exception {
         setREG_DWORD_Value(subKey, hKey, name, value ? 1 : 0);
     }
 
     public void setValue(String name, byte value) throws Win32Exception {
         setREG_DWORD_Value(subKey, hKey, name, value);
     }
 
     public void setValue(String name, byte[] value) throws Win32Exception {
         setREG_BINARY_Value(subKey, hKey, name, value);
     }
 
     public void setValue(String name, double value) throws Win32Exception {
         setValue(name, Double.toString(value));
     }
 
     public void setValue(String name, float value) throws Win32Exception {
         setValue(name, Float.toString(value));
     }
 
     public void setValue(String name, int value) throws Win32Exception {
         setREG_DWORD_Value(subKey, hKey, name, value);
     }
 
     public void setValue(String name, long value) throws Win32Exception {
         setValue(name, Long.toString(value));
     }
 
     public void setValue(String name, short value) throws Win32Exception {
         setREG_DWORD_Value(subKey, hKey, name, value);
     }
 
     public void setValue(String name, String value) throws Win32Exception {
         setREG_X_SZ_Value(subKey, hKey, name, value, value.length(), REG_SZ);
     }
 
     public void setValue(String name, String[] value) throws Win32Exception {
         StringBuffer sb = new StringBuffer();
         for (String s : value) {
             sb.append(s);
             sb.append((char) 0);
         }
         String nativeString = sb.toString();
         setREG_X_SZ_Value(subKey, hKey, name, nativeString, nativeString.length(), REG_MULTI_SZ);
     }
 
     public void setValue(String name, String value, int valueType)
             throws Win32Exception {
         switch (valueType) {
             case REG_NONE:
                 throw new Win32Exception(
                         "setValue valueType \"REG_NONE\" not supported");
             case REG_SZ:
                 setREG_X_SZ_Value(subKey, hKey, name, value, REG_SZ, valueType);
                 break;
             case REG_EXPAND_SZ:
                 setREG_X_SZ_Value(subKey, hKey, name, value, REG_SZ, valueType);
                 break;
             case REG_BINARY:
                 throw new Win32Exception(
                         "setValue valueType \"REG_LINK\" not supported");
             // TODO greater than 2^31 ???
             case REG_DWORD:
                 setREG_DWORD_Value(subKey, hKey, name, (int) Long.parseLong(value));
                 break;
             // case REG_DWORD_LITTLE_ENDIAN: setREG_DWORD_Value(subKey, hKey,
             // name, (int)Long.parseLong(value));
             // break;
             case REG_DWORD_BIG_ENDIAN:
                 setREG_DWORD_Value(subKey, hKey, name, (int) Long.parseLong(value));
                 break;
             case REG_LINK:
                 throw new Win32Exception(
                         "setValue valueType \"REG_LINK\" not supported");
             case REG_MULTI_SZ:
                 throw new Win32Exception(
                         "setValue valueType \"REG_MULTI_SZ\" not supported");
             case REG_RESOURCE_LIST:
                 throw new Win32Exception(
                         "setValue valueType \"REG_RESOURCE_LIST\" not supported");
             case REG_FULL_RESOURCE_DESCRIPTOR:
                 throw new Win32Exception(
                         "setValue valueType \"REG_FULL_RESOURCE_DESCRIPTOR\" not supported");
             case REG_RESOURCE_REQUIREMENTS_LIST:
                 throw new Win32Exception(
                         "setValue valueType \"REG_RESOURCE_REQUIREMENTS_LIST\" not supported");
             case REG_QWORD_LITTLE_ENDIAN:
                 throw new Win32Exception(
                         "setValue valueType \"REG_QWORD_LITTLE_ENDIAN\" not supported");
         }
     }
 
     public String[] subKeyNames() {
         return subKeys(subKey, hKey);
     }
 
     public Iterator<Registry> subKeys() {
         return new SubKeyIterator(subKeys(subKey, hKey));
     }
 
     private native String[] subKeys(String subKey, int hKey);
 
     @Override
     public String toString() {
         StringBuffer sb = new StringBuffer(getHKeyName(hKey));
 
         if (subKey.length() > 0) {
             sb.append('\\').append(subKey);
         }
         return sb.toString();
     }
 
     public String[] valueNames() {
         return valueNames(subKey, hKey);
     }
 
     private native String[] valueNames(String subKey, int hKey)
             throws Win32Exception;
 
     public Iterator<Registry> iterator() {
         return subKeys();
     }
 }