#ifndef _MIDISEQ_PUREEVENT_HPP_
#define _MIDISEQ_PUREEVENT_HPP_
#ifndef _COMMON_WINDOWS_HPP_
#include <common/windows.hpp>
#endif
#ifndef _COMMON_STRING_HPP_
#include <common/string.hpp>
#endif
#ifndef _MIDISEQ_MIDICHANNELMESSAGE_HPP_
#include <midiseq/midimsg.hpp>
#endif

class PureEvent
{
public:
	PureEvent(void);
	PureEvent(const PureEvent &somePureEvent);
  PureEvent(BYTE eventType,DWORD deltaTime,BYTE channel,BYTE firstData,BYTE secondData);
	virtual ~PureEvent();
	BYTE eventType(void)const;
	DWORD deltaTime(void)const;
  DWORD playTime(void)const;
	BYTE channel(void)const;
	BYTE firstData(void)const;
	BYTE secondData(void)const;
	DWORD midiTime(void)const;
	void eventType(BYTE eventType);
	void deltaTime(DWORD deltaTime);
  void playTime(DWORD playTime);
	void channel(BYTE channel);
	void firstData(BYTE firstData);
	void secondData(BYTE secondData);
  void midiTime(DWORD midiTime);
	WORD operator==(const PureEvent &somePureEvent)const;
  WORD operator<(const PureEvent &somePureEvent)const;
  WORD operator>(const PureEvent &somePureEvent)const;
	String toString(void)const;
  PureEvent &operator=(const PureEvent &somePureEvent);
private:
	BYTE mEventType;
	DWORD mDeltaTime;
	BYTE mChannel;
	BYTE mFirstData;
	BYTE mSecondData;
	DWORD mPlayTime;
	DWORD mMIDITime;
};

inline
PureEvent::PureEvent(void)
: mEventType(0), mDeltaTime(0L), mChannel(0), mFirstData(0), mSecondData(0),
	mPlayTime(0L), mMIDITime(0L)
{
}

inline
PureEvent::PureEvent(const PureEvent &somePureEvent)
: mEventType(somePureEvent.mEventType), mDeltaTime(somePureEvent.mDeltaTime),
	mPlayTime(somePureEvent.mPlayTime), mChannel(somePureEvent.mChannel),
	mFirstData(somePureEvent.mFirstData), mSecondData(somePureEvent.mSecondData),
  mMIDITime(somePureEvent.mMIDITime)
{
}

inline
PureEvent::PureEvent(BYTE eventType,DWORD deltaTime,BYTE channel,BYTE firstData,BYTE secondData)
: mEventType(eventType), mDeltaTime(deltaTime), mChannel(channel), mFirstData(firstData),
  mSecondData(secondData), mPlayTime(0L), mMIDITime(0L)
{
}

inline
PureEvent::~PureEvent()
{
}

// accessors

inline
BYTE PureEvent::eventType(void)const
{
	return mEventType;
}

inline
DWORD PureEvent::deltaTime(void)const
{
  return mDeltaTime;
}

inline
DWORD PureEvent::playTime(void)const
{
  return mPlayTime;
}

inline
DWORD PureEvent::midiTime(void)const
{
  return mMIDITime;
}

inline
BYTE PureEvent::channel(void)const
{
	return mChannel;
}

inline
BYTE PureEvent::firstData(void)const
{
  return mFirstData;
}

inline
BYTE PureEvent::secondData(void)const
{
  return mSecondData;
}

// mutators

inline
void PureEvent::eventType(BYTE eventType)
{
	mEventType=eventType;
}

inline
void PureEvent::deltaTime(DWORD deltaTime)
{
  mDeltaTime=deltaTime;
}

inline
void PureEvent::playTime(DWORD playTime)
{
  mPlayTime=playTime;
}

inline
void PureEvent::midiTime(DWORD midiTime)
{
	mMIDITime=midiTime;
}

inline
void PureEvent::channel(BYTE channel)
{
	mChannel=channel;
}

inline
void PureEvent::firstData(BYTE firstData)
{
	mFirstData=firstData;
}

inline
void PureEvent::secondData(BYTE secondData)
{
	mSecondData=secondData;
}

// comparators

inline
WORD PureEvent::operator==(const PureEvent &somePureEvent)const
{
  return mPlayTime==somePureEvent.mPlayTime&&eventType()==somePureEvent.eventType();
/*	return (mEventType==somePureEvent.mEventType&&
					mChannel==somePureEvent.mChannel&&
					mFirstData==somePureEvent.mFirstData&&
					mSecondData==somePureEvent.mSecondData&&
					mDeltaTime==somePureEvent.mDeltaTime&&
					mPlayTime==somePureEvent.mPlayTime&&
					mMIDITime==somePureEvent.mMIDITime);
*/
}

inline
PureEvent &PureEvent::operator=(const PureEvent &somePureEvent)
{
	eventType(somePureEvent.eventType());
	deltaTime(somePureEvent.deltaTime());
	playTime(somePureEvent.playTime());
  midiTime(somePureEvent.midiTime());
	channel(somePureEvent.channel());
	firstData(somePureEvent.firstData());
	secondData(somePureEvent.secondData());
  return *this;
}

inline
WORD PureEvent::operator<(const PureEvent &somePureEvent)const
{
  if(mPlayTime==somePureEvent.mPlayTime&&eventType()==somePureEvent.eventType())return false;
  if(mPlayTime==somePureEvent.mPlayTime&&eventType()==MIDINoteOff)return true;
	else if(mPlayTime==somePureEvent.mPlayTime)return false;
  return (mPlayTime<somePureEvent.mPlayTime);
}

inline
WORD PureEvent::operator>(const PureEvent &somePureEvent)const
{
  if(mPlayTime==somePureEvent.mPlayTime&&eventType()==somePureEvent.eventType())return false;
  if(mPlayTime==somePureEvent.mPlayTime&&eventType()==MIDINoteOn)return true;
	else if(mPlayTime==somePureEvent.mPlayTime)return false;
  return (mPlayTime>somePureEvent.mPlayTime);
}
#endif