/*
 * asymRootRecord.hh
 *
 *  Created on: October 30, 2025
 *      Author: Hovanes Egiyan
 *
 *
 */

#ifndef ASYMROOTRECORD_HH_
#define ASYMROOTRECORD_HH_

#include <time.h>
#include <sys/types.h>

#include <TObject.h>
#include <TArrayL.h>

class asymRootRecord: public TObject {

private:
	struct timespec prrTime; // POSIX timestamp
	TArrayL prrData; // ROOT array of longs
	short prrHelScheme; // Helicity flip scheme
	float prrFlipFreq; // Sync clock frequency in Hz
	float prrStableTime; // Stable time in micorseconds

public:
	asymRootRecord( struct timespec posixTime, unsigned nElm, const long* arrayPtr, short& helScheme,
			float& flipFreq, float& stableTime ) :
			TObject(), prrTime( posixTime ), prrData( nElm, arrayPtr ), prrHelScheme( helScheme ),
					prrFlipFreq( flipFreq ), prrStableTime( stableTime ) {
		;
	}

	asymRootRecord& operator=( const asymRootRecord &record ) {
		*dynamic_cast<TObject*>( this ) = record;
		prrTime = record.prrTime;
		prrData = record.prrData;
		return *this;
	}

	virtual ~asymRootRecord() {
	}
	;

	void CopyToBuffer( void* bufferPtr );

	inline struct timespec GetTimeStamp() const {
		return prrTime;
	}

	inline TArrayL& GetData() {
		return prrData;
	}

	inline struct timespec SetTimeStamp( struct timespec posixTime ) {
		return prrTime = posixTime;
	}
	float getPrrFlipFreq() const {
		return prrFlipFreq;
	}

	void setFlipFreq( float prrFlipFreq ) {
		this->prrFlipFreq = prrFlipFreq;
	}

	short getHelScheme() const {
		return prrHelScheme;
	}

	void setHelScheme( short prrHelScheme ) {
		this->prrHelScheme = prrHelScheme;
	}

	float getStableTime() const {
		return prrStableTime;
	}

	void setStableTime( float prrStableTime ) {
		this->prrStableTime = prrStableTime;
	}

	inline TArrayL& SetData( Int_t nElm, const Long_t* arrayPtr ) {
		return prrData = TArrayL( nElm, arrayPtr );
	}

	inline TArrayL& SetData( const TArrayL& array ) {
		return prrData = array;
	}

};

void asymRootRecord::CopyToBuffer( void* bufferPtr ) {

	// Copy second
	memcpy( bufferPtr, &(prrTime.tv_sec), sizeof(__time_t ) );

	// Copy Nanosecond
	void * currentPtr = &((static_cast<__time_t *>( bufferPtr ))[1]);
	memcpy( currentPtr, &(prrTime.tv_nsec), sizeof(long int) );

	// Copy Data array
	currentPtr = &((static_cast<timespec*>( bufferPtr ))[1]);
	memcpy( currentPtr, prrData.fArray, prrData.GetSize() * sizeof(long int) );

	// Copy Helicity Scheme
	currentPtr = &((long int*)currentPtr)[prrData.GetSize()];
	memcpy( currentPtr, &prrHelScheme, sizeof(short) );

	// Copy Flipping Frequency
	currentPtr = &((short*)currentPtr)[1];
	memcpy( currentPtr, &prrFlipFreq, sizeof(float) );

	// Copy stable time
	currentPtr = &((float*)currentPtr)[1];
	memcpy( currentPtr, &prrStableTime, sizeof(float) );

	return;
}

#endif /* ASYMROOTRECORD_HH_ */