/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  
*
*/


#ifndef PROFILERGENERICCLASSESKRN_H
#define PROFILERGENERICCLASSESKRN_H

	#include <piprofiler/ProfilerGenericClassesCommon.h>
	#include <piprofiler/ProfilerTraces.h>

	#include <e32cmn.h>

	#define PROFILER_KERNEL_MODE

#ifdef PROFILER_KERNEL_MODE
class DProfilerSampleBuffer;

class DProfilerSampleStream
    {
public:
		DProfilerSampleStream();
		~DProfilerSampleStream();

		void InsertCurrentClient(DThread* aClient);
		void AddSampleBuffer(TBapBuf* aBuffer,TRequestStatus* aStatus);
		void ReleaseIfPending();

		void AddSamples(DProfilerSampleBuffer& aBuffer, TInt aSamplerId);
		TInt EndSampling(DProfilerSampleBuffer& aBuffer,TInt aSamplerId);

		void PerformCopy(TUint8 aSamplerId,TUint8* aSrc,TPtr8* dst,TInt aOffset,TInt aAmount);

private:
		TBapBuf*			iCurrentBuffer;
		TRequestStatus*		iPendingRequest;
		DThread*			iClient;
		TInt				iAddingSamples;
    };

class DProfilerSampleBuffer : public DBase
    {
		friend class DProfilerSampleStream;
public:

			enum ProfilerBufferStatus 
			    {
				BufferOk,
				BufferCopyAsap,
				BufferBeingCopied,
				BufferFull,
				BufferDataEnd
			    };

			DProfilerSampleBuffer(TUint8* aBuffer, TUint8* aDblBuffer, TUint32 aSize);
			~DProfilerSampleBuffer();	
			TInt	AddSample(TUint8* aSample, TUint32 aLength);
			TUint32 GetBufferStatus();
			void	ClearBuffer();
			void	EndSampling();
			void	DataCopied();

			TUint32 iBufferStatus;
private:
			TUint32 iBytesWritten;
			TUint32 iDblBytesWritten;
			TUint32 iDblBytesRead;

			TUint32 iBufferDataSize;
			TUint32 iBufferRealSize;

			TProfilerSampleBufStruct* iDblBufStruct;
			TProfilerSampleBufStruct* iBufStruct;
    };

#endif


 
/*
 *	
 *	Abstract class CProfilerSamplerBase definition
 *	
 */

#ifdef PROFILER_KERNEL_MODE
class DProfilerSamplerBase : public DBase
    {
public:
	DProfilerSamplerBase();
			virtual					~DProfilerSamplerBase();

			virtual	TInt			Initialise() = 0;
			virtual	void			Sample() = 0;
			virtual TBool			PostSampleNeeded() = 0;
			virtual TInt			PostSample() = 0;
			virtual TInt			EndSampling() = 0;

			virtual TInt			Reset(DProfilerSampleStream* aStream = 0, TUint32 aSyncOffset = 0) = 0;

			virtual void			SetEnabledFlag(TBool aFlag) = 0;
			virtual TBool			GetEnabledFlag() = 0;
			virtual void			SetOutputCombination(TInt aSettings) = 0;
			virtual void 			SetSamplingPeriod(TInt aSettings) = 0;
			virtual void			SetAdditionalSettings(TInt aSettings) = 0;
			virtual void			SetAdditionalSettings2(TInt aSettings) = 0;
			virtual void			SetAdditionalSettings3(TInt aSettings) = 0;
			virtual void			SetAdditionalSettings4(TInt aSettings) = 0;

			TInt					iSamplerId;
			TInt					iOutputCombination;
			TBool					iEnabled;
    };

/*
 *	
 *	Template abstract class CProfilerGenericSampler definition
 *	
 */

// size parameter given defines the explicit buffer size in bytes for this sampler
template <int BufferSize> 
class DProfilerGenericSampler : public DProfilerSamplerBase
    {
public:
			DProfilerGenericSampler(TInt aSamplerId);
			virtual					~DProfilerGenericSampler();

			TInt					Initialise();
			virtual	void			Sample() = 0;
			TBool					PostSampleNeeded();
			TInt					PostSample();
			TInt					EndSampling();
			virtual TInt			Reset(DProfilerSampleStream* aStream = 0, TUint32 aSyncOffset = 0);


			void					SetEnabledFlag(TBool aFlag);
			TBool					GetEnabledFlag();
			void					SetOutputCombination(TInt aComb);
			void 					SetSamplingPeriod(TInt aSettings);
			void					SetAdditionalSettings(TInt aSettings);
			void					SetAdditionalSettings2(TInt aSettings);
			void					SetAdditionalSettings3(TInt aSettings);
			void					SetAdditionalSettings4(TInt aSettings);

			DProfilerSampleBuffer*	iSampleBuffer;
			DProfilerSampleStream*	iStream;

			// for right alignment
			TUint8					iBuffer[BufferSize+4];
			TUint8					iDblBuffer[BufferSize+4];
			
			TInt					iSamplingPeriod;
			TInt					iAdditionalSettings;
			TInt					iAdditionalSettings2;
			TInt					iAdditionalSettings3;
			TInt					iAdditionalSettings4;
    };

/*
 *	
 *	Template abstract class CProfilerGenericSampler implementation
 *
 */

template <int BufferSize>
DProfilerGenericSampler<BufferSize>::DProfilerGenericSampler(TInt aSamplerId)
    {
	iSamplerId = aSamplerId;
	iEnabled = false;
	iSampleBuffer = 0;
	iAdditionalSettings = 0;
	iAdditionalSettings2 = 0;
    iAdditionalSettings3 = 0;
    iAdditionalSettings4 = 0;
	iStream = 0;
	Initialise();
    }

template <int BufferSize> 
DProfilerGenericSampler<BufferSize>::~DProfilerGenericSampler()
    {
	LOGSTRING2("CProfilerGenericSampler<%d>::CProfilerGenericSampler",BufferSize);	
	
	if(iSampleBuffer != 0)
		delete iSampleBuffer;

    }
 
template <int BufferSize> 
TInt DProfilerGenericSampler<BufferSize>::Initialise()
    {
	LOGSTRING2("CProfilerGenericSampler<%d>::Initialise - chunk option",BufferSize);

	// stream is not used in chunk mode
	iStream = 0;

	// create the sample buffer object with the buffers
	if(iSampleBuffer == 0)
	    {
	    iSampleBuffer = new DProfilerSampleBuffer(iBuffer,iDblBuffer,BufferSize);
        }
	else
	   {
		LOGSTRING2("CProfilerGenericSampler<%d>::Initialise - ERROR 1",BufferSize);
        }

	return KErrNone;
    }



template <int BufferSize> 
TInt DProfilerGenericSampler<BufferSize>::Reset(DProfilerSampleStream* aStream, TUint32 aSyncOffset)
    {
	LOGSTRING4("CProfilerGenericSampler<%d>::Reset %d, sync offset %d",BufferSize,aStream,aSyncOffset);
	// reset the sample buffer and resolve the chunk again

	// CURRENT VERSION SUPPORTS ONLY STREAM MODE!
	LOGSTRING2("CProfilerGenericSampler<%d>::Reset - stream option",BufferSize);

	// initialise the sampler with the stream option
	iStream = aStream;

	// clear the sample buffer
	if(iSampleBuffer != 0)
	    {
	    iSampleBuffer->ClearBuffer();
        }
	else
	    {
		LOGSTRING2("CProfilerGenericSampler<%d>::Initialise - ERROR no buffer",BufferSize);
        }

	return KErrNone;

    }

template <int BufferSize> 
TBool DProfilerGenericSampler<BufferSize>::PostSampleNeeded()
    {
	LOGSTRING4("CProfilerGenericSampler<%d>::PostSampleNeeded - ID %d, state %d",iSamplerId,BufferSize,iSampleBuffer->GetBufferStatus());

	TUint32 status = iSampleBuffer->iBufferStatus;

	if(status == DProfilerSampleBuffer::BufferCopyAsap || status == DProfilerSampleBuffer::BufferFull)
	    {
		return true;
        }
	
	return false;
    }


template <int BufferSize> 
TInt DProfilerGenericSampler<BufferSize>::PostSample()
    {
	LOGSTRING4("CProfilerGenericSampler<%d>::PostSample - ID %d, state %d",iSamplerId,BufferSize,iSampleBuffer->GetBufferStatus());

	TUint32 status = iSampleBuffer->iBufferStatus;

	if(status == DProfilerSampleBuffer::BufferCopyAsap || status == DProfilerSampleBuffer::BufferFull)
	    {
        // write data to the stream
	    iStream->AddSamples(*iSampleBuffer,iSamplerId);
		}
	
	return KErrNone;
    }

template <int BufferSize>
TInt DProfilerGenericSampler<BufferSize>::EndSampling()
    {
	LOGSTRING3("CProfilerGenericSampler<%d>::EndSampling, ID %d",BufferSize,iSamplerId);

    // only if write to stream option is selected
    if(iStream->EndSampling(*iSampleBuffer,iSamplerId) == 0)
        {
        return KErrNone;
        }
    else 
        {
        // there is still data to copy
        return KErrNotReady;
        }
    }

template <int BufferSize>
void DProfilerGenericSampler<BufferSize>::SetEnabledFlag(TBool aFlag)
    {
	LOGSTRING2("CProfilerGenericSampler<%d>::SetEnabledFlag",BufferSize);
	iEnabled = aFlag;
    }

template <int BufferSize>
TBool DProfilerGenericSampler<BufferSize>::GetEnabledFlag()
    {
	LOGSTRING2("CProfilerGenericSampler<%d>::GetEnabledFlag",BufferSize);
	return iEnabled;
    }

template <int BufferSize>
void DProfilerGenericSampler<BufferSize>::SetOutputCombination(TInt aComb)
    {
	LOGSTRING2("CProfilerGenericSampler<%d>::SetOutputCombination",BufferSize);
	iOutputCombination = aComb;
    }

template <int BufferSize>
void DProfilerGenericSampler<BufferSize>::SetAdditionalSettings(TInt aSettings)
    {
	LOGSTRING3("CProfilerGenericSampler<%d>::SetAdditionalSettings to 0x%x",BufferSize,aSettings);
	iAdditionalSettings = aSettings;
    }

template <int BufferSize>
void DProfilerGenericSampler<BufferSize>::SetAdditionalSettings2(TInt aSettings)
    {
	LOGSTRING3("CProfilerGenericSampler<%d>::SetAdditionalSettings2 to 0x%x",BufferSize,aSettings);
	iAdditionalSettings2 = aSettings;
    }

template <int BufferSize>
void DProfilerGenericSampler<BufferSize>::SetAdditionalSettings3(TInt aSettings)
    {
	LOGSTRING3("CProfilerGenericSampler<%d>::SetAdditionalSettings3 to 0x%x",BufferSize,aSettings);
	iAdditionalSettings3 = aSettings;
    }

template <int BufferSize>
void DProfilerGenericSampler<BufferSize>::SetAdditionalSettings4(TInt aSettings)
    {
	LOGSTRING3("CProfilerGenericSampler<%d>::SetAdditionalSettings4 to 0x%x",BufferSize,aSettings);
	iAdditionalSettings4 = aSettings;
    }

template <int BufferSize>
void DProfilerGenericSampler<BufferSize>::SetSamplingPeriod(TInt aSettings)
    {
	LOGSTRING3("CProfilerGenericSampler<%d>::SetSamplingPeriod to 0x%x",BufferSize,aSettings);
	iSamplingPeriod = aSettings;
    }

/*
 *	
 *	Just a test class that is derived from CProfilerGenericSampler
 *	
 */

template <int BufferSize>
class DProfilerExampleSampler : public DProfilerGenericSampler<BufferSize>
    {
public:
	TUint32 iSampleNumber;

	DProfilerExampleSampler(TInt aSamplerId);
	~DProfilerExampleSampler();

	void Sample();
	void Sample(TInt aCount, TInt aLastPc);
    };


/*
 *	
 *	Just a test class that is derived from CProfilerGenericSampler
 *	
 */

template <int BufferSize>
DProfilerExampleSampler<BufferSize>::DProfilerExampleSampler(TInt aSamplerId) :
	DProfilerGenericSampler<BufferSize>(aSamplerId) 
    {
    iSampleNumber = 0;
	LOGSTRING2("CProfilerExampleSampler<%d>::CProfilerExampleSampler",BufferSize);	
    }

template <int BufferSize>
void DProfilerExampleSampler<BufferSize>::Sample()
    {
	LOGSTRING2("CProfilerExampleSampler<%d>::Sample",BufferSize);
	TBuf8<20>* testiBuf = new TBuf8<20>;

	testiBuf->AppendNum((TInt)iSampleNumber);
	iSampleNumber++;

	this->iSampleBuffer->AddSample((TUint8*)testiBuf->Ptr(),testiBuf->Length());
	delete testiBuf;
	return;
    }

template <int BufferSize>
void DProfilerExampleSampler<BufferSize>::Sample(TInt aCount, TInt aLastPc)
    {
	return;
    }

template <int BufferSize>
DProfilerExampleSampler<BufferSize>::~DProfilerExampleSampler()
    {
	LOGSTRING2("CProfilerExampleSampler<%d>::~CProfilerExampleSampler",BufferSize);		
    }

#include <piprofiler/ProfilerGenericClassesKrn.inl>

#endif


#endif