#include <common/math.hpp>
#include <midiseq/miditrck.hpp>

WORD MidiTrack::readTrack(void)
{
  mBytesRead=0;
	if(PureHeader::Unset==mTimingMethod)return FALSE;
	if(!mMidiFile.read(mTrack,sizeof(mTrack)))return FALSE;
	if(::strncmp(mTrack,"MTrk",sizeof(mTrack)))return FALSE;
	if(!mMidiFile.read(mLengthData))return FALSE;
	if(!mLengthData)return FALSE;
	readTime();
	while(mBytesRead<mLengthData)
	{
		if(!mMidiFile.read(mEventType))return TRUE;
    mBytesRead++;
		if(!handleEvent())return TRUE;
		if(mBytesRead>=mLengthData)break;
		if(NullEvent==mRunningEvent){readTime();mLastEventType=mEventType;}
    else mLastEventType=mRunningEvent;
	}
  return TRUE;
}

void MidiTrack::readTime(void)
{
	switch(mTimingMethod)
	{
		case PureHeader::DeltaTime :
    case PureHeader::TimeCode :
			mDeltaTime=readVarLength();
			break;
	}
}

WORD MidiTrack::handleEvent(void)
{
  WORD returnCode;

	switch(mEventType)
	{
		case MetaEvent :
      mRunningEvent=NullEvent;
			returnCode=handleMetaEvent();
			break;
		case SystemExclusiveOne :
		case SystemExclusiveTwo :
      mRunningEvent=NullEvent;
      returnCode=handleSystemExclusiveEvent();
			break;
		default :
      returnCode=handleMIDIChannelMessage();
			break;
	}
  return returnCode;
}

WORD MidiTrack::isChannelMessage(BYTE eventType)const
{
	BYTE status((eventType>>4)&0x0F);

	if((status<=0x07)||(0x0F==status))return FALSE;
	if((status>=0x08&&status<=0x0B)||(status==0x0E))return 2;
  return 1;
}

WORD MidiTrack::handleMIDIChannelMessage(void)
{
  WORD returnCode;

	if(isRunningStatus(mEventType))
	{
		if(NullEvent==mRunningEvent)mRunningEvent=mLastEventType;
		mEventType=mLastEventType;
	}
	else mRunningEvent=NullEvent;
	if(isChannelMessage(mEventType))returnCode=processMIDIChannelMessage();
  else returnCode=FALSE;
  return returnCode;
}

WORD MidiTrack::handleMetaEvent(void)
{
	BYTE entryType;
  WORD returnCode(TRUE);

	if(!mMidiFile.read(entryType))return FALSE;
  mBytesRead++;
	switch(entryType)
	{
		case SequenceNumberEvent :
			returnCode=handleMetaSequenceNumberEvent();
			break;
		case TextEvent :
			returnCode=handleMetaTextEvent();
			break;
		case CopyrightNotice :
      returnCode=handleMetaTextEvent();
			break;
		case SequenceTrackName :
      handleGenericMetaEvent();      
			break;
		case InstrumentName :
      handleGenericMetaEvent();
			break;
		case Lyric :
			handleGenericMetaEvent();
			break;
		case Marker :
			handleGenericMetaEvent();
			break;
		case CuePoint :
			handleGenericMetaEvent();
			break;
		case ChannelPrefix :
			handleChannelPrefix();
      break;
		case EndOfTrack :
			handleGenericMetaEvent();
			returnCode=FALSE;
			break;
		case SetTempo :
      handleSetTempoEvent();
			break;
		case SMPTEFormatSpec :
      handleSMPTEFormatEvent();
			break;
		case TimeSignature :
      handleTimeSignatureEvent();
			break;
		case KeySignature :
			handleGenericMetaEvent();
			break;
		case SequencerSpecificMetaEvent :
			handleGenericMetaEvent();
			break;
		default :
			handleGenericMetaEvent();
     break;
	}
	return returnCode;
}

WORD MidiTrack::handleSystemExclusiveEvent(void)
{
  return handleGenericMetaEvent();
}

WORD MidiTrack::handleMetaSequenceNumberEvent(void)
{
	WORD sequenceNumber;

	if(!mMidiFile.read(sequenceNumber))return FALSE;
	mBytesRead++;
	return TRUE;
}

WORD MidiTrack::handleMetaTextEvent(void)
{
	BYTE textLength;
	BYTE textByte;

	if(!mMidiFile.read(textLength))return FALSE;
  mBytesRead++;
	for(short index=0;index<textLength;index++){if(!mMidiFile.read(textByte))return FALSE;mBytesRead++;}
	return TRUE;
}

WORD MidiTrack::handleSetTempoEvent(void)
{
	DWORD microsecsPerQtrNote(0L);
  BYTE tempoBytes[TempoEventLength];
	short entryLength;

	entryLength=(short)readVarLength();
	if(sizeof(tempoBytes)!=entryLength)return FALSE;
	if(!mMidiFile.read(tempoBytes,sizeof(tempoBytes)))return FALSE;
	microsecsPerQtrNote+=(DWORD)tempoBytes[0]*65536L;
	microsecsPerQtrNote+=(DWORD)tempoBytes[1]*256L;
	microsecsPerQtrNote+=(DWORD)tempoBytes[2];
  setTempo(microsecsPerQtrNote);
  return TRUE;
}

WORD MidiTrack::handleTimeSignatureEvent(void)
{
  BYTE tsBytes[TimeInfo::LengthTimeInfo];

	if(TimeInfo::LengthTimeInfo!=readVarLength())return FALSE;
	if(!mMidiFile.read(tsBytes,sizeof(tsBytes)))return FALSE;
	TimeInfo midiTimeSignature(tsBytes[0],Math::power(2,tsBytes[1]),tsBytes[2],tsBytes[3]);
  timeSignature(midiTimeSignature);
  return TRUE;
}

WORD MidiTrack::handleSMPTEFormatEvent(void)
{
  SMPTEFormat smpteFormatInfo;
	short entryLength;

	if(sizeof(SMPTEFormat::SMPTEFormatLength)!=readVarLength())return FALSE;
  smpteFormatInfo<<mMidiFile;
  smpteFormat(smpteFormatInfo);
  return TRUE;
}

WORD MidiTrack::handleChannelPrefix(void)
{
	BYTE charByte;
	short entryLength;

	entryLength=readVarLength();
	for(short index=0;index<entryLength;index++){if(!mMidiFile.read(charByte))return FALSE;mBytesRead++;}
  return TRUE;
}

WORD MidiTrack::handleGenericMetaEvent(void)
{
	BYTE charByte;
	short entryLength;

	entryLength=(short)readVarLength();
	for(short index=0;index<entryLength;index++){if(!mMidiFile.read(charByte))return FALSE;mBytesRead++;}
	return TRUE;
}

WORD MidiTrack::processMIDIChannelMessage(void)
{
	WORD returnCode(TRUE);
	BYTE channel;
	BYTE messageDataOne;
	BYTE messageDataTwo;
	BYTE requiredDataBytes;

	channel=mEventType&0x0F;
	requiredDataBytes=isChannelMessage(mEventType);
	switch(mEventType&0xF0)
	{
		case MIDIProgramChange :
			mMidiFile.read(messageDataOne);
			messageDataOne&=0x7F;
			midiChannelMessage(PureEvent(mEventType,mDeltaTime,channel,messageDataOne,0));
			mBytesRead++;
			break;
		case MIDINoteOff :
		  if(PureNote::PureNoteLength!=requiredDataBytes){returnCode=FALSE;break;}
			mNoteOff<<mMidiFile;
			mNoteOff.pitch(mNoteOff.pitch()&0x7F);
      mNoteOff.velocity(mNoteOff.velocity()&0x7F);
			midiChannelMessage(PureEvent(mEventType,mDeltaTime,channel,mNoteOff.pitch(),mNoteOff.velocity()));
			mBytesRead+=PureNote::PureNoteLength;
			break;
		case MIDINoteOn :
		  if(PureNote::PureNoteLength!=requiredDataBytes){returnCode=FALSE;break;}
			mNoteOn<<mMidiFile;
			mNoteOn.pitch(mNoteOn.pitch()&0x7F);
      mNoteOn.velocity(mNoteOn.velocity()&0x7F);
			midiChannelMessage(PureEvent(mEventType,mDeltaTime,channel,mNoteOn.pitch(),mNoteOn.velocity()));
			mBytesRead+=PureNote::PureNoteLength;
			break;
		case MIDIKeyPressure :
			if(2!=requiredDataBytes){returnCode=FALSE;break;}
			mMidiFile.read(messageDataOne);
			mMidiFile.read(messageDataTwo);
			messageDataOne&=0x7F;
      messageDataTwo&=0x7F;
			midiChannelMessage(PureEvent(mEventType,mDeltaTime,channel,messageDataOne,messageDataTwo));
			mBytesRead+=requiredDataBytes;
			break;
		case MIDIParameter :
			if(2!=requiredDataBytes){returnCode=FALSE;break;}
			mMidiFile.read(messageDataOne);
			mMidiFile.read(messageDataTwo);
			messageDataOne&=0x7F;
      messageDataTwo&=0x7F;
			midiChannelMessage(PureEvent(mEventType,mDeltaTime,channel,messageDataOne,messageDataTwo));
			mBytesRead+=requiredDataBytes;
			break;
		case MIDIPitchBend :
			if(2!=requiredDataBytes){returnCode=FALSE;break;}
			mMidiFile.read(messageDataOne);
			mMidiFile.read(messageDataTwo);
			messageDataOne&=0x7F;
      messageDataTwo&=0x7F;
			midiChannelMessage(PureEvent(mEventType,mDeltaTime,channel,messageDataOne,messageDataTwo));
			mBytesRead+=requiredDataBytes;
			break;
		case MIDIChannelPressure :
			if(1!=requiredDataBytes){returnCode=FALSE;break;}
			mMidiFile.read(messageDataOne);
      messageDataOne&=0x7F;
			midiChannelMessage(PureEvent(mEventType,mDeltaTime,channel,messageDataOne,0));
			mBytesRead++;
			break;
		default :
			returnCode=FALSE;
			break;
	}
	return returnCode;
}

DWORD MidiTrack::readVarLength(void)
{
	DWORD valueData(0L);
	BYTE byteValue;

	while(TRUE)
	{
		mMidiFile.read(byteValue);
		mBytesRead++;
		valueData=(valueData*0x80)+(byteValue&0x7F);
		if(!(byteValue&0x80))break;
	}
	return valueData;
}

// virtuals

void MidiTrack::setTempo(DWORD /*microsecondsPerQuarterNote*/)
{
	return;
}

void MidiTrack::midiChannelMessage(PureEvent &/*channelEvent*/)
{
	return;
}

void MidiTrack::timeSignature(const TimeInfo &/*someTimeInfo*/)
{
	return;
}

void MidiTrack::smpteFormat(const SMPTEFormat &/*someSMPTEFormat*/)
{
  return;
}