#ifndef _IMAGE_PUREIMPORT_HPP_
#define _IMAGE_PUREIMPORT_HPP_
#ifndef _COMMON_WINDOWS_HPP_
#include <common/windows.hpp>
#endif
#ifndef _COMMON_STRING_HPP_
#include <common/string.hpp>
#endif
#include <stdio.h>

class PureImport
{
public:
	enum ThunkType{StandardThunk,WIN95Thunk};
	PureImport(void);
	PureImport(const PureImport &somePureImport);
	PureImport(const String &moduleName,const String &importName,DWORD importAddress=0L,DWORD rewriteAddress=0L,ThunkType thunkType=StandardThunk);
  virtual ~PureImport();
	PureImport &operator=(const PureImport &somePureImport);
	WORD operator==(const PureImport &somePureImport)const;
	WORD operator>(const PureImport &somePureImport)const;
  WORD operator<(const PureImport &somePureImport)const;
	operator String(void)const;
	const String &moduleName(void)const;
	void moduleName(const String &moduleName);
	String importName(void)const;
	void importName(const String &importName);
	DWORD importAddress(void)const;
	void importAddress(DWORD importAddress);
	DWORD rewriteAddress(void)const;
	void rewriteAddress(DWORD rewriteAddress);
	ThunkType thunkType(void)const;
  void thunkType(ThunkType thunkType);
private:
	String mModuleName;
	String mImportName;
	DWORD mImportAddress;
	DWORD mRewriteAddress;
	ThunkType mThunkType;
};

inline
PureImport::PureImport(void)
: mImportAddress(0), mRewriteAddress(0), mThunkType(StandardThunk)
{
}

inline
PureImport::PureImport(const PureImport &somePureImport)
{
  *this=somePureImport;
}

inline
PureImport::PureImport(const String &moduleName,const String &importName,DWORD importAddress,DWORD rewriteAddress,ThunkType thunkType)
: mModuleName(moduleName), mImportName(importName), mImportAddress(importAddress),
	mRewriteAddress(rewriteAddress), mThunkType(thunkType)
{
}

inline
PureImport::~PureImport()
{
}

inline
PureImport &PureImport::operator=(const PureImport &somePureImport)
{
  moduleName(somePureImport.moduleName());
	importName(somePureImport.importName());
	importAddress(somePureImport.importAddress());
	rewriteAddress(somePureImport.rewriteAddress());
  thunkType(somePureImport.thunkType());
  return *this;
}

inline
WORD PureImport::operator==(const PureImport &somePureImport)const
{
  return importAddress()==somePureImport.importAddress();
}

inline
WORD PureImport::operator>(const PureImport &somePureImport)const
{
	return (importAddress()>somePureImport.importAddress());
}

inline
WORD PureImport::operator<(const PureImport &somePureImport)const
{
  return (importAddress()<somePureImport.importAddress());
}

inline
PureImport::operator String(void)const
{
	String importString;
	::sprintf((LPSTR)importString,"%s!%s @0x%08lx @0x%08lx(%08lx) %s",
		(LPSTR)moduleName(),
		(LPSTR)importName(),
		importAddress(),
		rewriteAddress(),
		rewriteAddress()?*((DWORD*)rewriteAddress()):0x00000000,
		(thunkType()==StandardThunk?"StandardThunk":"WIN95 Thunk"));
  return importString;
}

inline
const String &PureImport::moduleName(void)const
{
  return mModuleName;
}

inline
void PureImport::moduleName(const String &moduleName)
{
  mModuleName=moduleName;
}

inline
String PureImport::importName(void)const
{
	return mImportName;
}

inline
void PureImport::importName(const String &importName)
{
  mImportName=importName;
}

inline
DWORD PureImport::importAddress(void)const
{
	return mImportAddress;
}

inline
void PureImport::importAddress(DWORD importAddress)
{
  mImportAddress=importAddress;
}

inline
DWORD PureImport::rewriteAddress(void)const
{
  return mRewriteAddress;
}

inline
void PureImport::rewriteAddress(DWORD rewriteAddress)
{
  mRewriteAddress=rewriteAddress;
}

inline
PureImport::ThunkType PureImport::thunkType(void)const
{
	return mThunkType;
}

inline
void PureImport::thunkType(ThunkType thunkType)
{
  mThunkType=thunkType;
}
#endif