/*
 * IzPack - Copyright 2001-2008 Julien Ponge, All Rights Reserved.
 * 
 * http://izpack.org/
 * http://izpack.codehaus.org/
 * 
 * Copyright 2005 Klaus Bartz
 *
 * Licensed 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 com.coi.tools.os.win;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * System dependent helper for MS Windows registry handling. This class is only vaild on Windows. It
 * declares naitve methods which are implemented in COIOSHelper.dll. The native methods uses the
 * classes RegDataContainer and AccessControlList as in and output. Do not change the getter and
 * setter methods of them. Do not try to implement a get or setValueACL because it will be nonsense.
 * In the registry only keys have a ACL. not values.
 *
 * @author Klaus Bartz
 */
public class RegistryImpl implements MSWinConstants
{

    private static final String DEFAULT_PLACEHOLDER = "__#$&DEFAULT_PLACEHODER_VALUE#$?";

    private int currentRoot = HKEY_CURRENT_USER;

    private boolean logPrevSetValueFlag = true;

    private List logging = new ArrayList();

    private boolean doLogging = false;

    /**
     * Creates a new empty RegistryImpl object.
     */
    public RegistryImpl()
    {
        super();
    }

    /**
     * Returns current root.
     *
     * @return current root
     */
    public int getRoot()
    {
        return currentRoot;
    }

    /**
     * Sets the root id to the given value.
     *
     * @param i root id to be set
     */
    public void setRoot(int i)
    {
        currentRoot = i;
    }

    /**
     * Determines whether or not previous contents of registry values
     * will be logged by the 'setValue()' method.
     *
     * @return true if the previous contents of registry values will be
     * logged by the 'setValue()' method.
     */
    public boolean getLogPrevSetValueFlag()
    {
        return logPrevSetValueFlag;
    }

    /**
     * Sets up whether or not previous contents of registry values will
     * be logged by the 'setValue()' method.  When registry values are
     * overwritten by repeated installations, the desired behavior can
     * be to have the registry value removed rather than rewound to the
     * last-set contents (acheived via 'false').  If this method is not
     * called then the flag wll default to 'true'.
     *
     * @param flagVal true to have the previous contents of registry
     * values logged by the 'setValue()' method.
     */
    public void setLogPrevSetValueFlag(boolean flagVal)
    {
        logPrevSetValueFlag = flagVal;
    }

    /**
     * Returns the value of the given value name as RegDataContainer.
     *
     * @param key   key of the registry entry
     * @param value value name of the registry entry
     * @return the value of the given value name as RegDataContainer
     * @throws NativeLibException
     */
    public RegDataContainer getValue(String key, String value) throws NativeLibException
    {
        if (key == null)
        {
            key = "";
        }
        return (getValue(currentRoot, key, value));
    }

    /**
     * Returns the value of the given value name as Object. The real type depends to the type of the
     * value.
     *
     * @param key   key of the registry entry
     * @param value value name of the registry entry
     * @return the value of the given value name as RegDataContainer
     * @throws NativeLibException
     */
    public Object getValueAsObject(String key, String value) throws NativeLibException
    {
        if (key == null)
        {
            key = "";
        }
        return (getValue(currentRoot, key, value).getDataAsObject());
    }

    /**
     * Returns all sub keys under the given key which is under the current root.
     *
     * @param key key for which the sub keys should be detected
     * @return all sub keys under the given key which is under the current root
     * @throws NativeLibException
     */
    public String[] getSubkeys(String key) throws NativeLibException
    {
        if (key == null)
        {
            key = "";
        }
        return (getSubkeyNames(currentRoot, key));
    }

    /**
     * Returns all value names under the given key which is under the current root.
     *
     * @param key key for which the values should be detected
     * @return all value names under the given key which is under the current root
     * @throws NativeLibException
     */
    public String[] getValueNames(String key) throws NativeLibException
    {
        if (key == null)
        {
            key = "";
        }
        return (getValueNames(currentRoot, key));
    }

    /**
     * Creates the given key under the current root.
     *
     * @param key key to be created
     * @throws NativeLibException
     */
    public void createKey(String key) throws NativeLibException
    {
        createKey(currentRoot, key);
    }

    /**
     * Creates the given key under the given root.
     * It is possible to declare keys without a sub path.
     * This is only possible on roots which are no real roots
     * (e.g. HKEY_CURRENT_USER which is a link to
     * HKEY_USERS\GUID of current user). Therefore this method
     * will be raise an exception if root is a real root and
     * key contains no sub path.
     *
     * @param root to be used
     * @param key  key to be created
     * @throws NativeLibException
     */
    public void createKey(int root, String key) throws NativeLibException
    {
        int pathEnd = key.lastIndexOf('\\');
        if (pathEnd > 0)
        {
            String subkey = key.substring(0, pathEnd);
            if (!exist(root, subkey))
            { // Create missing sub keys
                createKey(root, subkey);
            }
        }
        // Create key
        createKeyN(root, key);
        RegistryLogItem rli = new RegistryLogItem(RegistryLogItem.CREATED_KEY, root, key, null,
                null, null);
        log(rli);

    }

    /**
     * Returns whether the given key under the current root exist or not.
     *
     * @param key key to be tested
     * @return true if thekey exist, else false
     * @throws NativeLibException
     */
    public boolean keyExist(String key) throws NativeLibException
    {
        return (keyExist(currentRoot, key));
    }

    /**
     * Returns whether the given key under the given root exist or not.
     *
     * @param root to be used
     * @param key  key to be tested
     * @return true if thekey exist, else false
     * @throws NativeLibException
     */
    public boolean keyExist(int root, String key) throws NativeLibException
    {
        try
        {
            return (exist(root, key));
        }
        catch (NativeLibException ne)
        {
            String em = ne.getLibMessage();
            if ("functionFailed.RegOpenKeyEx".equals(em))
            {
                return (false);
            }
            throw (ne);
        }
    }

    /**
     * Returns whether the given value exist under the current root or not.
     *
     * @param key   key of the value for which should be tested
     * @param value value to be tested
     * @return true if the value exist, else false
     * @throws NativeLibException
     */
    public boolean valueExist(String key, String value) throws NativeLibException
    {
        if (key == null)
        {
            key = "";
        }
        try
        {
            this.getValue(currentRoot, key, value);
        }
        catch (NativeLibException ne)
        {
            String em = ne.getLibMessage();
            if ("functionFailed.RegOpenKeyEx".equals(em)
                    || "functionFailed.RegQueryValueEx".equals(em))
            {
                return (false);
            }
            throw (ne);
        }
        return (true);
    }

    /**
     * Sets the given contents to the given registry value. If a sub key or the registry value does
     * not exist, it will be created. REG_SZ is used as registry value type.
     *
     * @param key      the registry key which should be used or created
     * @param value    the registry value into which the contents should be set
     * @param contents the contents for the value
     * @throws NativeLibException
     */
    public void setValue(String key, String value, String contents) throws NativeLibException
    {

        setValue(currentRoot, key, value, new RegDataContainer(contents));
    }

    /**
     * Sets the given contents to the given registry value. If a sub key or the registry value does
     * not exist, it will be created. REG_MULTI_SZ is used as registry value type.
     *
     * @param key      the registry key which should be used or created
     * @param value    the registry value into which the contents should be set
     * @param contents the contents for the value
     * @throws NativeLibException
     */
    public void setValue(String key, String value, String[] contents) throws NativeLibException
    {

        setValue(currentRoot, key, value, new RegDataContainer(contents));
    }

    /**
     * Sets the given contents to the given registry value. If a sub key or the registry value does
     * not exist, it will be created. REG_BINARY is used as registry value type.
     *
     * @param key      the registry key which should be used or created
     * @param value    the registry value into which the contents should be set
     * @param contents the contents for the value
     * @throws NativeLibException
     */
    public void setValue(String key, String value, byte[] contents) throws NativeLibException
    {

        setValue(currentRoot, key, value, new RegDataContainer(contents));
    }

    /**
     * Sets the given contents to the given registry value. If a sub key or the registry value does
     * not exist, it will be created. REG_DWORD is used as registry value type.
     *
     * @param key      the registry key which should be used or created
     * @param value    the registry value into which the contents should be set
     * @param contents the contents for the value
     * @throws NativeLibException
     */
    public void setValue(String key, String value, long contents) throws NativeLibException
    {
        setValue(currentRoot, key, value, new RegDataContainer(contents));
    }

    /**
     * Sets the given contents to the given registry value under current root. If a sub key or the
     * registry value does not exist, it will be created. The used registry value type will be
     * determined by the type of the RegDataContainer.
     *
     * @param key      the registry key which should be used or created
     * @param value    the registry value into which the contents should be set
     * @param contents the contents for the value
     * @throws NativeLibException
     */
    public void setValue(String key, String value, RegDataContainer contents)
            throws NativeLibException
    {
        setValue(currentRoot, key, value, contents);
    }

    /**
     * Sets the given contents to the given registry value. If a sub key or the registry value does
     * not exist, it will be created. The used registry value type will be determined by the type of
     * the RegDataContainer.
     *
     * @param root     id for the root of the key
     * @param key      the registry key which should be used or created
     * @param value    the registry value into which the contents should be set
     * @param contents the contents for the value
     * @throws NativeLibException
     */
    public void setValue(int root, String key, String value, RegDataContainer contents)
            throws NativeLibException
    {
        RegDataContainer oldContents = null;
        String localValue = value;
        if (key == null)
        {
            key = "";
        }
        if (value == null)   // We allow it for the default value...
        {
            value = "";
        }
        // May be someone do not like backslashes ...
        key = key.replace('/', '\\');

        synchronized (logging)
        {
            if (!logPrevSetValueFlag)
            {  //flag not set; don't log previous contents
                setValueR(root, key, value, contents);
                return;
            }
            try
            {
                oldContents = getValue(currentRoot, key, value);
            }
            catch (NativeLibException ne)
            {
                String em = ne.getLibMessage();
                if ("functionFailed.RegOpenKeyEx".equals(em)
                        || "functionFailed.RegQueryValueEx".equals(em))
                {
                    setValueR(root, key, value, contents);
                    return;
                }
                throw (ne);
            }
            setValueN(root, key, value, contents);
            // Add value changing to log list
            if (value.length() == 0) // The default value ...
            {
                localValue = DEFAULT_PLACEHOLDER; // Rewind will fail if last
            }
            // token is
            // empty.

            RegistryLogItem rli = new RegistryLogItem(RegistryLogItem.CHANGED_VALUE, root, key,
                    localValue, contents, oldContents);
            log(rli);
        }
    }

    /**
     * Deletes a key under the current root if exist and it is empty, else throw an exception.
     *
     * @param key key to be deleted
     * @throws NativeLibException
     */
    public void deleteKey(String key) throws NativeLibException
    {
        deleteKeyL(currentRoot, key);
    }

    /**
     * Deletes a key under the current root if it is empty, else do nothing.
     *
     * @param key key to be deleted
     * @throws NativeLibException
     */
    public void deleteKeyIfEmpty(String key) throws NativeLibException
    {
        deleteKeyIfEmpty(currentRoot, key);
    }

    /**
     * Deletes a key if it is empty, else do nothing.
     *
     * @param root id for the root of the key
     * @param key  key to be deleted
     * @throws NativeLibException
     */
    public void deleteKeyIfEmpty(int root, String key) throws NativeLibException
    {
        if (keyExist(root, key) && isKeyEmpty(root, key))
        {
            deleteKeyL(root, key);
        }

    }

    /**
     * Deletes a value.
     *
     * @param key   key of the value which should be deleted
     * @param value value name to be deleted
     * @throws NativeLibException
     */
    public void deleteValue(String key, String value) throws NativeLibException
    {
        deleteValueL(currentRoot, key, value);
    }

    /**
     * Deletes a key with logging.
     *
     * @param root id for the root of the key
     * @param key  key to be deleted
     * @throws NativeLibException
     */
    private void deleteKeyL(int root, String key) throws NativeLibException
    {
        RegistryLogItem rli = new RegistryLogItem(RegistryLogItem.REMOVED_KEY, root, key, null,
                null, null);
        log(rli);
        deleteKeyN(root, key);
    }

    /**
     * Deletes a value with logging.
     *
     * @param root  id for the root of the key
     * @param key   key of the value which should be deleted
     * @param value value name to be deleted
     * @throws NativeLibException
     */
    private void deleteValueL(int root, String key, String value) throws NativeLibException
    {
        if (key == null)
        {
            key = "";
        }
        RegDataContainer oldContents = getValue(currentRoot, key, value);
        RegistryLogItem rli = new RegistryLogItem(RegistryLogItem.REMOVED_VALUE, root, key, value,
                null, oldContents);
        log(rli);
        deleteValueN(currentRoot, key, value);
    }

    /**
     * Rewinds all logged actions.
     *
     * @throws IllegalArgumentException
     * @throws NativeLibException
     */
    public void rewind() throws IllegalArgumentException, NativeLibException
    {
        synchronized (logging)
        {
            Iterator iter = logging.iterator();
            suspendLogging();

            while (iter.hasNext())
            {
                RegistryLogItem rli = (RegistryLogItem) iter.next();
                String rliValueName = (DEFAULT_PLACEHOLDER.equals(rli.getValueName())) ? "" : rli
                        .getValueName();
                switch (rli.getType())
                {
                    case RegistryLogItem.CREATED_KEY:
                        deleteKeyIfEmpty(rli.getRoot(), rli.getKey());
                        break;
                    case RegistryLogItem.REMOVED_KEY:
                        createKeyN(rli.getRoot(), rli.getKey());
                        break;
                    case RegistryLogItem.CREATED_VALUE:
                        RegDataContainer currentContents = null;
                        // Delete value only if reg entry exists and is equal to the stored value.
                        try
                        {
                            currentContents = getValue(rli.getRoot(), rli.getKey(), rliValueName);
                        }
                        catch (NativeLibException nle)
                        {
                            break;
                        }
                        if (currentContents.equals(rli.getNewValue()))
                        {
                            deleteValueN(rli.getRoot(), rli.getKey(), rliValueName);
                        }
                        // TODO: what todo if value has changed?
                        break;
                    case RegistryLogItem.REMOVED_VALUE:
                        // Set old value only if reg entry not exists.
                        try
                        {
                            getValue(rli.getRoot(), rli.getKey(), rliValueName);
                        }
                        catch (NativeLibException nle)
                        {
                            setValueN(rli.getRoot(), rli.getKey(), rliValueName, rli
                                    .getOldValue());
                        }
                        break;
                    case RegistryLogItem.CHANGED_VALUE:
                        // Change to old value only if reg entry exists and equal to
                        // the
                        // stored value.
                        try
                        {
                            currentContents = getValue(rli.getRoot(), rli.getKey(), rliValueName);
                        }
                        catch (NativeLibException nle)
                        {
                            break;
                        }
                        if (currentContents.equals(rli.getNewValue()))
                        {
                            setValueN(rli.getRoot(), rli.getKey(), rliValueName, rli
                                    .getOldValue());
                        }
                        break;
                }
            }
        }

    }

    /**
     * Sets the given contents to the given registry value. If a sub key or the registry value does
     * not exist, it will be created. The used registry value type will be determined by the type of
     * the RegDataContainer.
     *
     * @param root     id for the root of the key
     * @param key      the registry key which should be used or created
     * @param value    the registry value into which the contents should be set
     * @param contents the contents for the value
     * @throws NativeLibException
     */
    private void setValueR(int root, String key, String value, RegDataContainer contents)
            throws NativeLibException
    {
        String localValue = value;
        if (!exist(root, key))
        { // Create missing sub keys
            createKey(root, key);
        }
        // Create value
        setValueN(root, key, value, contents);
        // Add value creation to log list
        if (value.length() == 0) // The default value ...
        {
            localValue = DEFAULT_PLACEHOLDER; // Rewind will fail if last token
        }
        // is
        // empty.
        StringBuffer sb = new StringBuffer();
        sb.append("SetValue;").append(Integer.toString(root)).append(";").append(key).append(";")
                .append(localValue);
        RegistryLogItem rli = new RegistryLogItem(RegistryLogItem.CREATED_VALUE, root, key,
                localValue, contents, null);
        log(rli);
    }

    private native boolean exist(int root, String key) throws NativeLibException;

    private native void createKeyN(int root, String key) throws NativeLibException;

    private native void setValueN(int root, String key, String value, RegDataContainer contents)
            throws NativeLibException;

    private native RegDataContainer getValue(int root, String key, String value)
            throws NativeLibException;

    private native void deleteValueN(int root, String key, String value) throws NativeLibException;

    private native void deleteKeyN(int root, String key) throws NativeLibException;

    private native boolean isKeyEmpty(int root, String key) throws NativeLibException;

    private native String[] getSubkeyNames(int root, String key) throws NativeLibException;

    private native String[] getValueNames(int root, String key) throws NativeLibException;

    // Methods which are implemented in the native part but not used yet. To suppress warnings
    // in Eclipse this methods are commented out. Comment in if needed.
    // private native int getValueType(int root, String key, String value) throws
    // NativeLibException;
    //
    // private native int getSubkeyCount(int root, String key) throws NativeLibException;
    //
    // private native int getValueCount(int root, String key) throws NativeLibException;
    //
    // private native String getSubkeyName(int root, String key, int index) throws
    // NativeLibException;
    //
    // private native String getValueName(int root, String key, int index) throws
    // NativeLibException;
    //
    // private native void modifyKeyACL(int root, String key, AccessControlList acl)
    // throws NativeLibException;
    //
    // private native AccessControlList getKeyACL(int root, String key) throws NativeLibException;

    /**
     * Creates a new (empty) logging list and activates logging.
     */
    public void resetLogging()
    {
        logging = new ArrayList();
        activateLogging();
    }

    /**
     * Suspends logging.
     */
    public void suspendLogging()
    {
        doLogging = false;
    }

    /**
     * Activates logging.
     */
    public void activateLogging()
    {
        doLogging = true;
    }

    /**
     * Returns a copy of the colected logging informations.
     *
     * @return a copy of the colected logging informations
     */
    public List<Object> getLoggingInfo()
    {
        ArrayList<Object> retval = new ArrayList<Object>(logging.size());
        Iterator iter = logging.iterator();
        while (iter.hasNext())
        {
            try
            {
                retval.add(((RegistryLogItem) iter.next()).clone());
            }
            catch (CloneNotSupportedException e)
            { // Should never be...
                e.printStackTrace();
            }
        }
        return (retval);
    }

    /**
     * Copies the contents of the given list of RegistryLogItems to a newly created internal logging
     * list.
     *
     * @param info list containing RegistryLogItems to be used for logging
     */
    public void setLoggingInfo(List info)
    {
        resetLogging();
        addLoggingInfo(info);
    }

    /**
     * Adds copies of the contents of the given list of RegistryLogItems to the existent internal
     *
     * @param info list containing RegistryLogItems to be used for logging logging list.
     */
    public void addLoggingInfo(List info)
    {
        Iterator iter = info.iterator();
        while (iter.hasNext())
        {
            try
            {
                logging.add(((RegistryLogItem) iter.next()).clone());
            }
            catch (CloneNotSupportedException e)
            { // Should never be
                e.printStackTrace();
            }
        }

    }

    /**
     * Adds the given item to the beginning of the logging list if logging is enabled, else do
     * nothing.
     *
     * @param item
     */
    private void log(RegistryLogItem item)
    {
        if (doLogging && logging != null)
        {
            logging.add(0, item);
        }
    }

}
