//========= Copyright c 1996-2008, Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//=============================================================================//
#ifndef DATA_LINKER_INTERFACE_H
#define DATA_LINKER_INTERFACE_H


#include "tier0/platform.h"
#include "tier0/basetypes.h"
#include "tier0/dbg.h"



template <uint nAlignment = 1, uint nCookie = 0>
struct DataLinkerClassProperties
{
	enum {kDataAlignment = nAlignment};
	enum {kDataCookie = nCookie};// 0 means no cookie
};

template <typename T>
struct DataLinkerClassPropertiesSelector: public DataLinkerClassProperties<sizeof(T)&1?1:sizeof(T)&3?2:4> // heuristic: 1-, 2- and 4-byte aligned type size calls for 1-, 2- and 4-byte alignment by default
{
};



//#define DATALINKER_ALIGNMENT(ALIGNMENT) enum {kDataAlignment = ALIGNMENT}


#define DATALINKER_CLASS_ALIGNMENT(CLASS, ALIGNMENT) template <> struct DataLinkerClassPropertiesSelector<CLASS> {enum {kDataAlignment = ALIGNMENT};}

DATALINKER_CLASS_ALIGNMENT(float,4);
DATALINKER_CLASS_ALIGNMENT(int32,4);
DATALINKER_CLASS_ALIGNMENT(int16,2);
DATALINKER_CLASS_ALIGNMENT(int8,1);
DATALINKER_CLASS_ALIGNMENT(uint32,4);
DATALINKER_CLASS_ALIGNMENT(uint16,2);
DATALINKER_CLASS_ALIGNMENT(uint8,1);

// undefine DATALINKER_CHECK_COOKIES if you don't want runtime cookie checks
#define DATALINKER_CHECK_COOKIES

namespace DataLinker
{


inline byte *ResolveOffset(int32 *pOffset)
{
	int offset = *pOffset;
	return offset ? ((byte*)pOffset) + offset : NULL;
}

inline byte *ResolveOffsetFast(const int32 *pOffset)
{
	int offset = *pOffset;
	Assert(offset != 0);
	return ((byte*)pOffset) + offset;
}




// AT RUN-TIME ONLY the offset converts automatically into pointers to the appropritate type 
// at tool-time, you should use LinkSource_t and LinkTarget_t
template <typename T, int32 nCookie = 0>
struct Offset_t
{
	enum {kDataAlignment = 4};

	int32 offset;
	bool operator == (int zero)const {Assert(zero == 0); return offset == zero;}
	bool IsNull()const {return offset == 0;}
	int32 NotNull()const {return offset;}
	const T* GetPtr()const
	{
		// validate
		byte *ptr = ResolveOffsetFast(&offset);
#ifdef DATALINKER_CHECK_COOKIES
		if(nCookie)
		{
			if(nCookie != ((int*)ptr)[-1])
			{
				Error("Invalid data cookie %d != %d\n", ((int*)ptr)[-1], nCookie);
			}
		}
#endif
		return (const T*)ptr;
	}
	//const T* GetPtrFast()const {return (const T*)ResolveOffsetFast(&offset);}
	operator const T* ()const{return GetPtr();}
	const T* operator ->() const{return GetPtr();}
};

template <typename T,int32 nCookie = 0>
struct OffsetAndSize_t: public Offset_t<T,nCookie>
{
	int32 size;

	const T& operator []( int index ) const
	{
		Assert(index < size);
		return this->GetPtr()[index];
	}
};

template <typename T,int32 nCookie = 0>
struct OffsetSizeAndStride_t : public OffsetAndSize_t<T,nCookie>
{
	int32 stride;
	const T& operator []( int index ) const
	{
		Assert(index < this->size);
		return *(const T*)(ResolveOffsetFast(&this->offset) + stride * index);
	}
};


enum {kSpecialTargetUndefined = -1};
enum {kSpecialTargetNull = 0};
enum {kSpecialTargetDefault = 1};// resolved pointer/offset right in the LinkSource 

// this is resolved or unresolved reference within the data block
// it's unique for the life cycle of the Stream and must either be resolved or
// never referenced by the end
struct LinkTarget_t
{
	int m_id;
	friend class Stream;
	LinkTarget_t(){m_id = kSpecialTargetUndefined;} // -1 is anonymous/undefined reference
};



struct LinkTargetNull_t: public LinkTarget_t
{
	LinkTargetNull_t(){m_id = kSpecialTargetNull;} // 0 is special default case meaning null pointer/offset 
};

/*
template <typename T>
struct Target_t
{
	T* m_ptr;
	operator T* () {return m_ptr;}
	T* operator -> () {return m_ptr;}
};
*/

struct LinkSource_t
{
protected:
	int m_offset;
	friend class Stream;
	LinkSource_t(){}
};




enum OffsetTypeEnum
{
	kOtRelative32bit,
	kOtRelative16bit,
	kOtAbsolute32bit
};


//////////////////////////////////////////////////////////////////////////
// this class may be useful at runtime to use fast serialize interface (without data linking)
// 
abstract_class IBasicStream
{
public:
	virtual void* WriteBytes(uint numBytes) = 0;

	virtual void Align(uint nAlignment, int nOffset = 0) = 0;
	inline void AlignPointer(){Align(4);}
	virtual long Tell() = 0;

	// the Begin/End semantics differ in different implementations
	// in some, it can be ignored, some others can use it for statistics and some others may set fixed page boundaries based on the names and/or flags 
	virtual void Begin(const char *nName, uint flags = 0) = 0;
	virtual void End() = 0;
	virtual void PrintStats() = 0;
	virtual void ClearStats() = 0;

	template <typename T>
	T* Write(uint count = 1);

	template <typename T, int32 nCookie>
	T* WriteWithCookie(uint count = 1);

	template <typename T, int32 nCookie>
	T* WriteWithCookieStrided(uint count, uint stride);

	template <typename T>
	void WriteSimple(const T x)
	{
		*Write<T>() = x;
	}

	virtual void EnsureAvailable(uint addCapacity) = 0;

	inline void WriteFloat(float x)
	{
		WriteSimple(x);
	}
	inline void WriteU32(uint32 x)
	{
		WriteSimple(x);
	}
	inline void WriteU16(uint16 x) 
	{
		WriteSimple(x);
	}
	inline void WriteByte(byte x)
	{
		WriteSimple(x);
	}

};


//////////////////////////////////////////////////////////////////////////
// this is light-weight version of IStream with Links
// It can link on-the-fly, has minimal overhead but cannot late-bind symbols
// you basically have to manage all your late-bindings by managing 
// pointers to offsets, which is fine in 99% of use cases.
// WARNING: there are no error-checking facilities here. If you forget to set 
//          a link, you'll have a NULL offset and no warnings or errors
//
abstract_class IStream: public IBasicStream
{
public:
	template <typename T,int32 nCookie>	T* WriteAndLink(Offset_t<T,nCookie>*pOffset, uint count = 1);
	template <typename T,int32 nCookie>	T* WriteAndLink(OffsetAndSize_t<T,nCookie>*pOffset, uint count = 1); // intentionally not implemented - use explicit WriteAndLinkArray()
	template <typename T,int32 nCookie>	T* WriteAndLinkArray(OffsetAndSize_t<T,nCookie>*pOffsetAndSize, uint count = 1);
	template <typename T,int32 nCookie>	T* WriteAndLinkStrided(OffsetSizeAndStride_t<T,nCookie>*pOffset, uint nStride, uint count = 1);
	template <typename T,int32 nCookie>	void Link(Offset_t<T,nCookie>*pOffset, const T* pTarget);

	virtual void Link(int32 *pOffset, const void *pTarget) = 0;
	virtual void Link(int16 *pOffset, const void *pTarget) = 0;

	virtual bool Compile(void *pBuffer) = 0;
	virtual uint GetTotalSize()const = 0;
};


//////////////////////////////////////////////////////////////////////////
// This is IStream with late-binding capabilities. You can link multiple sources to 
// the same target, then change your mind and reset the target somewhere and it'll
// automatically track all sources and reset them to the latest target at compilation.
// You can create unresolved targets to resolve them later.
// You can extend this to multiple object files linked at later stage (szDescription 
// must be unique identifiers)
// 
abstract_class ILinkStream: public IStream
{
public:
	virtual LinkSource_t WriteOffset(const char *szDescription) = 0;
	virtual LinkSource_t WriteOffset(LinkTarget_t linkTarget, const char *szDescription) = 0;
	virtual LinkSource_t WriteNullOffset(const char *szDescription) = 0;

	virtual void Link(LinkSource_t, LinkTarget_t, const char *szDescription) = 0;
	virtual LinkSource_t LinkToHere(int32 *pOffset, const char *szDescription) = 0;
	virtual LinkSource_t Link(int32 *pOffset, LinkTarget_t linkTarget, const char *szDescription) = 0;

	virtual LinkTarget_t NewTarget() = 0; // create new, unresolved target
	virtual LinkTarget_t NewTarget(void *pWhere) = 0;
	virtual LinkTarget_t NewTargetHere() = 0; // creates a target right here
	virtual void SetTargetHere(LinkTarget_t) = 0; // sets the given target to point to right here
	virtual void SetTargetNull(LinkTarget_t) = 0; // set this target to point to NULL
	virtual LinkSource_t NewOffset(int *pOffset, const char *szDescription) = 0;

	virtual bool IsDeclared(LinkTarget_t linkTarget)const = 0;
	virtual bool IsSet(LinkTarget_t linkTarget)const = 0;
	virtual bool IsDefined(LinkSource_t linkSource)const = 0;
	virtual bool IsLinked(LinkSource_t linkSource)const = 0;
};



template <typename T>
inline T* IBasicStream::Write(uint count)
{
	// TODO: insert reflection code here
	uint nAlignment = DataLinkerClassPropertiesSelector<T>::kDataAlignment;
	Align(nAlignment);
	return (T*)WriteBytes(count * sizeof(T));
}



template <typename T, int32 nCookie>
inline T* IBasicStream::WriteWithCookie(uint count)
{
	// TODO: insert reflection code here
	uint nAlignment = DataLinkerClassPropertiesSelector<T>::kDataAlignment;

	if(nCookie)
	{
		if(nAlignment > sizeof(int32))
		{
			Align(nAlignment, -4);
		}
		else
		{
			Align(sizeof(int32));// we want the cookie itself aligned properly
		}
		WriteSimple<int32>(nCookie);
		Assert((Tell()&(nAlignment-1)) == 0); // must be correctly aligned by now
	}
	else
	{
		if(nAlignment > 1)
		{
			Align(nAlignment);
		}
	}
	return (T*)WriteBytes(count * sizeof(T));
}


template <typename T, int32 nCookie>
inline T* IBasicStream::WriteWithCookieStrided(uint count, uint stride)
{
	// TODO: insert reflection code here
	uint nAlignment = DataLinkerClassPropertiesSelector<T>::kDataAlignment;

	if(nCookie)
	{
		if(nAlignment > sizeof(int32))
		{
			Align(nAlignment, -4);
		}
		else
		{
			Align(sizeof(int32));// we want the cookie itself aligned properly
		}
		WriteSimple<int32>(nCookie);
		Assert((Tell()&(nAlignment-1)) == 0); // must be correctly aligned by now
	}
	else
	{
		if(nAlignment > 1)
		{
			Align(nAlignment);
		}
	}
	if(count)
		return (T*)WriteBytes((count-1) * stride + sizeof(T));
	else
		return (T*)WriteBytes(0);
}


template <typename T,int32 nCookie>
inline void IStream::Link(Offset_t<T,nCookie>*pOffset, const T* pTarget)
{
	Link(&pOffset->offset, pTarget);
}


template <typename T, int32 nCookie>
inline T* IStream::WriteAndLink(Offset_t<T,nCookie>*pOffset, uint count)
{
	T* p = WriteWithCookie<T,nCookie>(count);
	Link(&pOffset->offset, p);
	return p;
}

template <typename T, int32 nCookie>
inline T* IStream::WriteAndLinkArray(OffsetAndSize_t<T,nCookie>*pOffsetAndSize, uint count)
{
	pOffsetAndSize->size = count;
	if(count)
	{
		T* p = WriteWithCookie<T,nCookie>(count);
		Link(&pOffsetAndSize->offset, p);
		return p;
	}
	else
	{
		pOffsetAndSize->offset = 0;
		return NULL;
	}
}

template <typename T, int32 nCookie>
inline T* IStream::WriteAndLinkStrided(OffsetSizeAndStride_t<T,nCookie>*pOffset, uint stride, uint count)
{
	pOffset->size = count;
	pOffset->stride = stride;
	if(count)
	{
		T* p = WriteWithCookieStrided<T,nCookie>(count, stride);
		Link(&pOffset->offset, p);
		return p;
	}
	else
	{
		pOffset->offset = 0;
		return NULL;
	}
}



}


struct DataLinkerBasicStreamRange_t
{
	DataLinker::IBasicStream *m_pStream;
	DataLinkerBasicStreamRange_t(DataLinker::IBasicStream  *pStream, const char *name): m_pStream(pStream){pStream->Begin(name);}
	~DataLinkerBasicStreamRange_t(){m_pStream->End();}
};

#define DATALINKER_RANGE(STREAM,NAME) DataLinkerBasicStreamRange_t dataLinker_basicStreamRange##__LINE((STREAM),(NAME))

#endif