"""
Windows registry support.

openKey( keyname ) 
    open existing key object

>>> key=openKey( r"HKLM\HARDWARE\DESCRIPTION\System" )

createKey( keyname ) 
    create a key if it doesn't already exist

>>> key=createKey( r"HKLM\SOFTWARE\Python\Test" )

deleteKey( keyname ) 
    delete a key if it exists
    Note: deleteKey may not be recursive on all platforms.

>>> key=createKey( r"HKLM\SOFTWARE\Python\Test" )

RemoteKey( machine, top_level_key ): 
    open a key on another machine.
    You can use the returned key as a basis for opens, creates and deletes
    on the other machine.

>>> key=RemoteKey( "somemachine", "HKLM" )

For information on the key API, open a key and look at its docstring.


"""

import _winreg
import sys
import exceptions
import array
from types import *
import string

class RegType:
    "Represents one of the types that can go into the registry"
    def __init__( self, msname, friendlyname ):
        self.msname=msname
        self.friendlyname=friendlyname
        self.intval=getattr( _winreg, msname )

    def __repr__( self ):
        "Return a useful representation of the type object"
        return "<RegType %d: %s %s>" % \
                        (self.intval, self.msname, self.friendlyname )

_typeConstants={ 
    _winreg.REG_NONE: 
        RegType( "REG_NONE", "None" ),
    _winreg.REG_SZ: 
        RegType( "REG_SZ", "String" ),
    _winreg.REG_EXPAND_SZ: 
        RegType("REG_EXPAND_SZ", "Expandable Template String" ),
    _winreg.REG_BINARY: 
        RegType("REG_BINARY", "Binary Data"),
    _winreg.REG_DWORD : 
        RegType("REG_DWORD", "Integer" ),
#    _winreg.REG_DWORD_LITTLE_ENDIAN : 
#        RegType("REG_DWORD_LITTLE_ENDIAN", "Integer"),
    _winreg.REG_DWORD_BIG_ENDIAN : 
        RegType("REG_DWORD_BIG_ENDIAN", "Big Endian Integer"),
    _winreg.REG_LINK : 
        RegType("REG_LINK", "Link"),
    _winreg.REG_MULTI_SZ : 
        RegType("REG_MULTI_SZ", "List of Strings"),
    _winreg.REG_RESOURCE_LIST : 
        RegType("REG_RESOURCE_LIST", "Resource List"),
    _winreg.REG_FULL_RESOURCE_DESCRIPTOR : 
        RegType( "REG_FULL_RESOURCE_DESCRIPTOR", 
                                            "Full Resource Descriptor" ),
    _winreg.REG_RESOURCE_REQUIREMENTS_LIST: 
        RegType( "REG_RESOURCE_REQUIREMENTS_LIST", 
                                            "Resource Requirements List" )
}

regtypes={}
for constant in _typeConstants.values():
    regtypes[constant.msname]=constant

class _DictBase:
    "Base class for dictionary-type objects"
    def __init__( self, key ):
        self.key=key

    def clear( self ):
        "Clear the list of keys/data values, as in dictionaries"
        keys=list( self.keys() )
        map( self.__delitem__, keys )

    def get( self, item, defaultVal=None ):
        "Get a key/value by name or index"
        try:
            return self.__getitem__( item )
        except (IndexError, EnvironmentError, WindowsError):
            return defaultVal

    def has_key( self, item ):
        "Check if a key/data value with a particular name exists"
        try:
            self.__getitem__( item )
            return 1
        except (IndexError, EnvironmentError, WindowsError):
            return 0

    def keys( self ):
        "Get a list of key/data value names"
        keys=[] 
        try:
            for i in xrange( 0, sys.maxint ):
                keyname = self._nameFromNum( i  )
                keys.append( keyname )
        except (IndexError, EnvironmentError, WindowsError):
            pass
        return keys

    def values( self ):
        "Get a list of key objects or data values"
        values=[]  # map() doesn't use the IndexError semantics...
        for i in self:
            values.append( i )
        return values

    def items( self ):
        "Get pairs of keyname/key object or valuename/value data"
        return map( None, self.keys(), self.values() )

    def __len__( self ):
        return len( self.keys() )

def _getName( item, nameFromNum ):
    "Helper function -- don't use it directly"
    if type( item ) == IntType:
        try:
            keyname = nameFromNum( item )
        except (WindowsError, EnvironmentError):
            raise IndexError, item

    elif type( item )==StringType: 
        keyname=item
    else:
        raise exceptions.TypeError, \
                "Requires integer index or string key name" 
    return keyname


class RegValuesDict( _DictBase ):
    "A dictionary of registry data values"
    def _nameFromNum( self, i ):
        return self.key._nameFromNum( i )

    def __getitem__( self, item ):
        return self.key.getValueNameDataAndType( item )

    def __setitem__( self, name, val):
        if type( val )==TupleType:
            data, datatype=val
            assert isinstance( datatype, RegType )
            self.key.setValue( name, data, datatype )
        else:
            self.key.setValue( name, val )

    def __delitem__( self, item ):
        valname=_getName( item, self._nameFromNum )
        self.key.deleteValue( valname )
    
class RegKeysDict( _DictBase ):
    "A dictionary of registry keys"
    def _nameFromNum( self, item ):
        return _winreg.EnumKey( self.key.handle, item )

    def __getitem__( self, item ):
        keyname=_getName( item, self._nameFromNum )
        return self.key.openSubkey( keyname )

    def __delitem__( self, item ):
        keyname=_getName( item, self._nameFromNum )
        self.key.deleteSubkey( keyname )

def openKey( keyname, samFlags=None ):
    "Open a key by name"
    lst=string.split( keyname, "\\", 1 )
    if len( lst )==2:
        hivename,path=lst
        return hives[hivename].openSubkey( path )
    else:
        hivename=lst[0]
        return hives[hivename]

def createKey( keyname ):
    lst=string.split( keyname, "\\", 1 )
    assert len( lst )==2
    hivename,path=lst
    return hives[hivename].createSubkey( path )

def deleteKey( keyname ):
    lst=string.split( keyname, "\\", 1 )
    assert len( lst )==2
    hivename,path=lst
    return hives[hivename].deleteSubkey( path )


class RegKey:
    "A registry key object"

    def __init__( self, name, handle=None ):
        self.name=name
        self.handle=handle

    def _nameFromNum( self, item ):
        "internal"
        (name,data,datatype)=_winreg.EnumValue( self.handle, item )
        return name

    def __nonzero__(self):
        "Is the key open?"
        if self.handle:
            return 1
        else:
            return 0

    def __cmp__ (self, other ):
        "Compare two keys for equality"
        if hasattr( other, "handle" ) and hasattr( other, "name" ):
            return cmp( self.name, other.name )
        else:
            return cmp( self.handle, other )

    def __repr__( self ):
        return "<Windows RegKey: %s>"% self.name

    def close(self ):
        "Close the key"
        return _winreg.CloseKey( self.handle )

    def getSubkeyNames( self ):
        "Get a list of subkey names"
        return self.getSubkeys().keys()

    def getValueNames( self ):
        "Get a list of value names"
        return self.getValues().keys()

    def deleteSubkey( self, subkey ):
        "Delete a subkey by name"
        return _winreg.DeleteKey( self.handle, subkey )
        
    def deleteValue( self, valname ):
        "Delete a value by name"
        return _winreg.DeleteValue( self.handle, valname )

    def createSubkey( self, keyname ):
        "Create a subkey by name"
        handle=_winreg.CreateKey( self.handle, keyname )
        return RegKey( self.name+"\\"+keyname, handle)

    def openSubkey( self, keyname, samFlags=None ):
        "Open a named subkey"
        if samFlags:
            handle=_winreg.OpenKey( self.handle, keyname, 0, samFlags )
        else:
            handle=_winreg.OpenKey( self.handle, keyname, 0 )
        return RegKey( self.name+"\\"+keyname, handle )

    def getSubkeys( self ):
        "Get a dictionary-like mapping of subkeys"
        return RegKeysDict( self )

    def getValues( self ):
        "Get a dictionary-like mapping of data values"
        return RegValuesDict( self )

    def getValueNameDataAndType( self, valname ):
        "Get a data value's name, data and type all at one time"
        try:
            if type( valname )==IntType:
                (valname,data,datatype)=_winreg.EnumValue( self.handle, valname )
            else:
                keyname=_getName( valname, self._nameFromNum )
                (data,datatype)=_winreg.QueryValueEx( self.handle, keyname )
        except (WindowsError, EnvironmentError):
            raise IndexError, valname

        if datatype==_winreg.REG_BINARY:
            # use arrays for binary data
            data=array.array( 'c', data )

        return (valname, data, _typeConstants[datatype] )

    def getValueData( self, valname ):
        "Get a data value's data."
        name, data, type=self.getValueNameDataAndType( valname )
        return data

    def setValue( self, valname, data, regtype=None ):
        "Set a data value's data (and optionally type)"
        if regtype:
            typeint=regtype.intval
        else:
            if type( data )==StringType:
                typeint=_winreg.REG_SZ
            elif type( data )==IntType:
                typeint=_winreg.REG_DWORD
            elif type( data )==array.ArrayType:
                typeint=_winreg.REG_BINARY
                data=data.tostring()
        _winreg.SetValueEx( self.handle, valname, 0, typeint, data )

    def flush(self ):
        "Make sure that all changes are written to the registry. "
        "Only use this if you know what you are doing. "
        "It isn't usually needed."
        _winreg.FlushKey( self.keyobbj )

    def save( self, filename ):
        "Save a key to a filename"
        _winreg.SaveKey( self.keyobj, filename )

    def load( self, subkey, filename ):
        "Load a key from a filename"
        return _winreg.RegLoadKey( self.handle, subkey, filename )


class RemoteKey( RegKey ):
    "Open a key on a remote machine"
    def __init__( self, machine, topLevelKey ):
        assert topLevelKey in _hivenames 
        self.handle =  _winreg.ConnectRegistry( machine, parentKey )
        self.name=r"\\%s\%s" % (machine, topLevelKey )

_hivenames = ["HKEY_CLASSES_ROOT","HKEY_CURRENT_USER","HKEY_LOCAL_MACHINE",
                "HKEY_USERS","HKEY_CURRENT_CONFIG","HKEY_DYN_DATA",
                "HKEY_PERFORMANCE_DATA"]
hives={}
for name in _hivenames:
    hives[name]=RegKey( name, getattr( _winreg, name ) )
hives["HKLM"]=hives["HKEY_LOCAL_MACHINE"]
hives["HKCR"]=hives["HKEY_CLASSES_ROOT"]
hives["HKCU"]=hives["HKEY_CURRENT_USER"]

_flagnames = ["KEY_ALL_ACCESS","KEY_CREATE_LINK", "KEY_CREATE_SUB_KEY",
             "KEY_ENUMERATE_SUB_KEYS", "KEY_EXECUTE", "KEY_NOTIFY", 
             "KEY_QUERY_VALUE", "KEY_READ", "KEY_SET_VALUE"]
flags={}
for name in _flagnames:
    flags[name]=getattr( _winreg, name )

_RegNotifyChangeKeyValueOptions=[ "REG_NOTIFY_CHANGE_ATTRIBUTES",
            "REG_NOTIFY_CHANGE_SECURITY", "REG_NOTIFY_CHANGE_LAST_SET",
            "REG_NOTIFY_CHANGE_NAME", "REG_LEGAL_CHANGE_FILTER" ]

_RegRestoreKeyOptions=["REG_WHOLE_HIVE_VOLATILE", 
    "REG_NO_LAZY_FLUSH",
    "REG_OPTION_VOLATILE",
    "REG_REFRESH_HIVE",
    "REG_OPTION_NON_VOLATILE",
    "REG_OPTION_BACKUP_RESTORE" ]

_RegCreateKeyExOptions=[
    "REG_LEGAL_OPTION",
    "REG_OPTION_RESERVED",
    "REG_OPTION_VOLATILE",
    "REG_OPTION_NON_VOLATILE",
    "REG_OPTION_BACKUP_RESTORE",
    "REG_CREATED_NEW_KEY",
    "REG_OPENED_EXISTING_KEY",
    "REG_OPTION_CREATE_LINK"]


#unusednames=_RegNotifyChangeKeyValueOptions+_RegRestoreKeyOptions+_RegCreateKeyExOptions

#typeConstantNames=map( lambda x: x.msname, typeConstants.values() )

#allnames=_hivenames+_flagnames+typeConstantNames+unusednames
#winregnames=_winreg.__dict__.keys()
#for name in winregnames:
#    if name not in allnames:
#        print name