// VCTestPlugin.cpp : Defines the entry point for the DLL application.
//

#include "StdAfx.h"
#include "VCTestPlugin.h"
#include "comcat.h"

static HMODULE g_hModule = NULL ;    // DLL module handle
static long g_cComponents = 0 ;     // Count of active components
static long g_cServerLocks = 0 ;    // Count of locks


// Avaible subclasses
#define  Subclass_Other          1
#define  Subclass_System         (1 << 1)
#define  Subclass_Email          (1 << 2)
#define  Subclass_Browser        (1 << 3)
#define  Subclass_FTPClient      (1 << 4)
#define  Subclass_IM             (1 << 5)
#define  Subclass_Dialer         (1 << 6)
#define  Subclass_Downloader     (1 << 7)
#define  Subclass_Plugin         (1 << 8)

// Log types
#define  LT_NORMAL               0
#define  LT_HILITE               1
#define  LT_ERROR                2


// Friendly name of component
const char g_szFriendlyName[] = "MPR MSVC Plugin Component" ;

// Version-independent ProgID
const char g_szVerIndProgID[] = "VCTestPlugin" ;

// ProgID
const char g_szProgID[] = "VCTestPlugin.1" ;

EXTERN_C CLSID CLSID_VCTestPlugin =
	{0x0c333c21, 0x862c, 0x12cf,
	{0x16, 0xbb, 0x02, 0x85, 0xc7, 0x23, 0x55, 0x77}} ;

EXTERN_C CLSID CLSID_PluginCategory =
	{0x9BCF3212, 0x3D97, 0x4344,
	{0x9A, 0x41, 0xB4, 0x1A, 0xC1, 0xE9, 0x8E, 0x5F}} ;


BOOL APIENTRY DllMain( HMODULE hModule, 
                       DWORD  ul_reason_for_call, 
                       LPVOID lpReserved
					 )
{
	if (ul_reason_for_call == DLL_PROCESS_ATTACH)
	{
		g_hModule = hModule;
	}
	return TRUE ;
}


///////////////////////////////////////////////////////////
//
// Plugin
//

class CVCTestPlugin : public IMPRPlugin
{
public:
	// IUnknown
	virtual HRESULT __stdcall QueryInterface(const IID& iid, void** ppv) ;
	virtual ULONG __stdcall AddRef() ;
	virtual ULONG __stdcall Release() ;

	// IMPRPlugin
	virtual HRESULT __stdcall get_ModuleName(BSTR* Value);
	virtual __int64 __stdcall get_ModuleSubclass(void);
	virtual HRESULT __stdcall get_ModuleAbout(BSTR* Value);
	virtual long __stdcall get_ModuleIcon(IUnknown* Worker);
	virtual __int64 __stdcall get_ModuleVersion(void);
	virtual VARIANT_BOOL __stdcall get_IsEmpty(__int64 Subclass);
	virtual HRESULT __stdcall Collect(IUnknown* Worker);
	virtual HRESULT __stdcall AsText(IUnknown* Worker, __int64 Subclass, BSTR* TextData);
	virtual HRESULT __stdcall AsTree(IUnknown* Worker, __int64 Subclass);
	virtual HRESULT __stdcall ExportData(IUnknown* Stream);
	virtual HRESULT __stdcall ImportData(IUnknown* Stream);

	// Constructor
	CVCTestPlugin() ;

	// Destructor
	~CVCTestPlugin() ;

private:
	// Reference count
	long m_cRef ;
	BSTR m_Username;
	BSTR m_Password;
	BSTR m_IconName;
};


// Constructor
CVCTestPlugin::CVCTestPlugin() : m_cRef(1)
{ 
	InterlockedIncrement(&g_cComponents) ; 
	m_Username = NULL;
	m_Password = NULL;
	m_IconName = SysAllocString(L"VCTestPlugin.PLUGICON");
}

// Destructor
CVCTestPlugin::~CVCTestPlugin()
{ 
	InterlockedDecrement(&g_cComponents) ; 
	if (m_Username)
		SysFreeString(m_Username);
	if (m_Password)
		SysFreeString(m_Password);
	SysFreeString(m_IconName);
}

///////////////////////////////////////////////////////////
//
// Plugin IUnknown Implementation
//

HRESULT __stdcall CVCTestPlugin::QueryInterface(const IID& iid, void** ppv)
{    
	if (iid == IID_IUnknown)
	{
		*ppv = static_cast<IMPRPlugin*>(this) ; 
	}
	else if (iid == IID_IMPRPlugin)
	{
		*ppv = static_cast<IMPRPlugin*>(this) ;
	}
	else
	{
		*ppv = NULL ;
		return E_NOINTERFACE ;
	}
	reinterpret_cast<IUnknown*>(*ppv)->AddRef() ;
	return S_OK ;
}

ULONG __stdcall CVCTestPlugin::AddRef()
{
	return InterlockedIncrement(&m_cRef) ;
}

ULONG __stdcall CVCTestPlugin::Release() 
{
	if (InterlockedDecrement(&m_cRef) == 0)
	{
		delete this ;
		return 0 ;
	}
	return m_cRef ;
}

///////////////////////////////////////////////////////////
//
// Plugin IMPRPlugin implmentation
//

HRESULT __stdcall CVCTestPlugin::get_ModuleName(BSTR *Value)
{
	*Value = SysAllocString(L"VC Plugin Sample");
	return S_OK;
}

__int64 __stdcall CVCTestPlugin::get_ModuleSubclass( void)
{
	return Subclass_Plugin;
}

HRESULT __stdcall CVCTestPlugin::get_ModuleAbout(BSTR* Value)
{
	*Value = SysAllocString(L"VC Plugin Sample About");
	return S_OK;
}

long __stdcall CVCTestPlugin::get_ModuleIcon(IUnknown* Worker)
{
	IMPRWorker* pWorker;
	if (SUCCEEDED(Worker->QueryInterface(IID_IMPRWorker, (void**) &pWorker)))
	{
		HBITMAP hBmp = LoadBitmap(g_hModule, "PLUGICON");
		long r;
		pWorker->IconAssign(m_IconName, (long)hBmp, TRUE, -2, &r);
		DeleteObject(hBmp);
		pWorker->Release();
		return r;
	}
	return -1;
}

__int64 __stdcall CVCTestPlugin::get_ModuleVersion( void)
{
	return ((__int64)1 << 32); /* 1.0 */
}

VARIANT_BOOL __stdcall CVCTestPlugin::get_IsEmpty(__int64 Subclass)
{
	return (!m_Username && !m_Password);
}

HRESULT __stdcall CVCTestPlugin::Collect(IUnknown* Worker)
{
	m_Username = SysAllocString(L"vc_user_name");
	m_Password = SysAllocString(L"vc_password");
	return S_OK;
}

HRESULT __stdcall CVCTestPlugin::AsText(IUnknown* Worker, __int64 Subclass, BSTR* TextData)
{
	return E_NOTIMPL;
}

HRESULT __stdcall CVCTestPlugin::AsTree(IUnknown* Worker, __int64 Subclass)
{
	IMPRWorker* pWorker;
	if (SUCCEEDED(Worker->QueryInterface(IID_IMPRWorker, (void**) &pWorker)))
	{
		HBITMAP hBmp = LoadBitmap(g_hModule, "PLUGICON");
		long r;
		pWorker->IconAssign(m_IconName, (long)hBmp, TRUE, -2, &r);
		DeleteObject(hBmp);

		BSTR _FolderName = SysAllocString(L"VC TestPlugin");
		BSTR _FolderDesc = SysAllocString(L"Here are some test passwords");
		pWorker->AddNodeFolder(_FolderName, _FolderDesc);
		SysFreeString(_FolderName); SysFreeString(_FolderDesc);
		pWorker->MoveIn();
		pWorker->Expand();

		BSTR SafeUsername = SysAllocString(m_Username);
		BSTR SafePassword = SysAllocString(m_Password);
		pWorker->HTMLSafe(&SafeUsername);
		pWorker->HTMLSafe(&SafePassword);
		wchar_t ovfw_buf[5000];
		wsprintfW(ovfw_buf, L"<ul><li>Username: %s<li>Password: %s</ul>", SafeUsername, SafePassword);
		SysFreeString(SafeUsername);
		SysFreeString(SafePassword);

		BSTR _AccInfo = SysAllocString(L"Account Info");
		BSTR _ovfw_buf = SysAllocString(ovfw_buf);
		pWorker->AddNode(_AccInfo, _ovfw_buf, r);
		SysFreeString(_AccInfo);
		SysFreeString(_ovfw_buf);
		
		pWorker->MoveOut();
		pWorker->Release();
	} else
		return E_UNEXPECTED;
	return S_OK;
}

HRESULT __stdcall CVCTestPlugin::ExportData(IUnknown* Stream)
{
	IStream* pStream;
	if (SUCCEEDED(Stream->QueryInterface(IID_IStream, (void**) &pStream)))
	{
		int L = lstrlenW(m_Username)*2;
		pStream->Write(&L, sizeof(int), NULL);
		pStream->Write(m_Username, L, NULL);
		L = lstrlenW(m_Password)*2;
		pStream->Write(&L, sizeof(int), NULL);
		pStream->Write(m_Password, L, NULL);
		pStream->Release();
	} else
		return E_UNEXPECTED;
	return S_OK;
}

HRESULT __stdcall CVCTestPlugin::ImportData(IUnknown* Stream)
{
	IStream* pStream;
	if (SUCCEEDED(Stream->QueryInterface(IID_IStream, (void**) &pStream)))
	{
		int L;
		pStream->Read(&L, sizeof(int), NULL);
		m_Username = SysAllocStringByteLen(NULL, L);
		pStream->Read(m_Username, L, NULL);
		pStream->Read(&L, sizeof(int), NULL);
		m_Password = SysAllocStringByteLen(NULL, L);
		pStream->Read(m_Password, L, NULL);
		pStream->Release();
	} else
		return E_UNEXPECTED;
	return S_OK;
}

///////////////////////////////////////////////////////////
//
// Class factory
//
class CFactory : public IClassFactory
{
public:
	// IUnknown
	virtual HRESULT __stdcall QueryInterface(const IID& iid, void** ppv) ;         
	virtual ULONG   __stdcall AddRef() ;
	virtual ULONG   __stdcall Release() ;

	// Interface IClassFactory
	virtual HRESULT __stdcall CreateInstance(IUnknown* pUnknownOuter,
	                                         const IID& iid,
	                                         void** ppv) ;
	virtual HRESULT __stdcall LockServer(BOOL bLock) ; 

	// Constructor
	CFactory() : m_cRef(1) {}

private:
	long m_cRef ;
} ;

//
// Class factory IUnknown implementation
//
HRESULT __stdcall CFactory::QueryInterface(const IID& iid, void** ppv)
{    
	if ((iid == IID_IUnknown) || (iid == IID_IClassFactory))
	{
		*ppv = static_cast<IClassFactory*>(this) ; 
	}
	else
	{
		*ppv = NULL ;
		return E_NOINTERFACE ;
	}
	reinterpret_cast<IUnknown*>(*ppv)->AddRef() ;
	return S_OK ;
}

ULONG __stdcall CFactory::AddRef()
{
	return InterlockedIncrement(&m_cRef) ;
}

ULONG __stdcall CFactory::Release() 
{
	if (InterlockedDecrement(&m_cRef) == 0)
	{
		delete this ;
		return 0 ;
	}
	return m_cRef ;
}

//
// IClassFactory implementation
//
HRESULT __stdcall CFactory::CreateInstance(IUnknown* pUnknownOuter,
                                           const IID& iid,
                                           void** ppv) 
{
	// Cannot aggregate.
	if (pUnknownOuter != NULL)
	{
		return CLASS_E_NOAGGREGATION ;
	}

	// Create component.
	CVCTestPlugin* pPlugin = new CVCTestPlugin;
	if (pPlugin == NULL)
	{
		return E_OUTOFMEMORY;
	}

	// Get the requested interface.
	HRESULT hr = pPlugin->QueryInterface(iid, ppv) ;

	// Release the IUnknown pointer.
	// (If QueryInterface failed, component will delete itself.)
	pPlugin->Release() ;
	return hr ;
}

// LockServer
HRESULT __stdcall CFactory::LockServer(BOOL bLock) 
{
	if (bLock)
	{
		InterlockedIncrement(&g_cServerLocks) ; 
	}
	else
	{
		InterlockedDecrement(&g_cServerLocks) ;
	}
	return S_OK ;
}


///////////////////////////////////////////////////////////
//
// Exported functions
//


STDAPI DllCanUnloadNow(void)
{
	if ((g_cComponents == 0) && (g_cServerLocks == 0))
	{
		return S_OK ;
	}
	else
	{
		return S_FALSE ;
	}
}

STDAPI DllGetClassObject(const CLSID& clsid,
                         const IID& iid,
                         void** ppv)
{
	// Can we create this component?
	if (clsid != CLSID_VCTestPlugin)
	{
		return CLASS_E_CLASSNOTAVAILABLE ;
	}

	// Create class factory.
	CFactory* pFactory = new CFactory ;  // No AddRef in constructor
	if (pFactory == NULL)
	{
		return E_OUTOFMEMORY ;
	}

	// Get requested interface.
	HRESULT hr = pFactory->QueryInterface(iid, ppv) ;
	pFactory->Release() ;

	return hr ;
}

STDAPI DllRegisterServer(void)
{
	ICatRegister* CatRegister;
	if (SUCCEEDED(CoCreateInstance(CLSID_StdComponentCategoriesMgr, NULL, CLSCTX_ALL, 
		IID_ICatRegister, (void **)&CatRegister)))
	{
		CatRegister->RegisterClassImplCategories(CLSID_VCTestPlugin, 1, &CLSID_PluginCategory);
		CatRegister->Release();
	}

	return RegisterServer(g_hModule, 
	                      CLSID_VCTestPlugin,
	                      g_szFriendlyName,
	                      g_szVerIndProgID,
	                      g_szProgID) ;
}

STDAPI DllUnregisterServer(void)
{
	ICatRegister* CatRegister;
	if (SUCCEEDED(CoCreateInstance(CLSID_StdComponentCategoriesMgr, NULL, CLSCTX_ALL, 
		IID_ICatRegister, (void **)&CatRegister)))
	{
		CatRegister->UnRegisterClassImplCategories(CLSID_VCTestPlugin, 1, &CLSID_PluginCategory);
		CatRegister->Release();
	}

	return UnregisterServer(CLSID_VCTestPlugin,
	                        g_szVerIndProgID,
	                        g_szProgID) ;
}