#ifndef _KTEXTRACTDWGFILER_H__
#define _KTEXTRACTDWGFILER_H__

#if _MSC_VER > 1000
#pragma once
#endif

#include "dbfiler.h"

typedef struct XData
{
	int nVt;
	LONG_PTR npszLen;
	union
	{
		LONG_PTR nVal;
		double	dVal[3];
		TCHAR*	pszVal;
	};
}XDATA;

class AecXDataMap
{
public:
	AecXDataMap();
	virtual ~AecXDataMap();

public:

	BOOL SetAt(LPCTSTR pszKey, int nVal);
	BOOL SetAt(LPCTSTR pszKey, double dVal);

	BOOL SetAt(LPCTSTR pszKey, const AcGeDoubleArray& arVal);
	BOOL SetAt(LPCTSTR pszKey, const AcGeVector3d& vt, BOOL bTransformBy = FALSE);

	BOOL SetAt(LPCTSTR pszKey, const AcGePoint3d& ptGe, BOOL bTransformBy = FALSE);
	BOOL SetAt(LPCTSTR pszKey, const AcGePoint3dArray& arPt, BOOL bTransformBy = FALSE);

	BOOL SetAt(LPCTSTR pszKey, LPCTSTR pszValue);
	BOOL SetAt(LPCTSTR pszKey, const AcDbObjectId& id, BOOL bIsSoft = TRUE);

	BOOL SetAt(LPCTSTR pszKey, const AcGeMatrix3d& xform);

	BOOL GetAt(LPCTSTR pszKey, int& nVal) const;

	BOOL GetAt(LPCTSTR pszKey, double& dVal) const;
	BOOL GetAt(LPCTSTR pszKey, AcGeDoubleArray& arVal) const;

	BOOL GetAt(LPCTSTR pszKey, AcGeVector3d& vt) const;

	BOOL GetAt(LPCTSTR pszKey, AcGePoint3d& ptGe) const;

	BOOL GetAt(LPCTSTR pszKey, AcGePoint3dArray& arPt) const;

	BOOL GetAt(LPCTSTR pszKey, AcGeMatrix3d& xform) const;

	BOOL GetAt(LPCTSTR pszKey, CString &sValue) const;

	BOOL GetAt(LPCTSTR pszKey, AcDbObjectId& id) const;

	BOOL SetAt(LPCTSTR pszKey, int iIndex, LPCTSTR pszValue);
	BOOL GetAt(LPCTSTR pszKey, int iIndex, CString &sValue);

	BOOL SetAt(LPCTSTR pszKey, int iIndex, const AecXDataMap& xDataMap);
	BOOL GetAt(LPCTSTR pszKey, int iIndex, AecXDataMap& xDataMap);

	BOOL SetAt(LPCTSTR pszKey, const XData& XData);
	BOOL GetAt(LPCTSTR pszKey, XData& XData);

	BOOL HasKey(LPCTSTR pszKey, int& nVt);
	void Empty();

	BOOL RemoveAt(LPCTSTR pszKey);
	BOOL RemoveAt(LPCTSTR pszKey, int nIndex);

	BOOL Write(CFile* pFileOut, BOOL bWriteUserData);
	BOOL Read(CFile* pFileIn, BOOL bWriteUserData);

	typedef std::map<CString, XData>::iterator It;
	It Begin();
	BOOL GetNext(It& it, XData& xData);
	It End();

	BOOL FormatDataMap(CStringArray& arItemLines);

private:

	BOOL ParseToRecords(CString& sText, CStringArray& arRecords);

	BOOL ExtractRecord(CString& sRecord, CString& sKey, CString& sType, CString& sInfo);

	BOOL StringToAcGePoint3d(CString& sText, AcGePoint3d& ptGe);

	BOOL StringToAcGeVector3d(CString& sText, AcGeVector3d& ptGe);

private:

	std::map<CString, XData> m_xData;
};

typedef struct binary_buf
{
	Adesk::UInt32 nLen;
	void* pBuf;
}BINARY_BUF;

class KTExtractDwgFiler : public AcDbDwgFiler 
{
public:

	ACRX_DECLARE_MEMBERS(KTExtractDwgFiler);

			 KTExtractDwgFiler();
	virtual ~KTExtractDwgFiler();

	virtual Acad::ErrorStatus   filerStatus() const;
	virtual AcDb::FilerType     filerType() const;

	virtual void                setFilerStatus(Acad::ErrorStatus);
	virtual void                resetFilerStatus();

	// readXxx() and writeXxx() functions
	virtual Acad::ErrorStatus   readHardOwnershipId(AcDbHardOwnershipId* pid){return Acad::eOk;}
	virtual Acad::ErrorStatus   writeHardOwnershipId(const AcDbHardOwnershipId& id);

	virtual Acad::ErrorStatus   readSoftOwnershipId(AcDbSoftOwnershipId* pid){return Acad::eOk;}
	virtual Acad::ErrorStatus   writeSoftOwnershipId(const AcDbSoftOwnershipId& id);

	virtual Acad::ErrorStatus   readHardPointerId(AcDbHardPointerId* pid){return Acad::eOk;}
	virtual Acad::ErrorStatus   writeHardPointerId(const AcDbHardPointerId& id);

	virtual Acad::ErrorStatus   readSoftPointerId(AcDbSoftPointerId* pid){return Acad::eOk;}
	virtual Acad::ErrorStatus   writeSoftPointerId(const AcDbSoftPointerId& id);

#if ARX>17
	virtual Acad::ErrorStatus   readInt64(Adesk::Int64*){return Acad::eOk;}
	virtual Acad::ErrorStatus   writeInt64(Adesk::Int64);
	
	virtual Acad::ErrorStatus   readUInt64(Adesk::UInt64*){return Acad::eOk;}
	virtual Acad::ErrorStatus   writeUInt64(Adesk::UInt64);

	virtual Acad::ErrorStatus   seek(Adesk::Int64 nOffset, int nMethod) {return Acad::eOk;}
	virtual Adesk::Int64        tell() const {return 0;}

	virtual Acad::ErrorStatus   readBytes(void *, Adesk::UIntPtr) {return Acad::eOk;}
	virtual Acad::ErrorStatus   writeBytes(const void *, Adesk::UIntPtr);

#endif

	virtual Acad::ErrorStatus   readInt8(Adesk::Int8* pInt8) {return Acad::eOk;}
	virtual Acad::ErrorStatus   writeInt8(Adesk::Int8 nInt8);

	// These are to be removed in a future release.  Please use
	// readInt8 or writeInt8 instead.
	inline  Acad::ErrorStatus   readChar(Adesk::Int8 *pInt8) {return Acad::eOk;}
	inline  Acad::ErrorStatus   writeChar(Adesk::Int8 ch);

	// Note: use of readString(ACHAR **) is discouraged, because
	// caller has to free the returned string.  It may be phased
	virtual Acad::ErrorStatus   readString(ACHAR ** ppACHAR) {return Acad::eOk;}
	virtual Acad::ErrorStatus   writeString(const ACHAR * pACHAR);

#if ARX>15
	virtual Acad::ErrorStatus   readString(AcString& str) {return Acad::eOk;}
	virtual Acad::ErrorStatus   writeString(const AcString& str);
#endif

	virtual Acad::ErrorStatus   readBChunk(ads_binary* pbinar) {return Acad::eOk;}
	virtual Acad::ErrorStatus   writeBChunk(const ads_binary& binar);

	virtual Acad::ErrorStatus   readAcDbHandle(AcDbHandle* pdbhdl) {return Acad::eOk;}
	virtual Acad::ErrorStatus   writeAcDbHandle(const AcDbHandle& dbhdl);

	virtual Acad::ErrorStatus   readInt32(Adesk::Int32* pInt32) {return Acad::eOk;}
	virtual Acad::ErrorStatus   writeInt32(Adesk::Int32 nInt32);

	virtual Acad::ErrorStatus   readInt16(Adesk::Int16* pInt16) {return Acad::eOk;}
	virtual Acad::ErrorStatus   writeInt16(Adesk::Int16 nInt16);

	virtual Acad::ErrorStatus   readUInt32(Adesk::UInt32* pUInt32) {return Acad::eOk;}
	virtual Acad::ErrorStatus   writeUInt32(Adesk::UInt32 nUInt32);

	virtual Acad::ErrorStatus   readUInt16(Adesk::UInt16* pUInt16) {return Acad::eOk;}
	virtual Acad::ErrorStatus   writeUInt16(Adesk::UInt16 nUInt16);

	virtual Acad::ErrorStatus   readUInt8(Adesk::UInt8* pUInt8) {return Acad::eOk;}
	virtual Acad::ErrorStatus   writeUInt8(Adesk::UInt8 nUInt8);

	virtual Acad::ErrorStatus   readBoolean(Adesk::Boolean* pBoolean) {return Acad::eOk;}
	virtual Acad::ErrorStatus   writeBoolean(Adesk::Boolean bVal);

	virtual Acad::ErrorStatus   readBool(bool* pbVal) {return Acad::eOk;}
	virtual Acad::ErrorStatus   writeBool(bool bVal);

	virtual Acad::ErrorStatus   readDouble(double* pdVal) {return Acad::eOk;}
	virtual Acad::ErrorStatus   writeDouble(double dVal);

	virtual Acad::ErrorStatus   readPoint2d(AcGePoint2d* pPt2d) {return Acad::eOk;}
	virtual Acad::ErrorStatus   writePoint2d(const AcGePoint2d& pt2d);

	virtual Acad::ErrorStatus   readPoint3d(AcGePoint3d* pPt3d) {return Acad::eOk;}
	virtual Acad::ErrorStatus   writePoint3d(const AcGePoint3d& pt3d);

	virtual Acad::ErrorStatus   readVector2d(AcGeVector2d* pVec2d) {return Acad::eOk;}
	virtual Acad::ErrorStatus   writeVector2d(const AcGeVector2d& vec2d);

	virtual Acad::ErrorStatus   readVector3d(AcGeVector3d* pVec3d) {return Acad::eOk;}
	virtual Acad::ErrorStatus   writeVector3d(const AcGeVector3d& vec3d);

	virtual Acad::ErrorStatus   readScale3d(AcGeScale3d* pScl3d) {return Acad::eOk;}
	virtual Acad::ErrorStatus   writeScale3d(const AcGeScale3d& scl3d);

#if ARX<18
	virtual Acad::ErrorStatus   readBytes(void* pByte, Adesk::UInt32 nLen) {return Acad::eOk;}
	virtual Acad::ErrorStatus   writeBytes(const void* pByte, Adesk::UInt32 nLen);
#endif

	virtual Acad::ErrorStatus   readAddress(void ** ppAddr) {return Acad::eOk;}
	virtual Acad::ErrorStatus   writeAddress(const void* pAddr);

	// readItem() and writeItem() functions
	Acad::ErrorStatus			readItem(AcDbHardOwnershipId* pid) {return Acad::eOk;}
	Acad::ErrorStatus			writeItem(const AcDbHardOwnershipId& id);

	Acad::ErrorStatus			readItem(AcDbSoftOwnershipId* pid) {return Acad::eOk;}
	Acad::ErrorStatus			writeItem(const AcDbSoftOwnershipId& id);

	Acad::ErrorStatus			readItem(AcDbHardPointerId* pid) {return Acad::eOk;}
	Acad::ErrorStatus			writeItem(const AcDbHardPointerId& id);

	Acad::ErrorStatus			readItem(AcDbSoftPointerId* pid) {return Acad::eOk;}
	Acad::ErrorStatus			writeItem(const AcDbSoftPointerId& id);

	// Note: there are no filer methods for explicitly reading or
	// writing a single text character.  There are readChar() and
	// writeChar(), but these do not do any code page translation
	// on the data.  I.e., they treat it as a signed 8-bit
	// integer value.  Since they are thus the same as readInt8()
	// and writeInt8(), they are being deprecated.
	Acad::ErrorStatus			readItem(ACHAR ** ppStr) {return Acad::eOk;}
	Acad::ErrorStatus			writeItem(const ACHAR * pStr);

	Acad::ErrorStatus			readItem(ads_binary* pbinar) {return Acad::eOk;}
	Acad::ErrorStatus			writeItem(const ads_binary& binar);

	Acad::ErrorStatus			readItem(AcDbHandle* pHdl) {return Acad::eOk;}
	Acad::ErrorStatus			writeItem(const AcDbHandle& hdl);

	Acad::ErrorStatus			readItem(Adesk::Int32* pInt32) {return Acad::eOk;}
	Acad::ErrorStatus			writeItem(Adesk::Int32 nInt32);

	Acad::ErrorStatus			readItem(Adesk::Int16* pInt16) {return Acad::eOk;}
	Acad::ErrorStatus			writeItem(Adesk::Int16 nInt16);

	Acad::ErrorStatus			readItem(Adesk::Int8* pInt8) {return Acad::eOk;}
	Acad::ErrorStatus			writeItem(Adesk::Int8 nInt8);

	Acad::ErrorStatus			readItem(Adesk::UInt32* pUInt32) {return Acad::eOk;}
	Acad::ErrorStatus			writeItem(Adesk::UInt32 nUInt32);

	Acad::ErrorStatus			readItem(Adesk::UInt16* pUInt16) {return Acad::eOk;}
	Acad::ErrorStatus			writeItem(Adesk::UInt16 nUInt16);

	Acad::ErrorStatus			readItem(Adesk::UInt8* pUInt8) {return Acad::eOk;}
	Acad::ErrorStatus			writeItem(Adesk::UInt8 nUInt8);

#ifndef Adesk_Boolean_is_bool
	Acad::ErrorStatus			readItem(Adesk::Boolean* pBool) {return Acad::eOk;}
	Acad::ErrorStatus			writeItem(Adesk::Boolean bVal);
#else
	Acad::ErrorStatus			readItem(bool* pbVal) {return Acad::eOk;}
	Acad::ErrorStatus			writeItem(bool bVal);
#endif

	Acad::ErrorStatus			readItem(double* pdval) {return Acad::eOk;}
	Acad::ErrorStatus			writeItem(double dVal);

	Acad::ErrorStatus			readItem(AcGePoint2d* pPt2d) {return Acad::eOk;}
	Acad::ErrorStatus			writeItem(const AcGePoint2d& pt2d);

	Acad::ErrorStatus			readItem(AcGePoint3d* pPt3d) {return Acad::eOk;}
	Acad::ErrorStatus			writeItem(const AcGePoint3d& pt3d);

	Acad::ErrorStatus			readItem(AcGeVector2d* pPt2d) {return Acad::eOk;}
	Acad::ErrorStatus			writeItem(const AcGeVector2d& pt2d);

	Acad::ErrorStatus			readItem(AcGeVector3d* pPt3d) {return Acad::eOk;}
	Acad::ErrorStatus			writeItem(const AcGeVector3d& pt3d);

	Acad::ErrorStatus			readItem(AcGeScale3d* pPt3d) {return Acad::eOk;}
	Acad::ErrorStatus			writeItem(const AcGeScale3d& pt3d);

	Acad::ErrorStatus			readItem(void* pBuf, Adesk::UInt32 nLen) {return Acad::eOk;}
	Acad::ErrorStatus			writeItem(const void* pBuf, Adesk::UInt32 nLen);

	Acad::ErrorStatus			readItem(void** ppBuf) {return Acad::eOk;}
	Acad::ErrorStatus			writeItem(const void * pBuf);

#if ARX<18
	virtual Acad::ErrorStatus   seek(long offset, int method) {return Acad::eOk;}
	virtual        long			tell() const {return 0;}
#endif

	int							ReadLinesByLockedSerialDNA(CStringArray& arLockDNA,CStringArray& arLines);
	BOOL						ReadDNASegmentInSection(CStringArray& arLockDNA,CStringArray& arLines,LPCTSTR pszDNAType,LPCTSTR pszDNATypeBefor);

	int							FindPositionByDNATypes(CStringArray& arLockDNA);
	BOOL						ReadDNAAtPosition(int& nIndex,CString& sDNAType,CString& sLine);

	AecXDataMap*				FormatDataMap();

protected:

	AcDb::FilerType		m_filerType;		//文件器内容	

	//等长
	CStringArray		m_arItemLines;		//记录
	CStringArray		m_arSerialDNA;		//序列化DNA

	CArray<binary_buf>  m_arBinaryBufs;		//二进制数据
	AecXDataMap*		m_pxDataMap;
};	

#endif //_KTEXTRACTDWGFILER_H__