/*
 * Registry.h 
 * Copyright (c) 2011 Antillia.com TOSHIYUKI ARAI. ALL RIGHTS RESERVED. 
 */


// 2009/10/18 Modified to use StringT class.

#pragma once

#include <sol\Object.h>

#include <sol\String.h>
#include <sol\StringT.h>
#include <sol\StringConverter.h>

#include <sol\stdio.h>

namespace SOL {

class Registry :public Object {
private:
    HKEY baseKey;

private:
    /**
     * Constructor
     */
    Registry()
        :baseKey(NULL) 
    {
    }

public:
    /**
     * Constructor
     */
    Registry(HKEY base)
        :baseKey(base) 
    {
    }

public:
    /**
     */
    bool createKey(const TCHAR* regKey)
    {
        bool rc = false;
        if (regKey == NULL) {
            return rc;
        }

        HKEY hkReg = NULL; 
        if (RegOpenKeyEx(baseKey, _T(""), 0, KEY_READ, &hkReg) == ERROR_SUCCESS) {
    
            HKEY hSubKey = NULL;
            if (RegOpenKeyEx(hkReg, regKey, 0, KEY_READ, &hSubKey) == ERROR_SUCCESS) {

                RegCloseKey(hSubKey);

                rc = true;
            } else {
                HKEY hKeyResult = NULL;
                if (RegCreateKey(hkReg, regKey, &hKeyResult) == ERROR_SUCCESS){
                    rc = true;
                }
            }        
            RegCloseKey(hkReg);
        } 
        return rc;
    }

public:
    /**
     * @param regKey    [in]
     * @param regSubkey        [in]
     * @param text        [in,out] Buffer allocated by caller side. 
     * @param len        [in]     NumberOfElements of TCHAR array (TCHAR* text string)
     *                            This is NOT bytesLength of TCHAR text
     */
    bool getText(__in const TCHAR* regKey, 
                __in const TCHAR* regSubkey, 
                __out TCHAR* text, 
                __in size_t len) 
    {
        bool rc = false;

        if (regKey == NULL || regSubkey == NULL || text ==NULL ||
            len <1) {
            return rc;
        }

        HKEY hkReg = NULL; 
        if (RegOpenKeyEx(baseKey, regKey, 0, KEY_READ, &hkReg) == ERROR_SUCCESS) {
            DWORD nType = REG_SZ; 

            DWORD cbData = 0;
            // 1 Get bytesSize(cbData) for this registry entry
            RegQueryValueEx(hkReg, regSubkey, NULL, &nType, NULL, &cbData);    

            // 2 BytesSize of parameter text TCHAR string.
            DWORD textBytesSize = len*sizeof(TCHAR);

            if (textBytesSize<=cbData) {
                //3 Error;Buffer size for text is small.
                TCHAR error[1024];
                _stprintf_s(error, SizeOf(error), 
                    _T("Registry#getText() Error: buffer size(%d) is too small. It should be greater than %d.\r\nKey=%s rebsubKey=%s"),
                    len, 
                    cbData/sizeof(TCHAR)+1, 
                    regKey, 
                    regSubkey);

                MessageBox(NULL, error, _T("SOL9"), MB_OK);
                return rc;        
            }

            if (cbData>0) {
                TCHAR* data = (TCHAR*)new char[cbData];

                if (RegQueryValueEx(hkReg, regSubkey, NULL, 
                    &nType, (LPBYTE)data, &cbData) == ERROR_SUCCESS){
                    strcpy_s(text, len, data);
                    rc = true;
                }
            
                delete [] data;
            }

            RegCloseKey(hkReg);
        }
        return rc;
    }



public:
    /** 
     * @param regKey        [in] 
     * @param regSubkey        [in]
     * @param text            [out]
     */
    // The type of regSubkey must be REG_SZ.
    bool getText(__in const TCHAR* regKey, 
                __in const TCHAR*     regSubkey, 
                __out String& text) 
    {
        bool rc = false;
        if (regKey == NULL || regSubkey == NULL) {
            return rc;
        }

        HKEY hkReg = NULL; 

        if (RegOpenKeyEx(baseKey, regKey, 0, KEY_READ, &hkReg) == ERROR_SUCCESS) {
            DWORD nType = REG_SZ; 

            DWORD cbData = 0;
            //Get the bytessize to return a value for a entry of regKey and regSubkey ;
            
            RegQueryValueEx(hkReg, regSubkey, NULL, 
                &nType, NULL, &cbData);    
            if (cbData >0) {
                TCHAR* data = (TCHAR*)new char[cbData];

                if (RegQueryValueEx(hkReg, regSubkey, NULL, 
                    &nType, (LPBYTE)data, &cbData) == ERROR_SUCCESS){
                    text.shallowCopy(data);
            
                    rc = true;
                }
            }
            RegCloseKey(hkReg);
        }
        return rc;
    }

public:
    bool getText(__in const TCHAR* regKey, 
                __in const TCHAR*     regSubkey, 
                __out StringT<char>& text) 
    {
        bool rc = false;
        if (regKey == NULL || regSubkey == NULL) {
            return rc;
        }

        String string;
        rc = getText(regKey, regSubkey, string);
        if (rc) {
            StringConverter converter;
            converter.convert((const TCHAR*)string, text);
        }
        return rc;
    }

public:
    bool getText(__in const TCHAR* regKey, 
                __in const TCHAR*     regSubkey, 
                __out StringT<wchar_t>& text) 
    {
        bool rc = false;
        if (regKey == NULL || regSubkey == NULL) {
            return rc;
        }

        String string;
        rc = getText(regKey, regSubkey, string);
        if (rc) {
            StringConverter converter;
            converter.convert((const TCHAR*)string, text);
        }
        return rc;
    }


public:
    /**
     * @param regKey    [in]
     * @param regSubkey    [in]
     * @param    text    [in] NULL terminated TCHAR string.
     *
     */
    // The type of regSubkey must be REG_SZ.

    bool setText(__in const TCHAR* regKey, 
                __in const TCHAR* regSubkey, 
                __in const TCHAR* text) 
    {     
        bool rc = false;
        if (regKey == NULL || regSubkey == NULL || text ==NULL) {
            return rc;
        }

        HKEY hkReg = NULL; 
        DWORD dpos = 0;
        //We need bytes size for the TCHAR string of text
        // 
        DWORD bytesLen = (strlen(text)+1) * sizeof(TCHAR);

        if (RegCreateKeyEx(baseKey, regKey, 0, NULL, 0,
            KEY_WRITE, NULL, &hkReg, &dpos) == ERROR_SUCCESS) {
            if (RegSetValueEx(hkReg, regSubkey, 0, REG_SZ, 
                (LPBYTE)text, bytesLen) == ERROR_SUCCESS){    
                rc = true;
            }
            RegCloseKey(hkReg);
        }
        return rc;
    }

public:
    bool setText(__in const TCHAR* regKey, 
                __in const TCHAR*     regSubkey, 
                __in String& text) 
    { 
        bool rc = false;
        if (regKey == NULL || regSubkey == NULL || text ==NULL) {
            return rc;
        }
        String tstring(text);
        return setText(regKey, regSubkey, (const TCHAR*)tstring);
    }

public:
    bool setText(__in const TCHAR* regKey, 
                __in const TCHAR*     regSubkey, 
                __in StringT<char>& text) 
    {     
        bool rc = false;
        if (regKey == NULL || regSubkey == NULL || text ==NULL) {
            return rc;
        }
        String tstring(text);
        return setText(regKey, regSubkey, tstring);
    }

public:
    bool setText(__in const TCHAR* regKey, 
                __in const TCHAR*     regSubkey, 
                __in StringT<wchar_t>& text) 
    {     
        bool rc = false;
        if (regKey == NULL || regSubkey == NULL || text ==NULL) {
            return rc;
        }
        String tstring(text);
        return setText(regKey, regSubkey, tstring);
    }

public:
    /**
     * @param regKey    [in]
     * @param regSubkey    [in]
     * @param value        [out]

     */
    // The type of regSubkey must be REG_DWORD.

    bool getInteger(__in const TCHAR* regKey, 
                    __in const TCHAR* regSubkey, 
                    __out int& value) 
    {     
        bool rc = false;
        if (regKey == NULL || regSubkey == NULL) {
            return rc;
        }

        HKEY hkReg = NULL; 
        DWORD dpos = 0;

        if (RegOpenKeyEx(baseKey, regKey, 0, 
                KEY_READ, &hkReg) == ERROR_SUCCESS) {

            DWORD nType = REG_DWORD; 
            DWORD cbData = sizeof(value);
            if (RegQueryValueEx(hkReg, regSubkey, NULL, 
                &nType, (LPBYTE)&value, &cbData) == ERROR_SUCCESS){    
                rc = true;
            } 
            RegCloseKey(hkReg);
        }
        return rc;
    }

public:
    /**
     * @param regKey    [in]
     * @param regSubkey    [in]
     * @param value        [in]
     */
    // The type of regSubkey must be REG_DWORD.

    bool setInteger(__in const TCHAR* regKey, 
                __in const TCHAR*     regSubkey, 
                __in int    value) 
    { 
        
        bool rc = false;
        if (regKey == NULL || regSubkey == NULL) {
            return rc;
        }

        HKEY hkReg = NULL; 
        DWORD dpos = 0;

        if (RegCreateKeyEx(baseKey, regKey, 0, NULL, 0, 
                KEY_WRITE, NULL, &hkReg, &dpos) == ERROR_SUCCESS) {

            if (RegSetValueEx(hkReg, regSubkey, 0, REG_DWORD, 
                    (CONST BYTE*)&value, sizeof(value)) == ERROR_SUCCESS){    
                rc = true;
            }
            RegCloseKey(hkReg);
        }
        return rc;
    }

public:
    /**
     * @param regKey        [in]
     * @param regSubkey        [in]
     * @param data            [in,out]
     * @param len            [in]
     */
    // The type of regSubkey must be REG_BINARY.

    bool getBinary(__in const TCHAR* regKey, 
                __in const TCHAR*     regSubkey, 
                __out unsigned char* data,
                __in size_t len) 
    { 
        
        bool rc = false;
        if (regKey == NULL || regSubkey == NULL || data ==NULL ||
            len <1) {
            return rc;
        }

        HKEY hkReg = NULL; 
        DWORD dpos = 0;
        if (RegOpenKeyEx(baseKey, regKey, 0, KEY_READ, &hkReg) == ERROR_SUCCESS) {
        
            DWORD nType = REG_BINARY; 
            DWORD cbData = 0;

            RegQueryValueEx(hkReg, regSubkey, NULL, &nType, NULL, &cbData);
            if (cbData>len) {    
                TCHAR error[1024];
                _stprintf_s(error, SizeOf(error), 
                    _T("Registry#getBinary() Error: buffer size(%d) is too small. It should be greater than %d.\r\nKey=%s rebsubKey=%s"),
                len, 
                cbData, 
                regKey, 
                regSubkey);

                MessageBox(NULL, error, _T("SOL9"), MB_OK);
                return rc;
            }

            if (RegQueryValueEx(hkReg, regSubkey, NULL, &nType, (LPBYTE)data, &cbData) == ERROR_SUCCESS){
                rc = true;
            }
    
            RegCloseKey(hkReg);
        }
        return rc;
    }

public:
    /**
     * @param regKey        [in]
     * @param regSubkey        [in]
     * @param data            [in,out]
     * @param len            [in]
     */
    // The type of regSubkey must be REG_BINARY.
    //2009/06/18
    bool setBinary(__in const TCHAR* regKey, 
                __in const TCHAR*     regSubkey, 
                __in unsigned char* data,
                __in size_t len) 
    { 
        bool rc = false;
        if (regKey == NULL || regSubkey == NULL || data ==NULL ||
            len <1) {
            return rc;
        }

        HKEY hkReg = NULL; 
        DWORD dpos = 0;

        if (RegCreateKeyEx(baseKey, regKey, 0, NULL, 0, 
                KEY_WRITE, NULL, &hkReg, &dpos) == ERROR_SUCCESS) {

            if (RegSetValueEx(hkReg, regSubkey, 0, REG_BINARY, 
                    (CONST BYTE*)data, len) == ERROR_SUCCESS){
                rc = true;
            }
            RegCloseKey(hkReg);
        }
        return rc;
    }


public:
    long enumKey(DWORD index, TCHAR* name, DWORD* cbName)
    {
        FILETIME lastWrite;
        return ::RegEnumKeyEx(this->baseKey, index, name, cbName, NULL,
                NULL, 0, &lastWrite);
    }

public:
    long enumKey(DWORD index, TCHAR* name, DWORD* cbName,
        TCHAR* cls, DWORD* cbCls, FILETIME* lastWrite)
    {
        return ::RegEnumKeyEx(this->baseKey, index, name, cbName, NULL,
                cls, cbCls, lastWrite);
    }

public:
    long enumValue(DWORD index, TCHAR* value, DWORD* cbValue,
        DWORD* type, BYTE* data, DWORD* cbData)
    {
        return ::RegEnumValue(this->baseKey, index, value, cbValue, NULL,
                type, data, cbData);
    }

public:
    int setValue(const TCHAR* subkey, DWORD type, const TCHAR* value, int cbsize)
    {
        return ::RegSetValueEx(this->baseKey, subkey, NULL, type, 
            (const byte*) value, cbsize);
    }
 

public:
    int getValue(const TCHAR* subkey, DWORD* type, TCHAR* value, DWORD* cbsize)
    {
        return ::RegQueryValueEx(this->baseKey, subkey, NULL, type, 
                (byte*)value, cbsize);
    }
    
};

}