#ifndef RIPPLE_FIELDNAMES_H
#define RIPPLE_FIELDNAMES_H

// VFALCO TODO lose the macro.
#define FIELD_CODE(type, index) ((static_cast<int>(type) << 16) | index)

enum SerializedTypeID
{
	// special types
	STI_UNKNOWN		= -2,
	STI_DONE		= -1,
	STI_NOTPRESENT	= 0,

#define TYPE(name, field, value) STI_##field = value,
#define FIELD(name, field, value)
#include "../protocol/ripple_SerializeDeclarations.h"
#undef TYPE
#undef FIELD

	// high level types
	STI_TRANSACTION = 10001,
	STI_LEDGERENTRY	= 10002,
	STI_VALIDATION	= 10003,
};

// VFALCO TODO rename this to NamedField
class SField
{
public:
	typedef const SField&	ref;
	typedef SField const *	ptr;

	static const int sMD_Never			= 0x00;
	static const int sMD_ChangeOrig		= 0x01; // original value when it changes
	static const int sMD_ChangeNew		= 0x02; // new value when it changes
	static const int sMD_DeleteFinal	= 0x04; // final value when it is deleted
	static const int sMD_Create			= 0x08; // value when it's created
	static const int sMD_Always			= 0x10; // value when node containing it is affected at all
	static const int sMD_Default		= sMD_ChangeOrig | sMD_ChangeNew | sMD_DeleteFinal | sMD_Create;

public:

	const int				fieldCode;		// (type<<16)|index
	const SerializedTypeID	fieldType;		// STI_*
	const int				fieldValue;		// Code number for protocol
	std::string				fieldName;
	int						fieldMeta;
	int						fieldNum;
	bool					signingField;

	SField(int fc, SerializedTypeID tid, int fv, const char* fn) : 
		fieldCode(fc), fieldType(tid), fieldValue(fv), fieldName(fn), fieldMeta(sMD_Default), signingField(true)
	{
		boost::mutex::scoped_lock sl(mapMutex);
		codeToField[fieldCode] = this;
		fieldNum = ++num;
	}

	SField(SerializedTypeID tid, int fv, const char *fn) :
		fieldCode(FIELD_CODE(tid, fv)), fieldType(tid), fieldValue(fv), fieldName(fn),
		fieldMeta(sMD_Default), signingField(true)
	{
		boost::mutex::scoped_lock sl(mapMutex);
		codeToField[fieldCode] = this;
		fieldNum = ++num;
	}

	SField(int fc) : fieldCode(fc), fieldType(STI_UNKNOWN), fieldValue(0), fieldMeta(sMD_Never), signingField(true)
	{
		boost::mutex::scoped_lock sl(mapMutex);
		fieldNum = ++num;
	}

	~SField();

	static SField::ref getField(int fieldCode);
	static SField::ref getField(const std::string& fieldName);
	static SField::ref getField(int type, int value)				{ return getField(FIELD_CODE(type, value)); }
	static SField::ref getField(SerializedTypeID type, int value)	{ return getField(FIELD_CODE(type, value)); }

	std::string getName() const;
	bool hasName() const		{ return !fieldName.empty(); }

	bool isGeneric() const		{ return fieldCode == 0; }
	bool isInvalid() const		{ return fieldCode == -1; }
	bool isUseful() const		{ return fieldCode > 0; }
	bool isKnown() const		{ return fieldType != STI_UNKNOWN; }
	bool isBinary() const		{ return fieldValue < 256; }
	bool isDiscardable() const	{ return fieldValue > 256; }
	int getCode() const			{ return fieldCode; }
	int getNum() const			{ return fieldNum; }
	static int getNumFields()	{ return num; }

	bool isSigningField() const		{ return signingField; }
	void notSigningField()			{ signingField = false; }
	bool shouldMeta(int c) const	{ return (fieldMeta & c) != 0; }
	void setMeta(int c)				{ fieldMeta = c; }

	bool shouldInclude(bool withSigningField) const
		{ return (fieldValue < 256) && (withSigningField || signingField); }

	bool operator==(const SField& f) const { return fieldCode == f.fieldCode; }
	bool operator!=(const SField& f) const { return fieldCode != f.fieldCode; }

	static int compare(SField::ref f1, SField::ref f2);

    // VFALCO TODO make these private
protected:
	static std::map<int, ptr>	codeToField;
	static boost::mutex			mapMutex;
	static int 					num;

	SField(SerializedTypeID id, int val);
};

extern SField sfInvalid, sfGeneric, sfLedgerEntry, sfTransaction, sfValidation;

#define FIELD(name, type, index) extern SField sf##name;
#define TYPE(name, type, index)
#include "../protocol/ripple_SerializeDeclarations.h"
#undef FIELD
#undef TYPE

#endif