#ifndef __MRU_H_INCLUDED
#define __MRU_H_INCLUDED

#include <windows.h>
#include <shlobj.h>
#include <wiacrc32.h>
#include "simstr.h"
#include "simidlst.h"
#include "destdata.h"

#define CURRENT_REGISTRY_DATA_FORMAT_VERSION 3

class CMruStringList : public CSimpleLinkedList<CSimpleString>
{
private:
    int m_nNumToWrite;
    enum
    {
        DefaultNumToWrite=20
    };
private:
    CMruStringList( const CMruStringList & );
    CMruStringList &operator=( const CMruStringList & );
public:
    CMruStringList( int nNumToWrite=DefaultNumToWrite )
    : m_nNumToWrite(nNumToWrite)
    {
    }
    bool Read( HKEY hRoot, LPCTSTR pszKey, LPCTSTR pszValueName )
    {
        CSimpleReg reg( hRoot, pszKey, false, KEY_READ );
        if (reg.OK())
        {
            if (REG_MULTI_SZ==reg.Type(pszValueName))
            {
                int nSize = reg.Size(pszValueName);
                if (nSize)
                {
                    PBYTE pData = new BYTE[nSize];
                    if (pData)
                    {
                        if (reg.QueryBin( pszValueName, pData, nSize ))
                        {
                            for (LPTSTR pszCurr=reinterpret_cast<LPTSTR>(pData);*pszCurr;pszCurr+=lstrlen(pszCurr)+1)
                            {
                                Append( pszCurr );
                            }
                        }
                        delete[] pData;
                    }
                }
            }
        }
        return(true);
    }
    bool Write( HKEY hRoot, LPCTSTR pszKey, LPCTSTR pszValueName )
    {
        CSimpleReg reg( hRoot, pszKey, true, KEY_WRITE );
        if (reg.OK())
        {
            int nLengthInChars = 0, nCount;
            Iterator i;
            for (i=Begin(),nCount=0;i != End() && nCount < m_nNumToWrite;++i,++nCount)
                nLengthInChars += (*i).Length() + 1;
            if (nLengthInChars)
            {
                ++nLengthInChars;
                LPTSTR pszMultiStr = new TCHAR[nLengthInChars];
                if (pszMultiStr)
                {
                    LPTSTR pszCurr = pszMultiStr;
                    for (i = Begin(), nCount=0;i != End() && nCount < m_nNumToWrite;++i,++nCount)
                    {
                        lstrcpy(pszCurr,(*i).String());
                        pszCurr += (*i).Length() + 1;
                    }
                    *pszCurr = TEXT('\0');
                    reg.SetBin( pszValueName, reinterpret_cast<PBYTE>(pszMultiStr), nLengthInChars*sizeof(TCHAR), REG_MULTI_SZ );
                    delete[] pszMultiStr;
                }
            }
        }
        return(true);
    }
    void Add( CSimpleString str )
    {
        if (str.Length())
        {
            Remove(str);
            Prepend(str);
        }
    }
    void PopulateComboBox( HWND hWnd )
    {
        SendMessage( hWnd, CB_RESETCONTENT, 0, 0 );
        for (Iterator i = Begin();i != End();++i)
        {
            SendMessage( hWnd, CB_ADDSTRING, 0, (LPARAM)((*i).String()));
        }
    }
};


class CMruDestinationData : public CSimpleLinkedList<CDestinationData>
{
private:
    int m_nNumToWrite;
    enum
    {
        DefaultNumToWrite=20
    };
    struct REGISTRY_SIGNATURE
    {
        DWORD dwSize;
        DWORD dwVersion;
        DWORD dwCount;
        DWORD dwCrc;
    };
private:
    CMruDestinationData( const CMruDestinationData & );
    CMruDestinationData &operator=( const CMruDestinationData & );
public:
    CMruDestinationData( int nNumToWrite=DefaultNumToWrite )
      : m_nNumToWrite(nNumToWrite)
    {
    }
    bool Read( HKEY hRoot, LPCTSTR pszKey, LPCTSTR pszValueName )
    {
        //
        // Open the registry
        //
        CSimpleReg reg( hRoot, pszKey, false, KEY_READ );
        if (reg.OK())
        {
            //
            //  Make sure the type is correct
            //
            if (REG_BINARY==reg.Type(pszValueName))
            {
                //
                // Get the size and make sure it is at least as large as the signature structure
                //
                DWORD nSize = reg.Size(pszValueName);
                if (nSize >= sizeof(REGISTRY_SIGNATURE))
                {
                    //
                    // Allocate a block to hold the data
                    //
                    PBYTE pData = new BYTE[nSize];
                    if (pData)
                    {
                        //
                        // Get the data
                        //
                        if (reg.QueryBin( pszValueName, pData, nSize ))
                        {
                            //
                            // Copy the blob to a registry signature structure
                            //
                            REGISTRY_SIGNATURE RegistrySignature = {0};
                            CopyMemory( &RegistrySignature, pData, sizeof(REGISTRY_SIGNATURE) );

                            //
                            // Make sure the version and struct size are correct, and the count is non-zero.  Just ignore it if it isn't.
                            //
                            if (RegistrySignature.dwSize == sizeof(REGISTRY_SIGNATURE) && RegistrySignature.dwVersion == CURRENT_REGISTRY_DATA_FORMAT_VERSION && RegistrySignature.dwCount)
                            {
                                //
                                // Raw data starts at the end of the structure
                                //
                                PBYTE pCurr = pData + sizeof(REGISTRY_SIGNATURE);

                                //
                                // Get the CRC for this blob and make sure it matches
                                //
                                DWORD dwCrc = WiaCrc32::GenerateCrc32( nSize - sizeof(REGISTRY_SIGNATURE), pCurr );
                                if (dwCrc == RegistrySignature.dwCrc)
                                {
                                    //
                                    // Loop through all of the entries
                                    //
                                    for (int i=0;i<static_cast<int>(RegistrySignature.dwCount);i++)
                                    {
                                        //
                                        // Copy the item size
                                        //
                                        DWORD dwItemSize = 0;
                                        CopyMemory( &dwItemSize, pCurr, sizeof(DWORD) );

                                        //
                                        // Increment the current pointer beyond the size
                                        //
                                        pCurr += sizeof(DWORD);

                                        //
                                        // Make sure the item size is non-zero
                                        //
                                        if (dwItemSize)
                                        {
                                            //
                                            // Create a CDestinationData with this blob
                                            //
                                            CDestinationData DestinationData;
                                            DestinationData.SetRegistryData(pCurr,dwItemSize);

                                            //
                                            // Add it to the list
                                            //
                                            Append( DestinationData );
                                        }

                                        //
                                        // Increment the current pointer to the end of the blob
                                        //
                                        pCurr += dwItemSize;
                                    }
                                }
                            }
                        }

                        //
                        // Delete the registry data blob
                        //
                        delete[] pData;
                    }
                }
            }
        }
        
        return true;
    }
    bool Write( HKEY hRoot, LPCTSTR pszKey, LPCTSTR pszValueName )
    {
        CSimpleReg reg( hRoot, pszKey, true, KEY_WRITE );
        if (reg.OK())
        {
            //
            // Find the size needed for the data.  Initialize to the size of the registry signature struct.
            //
            DWORD nLengthInBytes = sizeof(REGISTRY_SIGNATURE);
            DWORD dwCount=0;
            
            //
            // Loop through each item and add up the number of bytes required to store it as a blob
            //
            Iterator ListIter=Begin();
            while (ListIter != End() && dwCount < static_cast<DWORD>(m_nNumToWrite))
            {
                nLengthInBytes += (*ListIter).RegistryDataSize() + sizeof(DWORD);
                ++dwCount;
                ++ListIter;
            }
            
            //
            // Allocate some memory to hold the blob
            //
            PBYTE pItems = new BYTE[nLengthInBytes];
            if (pItems)
            {
                //
                // Start at the end of the registry signature struct
                //
                PBYTE pCurr = pItems + sizeof(REGISTRY_SIGNATURE);
                
                //
                // Initialize the length remaining to the total length minus the size of the registry signature struct
                //
                DWORD nLengthRemaining = nLengthInBytes - sizeof(REGISTRY_SIGNATURE);
                
                //
                // Loop through the list, stopping when we get to the max number of items to write
                //
                ListIter=Begin();
                DWORD dwCurr = 0;
                while (ListIter != End() && dwCurr < dwCount)
                {
                    //
                    // Get the size of this blob
                    //
                    DWORD dwSize = (*ListIter).RegistryDataSize();
                    if (dwSize)
                    {
                        //
                        // Copy the size to our buffer, and increment the current pointer
                        //
                        CopyMemory( pCurr, &dwSize, sizeof(DWORD) );
                        pCurr += sizeof(DWORD);

                        //
                        // Get the blob for this item
                        //
                        (*ListIter).GetRegistryData( pCurr, nLengthRemaining );

                        //
                        // Increment the current pointer
                        //
                        pCurr += (*ListIter).RegistryDataSize();
                    }

                    ++dwCurr;
                    ++ListIter;
                }
                
                //
                // Initialize the registry signature struct
                //
                REGISTRY_SIGNATURE RegistrySignature = {0};
                RegistrySignature.dwSize = sizeof(REGISTRY_SIGNATURE);
                RegistrySignature.dwVersion = CURRENT_REGISTRY_DATA_FORMAT_VERSION;
                RegistrySignature.dwCount = dwCount;
                RegistrySignature.dwCrc = WiaCrc32::GenerateCrc32( nLengthInBytes - sizeof(REGISTRY_SIGNATURE), pItems + sizeof(REGISTRY_SIGNATURE) );
                
                //
                // Copy the registry signature struct to the buffer
                //
                CopyMemory( pItems, &RegistrySignature, sizeof(REGISTRY_SIGNATURE) );

                //
                // Save the data to the registry
                //
                reg.SetBin( pszValueName, pItems, nLengthInBytes, REG_BINARY );
                
                //
                // Free the temp buffer
                //
                delete[] pItems;
            }
        }
        return(true);
    }
    Iterator Add( CDestinationData item )
    {
        if (item.IsValid())
        {
            Remove(item);
            return Prepend(item);
        }
        return End();
    }
};


#endif //__MRU_H_INCLUDED