/*
 * Copyright (c) 2001-2004 MUSIC TECHNOLOGY GROUP (MTG)
 *                         UNIVERSITAT POMPEU FABRA
 * Copyright (c) 2007 Superlucidity Services, LLC and Zachary T Welch
 *
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 */

#ifndef CONTROL_TRACE_HXX
#define CONTROL_TRACE_HXX

#include <CLAM/Processing.hxx>
#include <CLAM/ProcessingConfig.hxx>
#include <CLAM/InControlArray.hxx>
#include <CLAM/OutControlArray.hxx>
#include <CLAM/Filename.hxx>
#include <vector>

class Network;

struct fann;

namespace CLAM
{

class ControlTraceEvent : public Component {
public:
	typedef std::vector<TControlData> ValueArray;

	ControlTraceEvent();
	ControlTraceEvent(const InControlArray &inputs);
	ControlTraceEvent(const ControlTraceEvent &event);
	const ControlTraceEvent& operator=( const ControlTraceEvent& );
	virtual ~ControlTraceEvent() { }

	const char *GetClassName() const { return "ControlTraceEvent"; }

	void LoadFrom( Storage& storage);
	void StoreOn( Storage& storage ) const;

	void WasRepeated() { mRepeats++; }
	unsigned int Repeats() const { return mRepeats; }

	size_t Size() const { return mValues.size(); }

	void UpdateControls(OutControlArray &array) const;

	bool ValuesEqual(const ControlTraceEvent &rhs) const;

private:
	unsigned int mRepeats;
	ValueArray mValues;
};

class ControlTraceData : public Component {
	static const unsigned int DumpVersion;
public:
	typedef std::list<ControlTraceEvent> EventList;
	virtual ~ControlTraceData() { }

	ControlTraceData();
	ControlTraceData(const ControlTraceData &obj);

	const char *GetClassName() const { return "ControlTraceData"; }

	unsigned int GetVersion() const { return mVersion; }

	void LoadFrom( Storage& storage);
	void StoreOn( Storage& storage ) const;

	size_t GetNumberOfControls() const { return mEvents.front().Size(); }

	void Append(const ControlTraceEvent &data);

	EventList::iterator Begin() { return mEvents.begin(); }
	EventList::iterator End() { return mEvents.end(); }

	void Clear() { mEvents.clear(); }

private:
	unsigned int mVersion;
	EventList mEvents;
};


class ControlTraceInFilename : public InFilename
{
public:
	ControlTraceInFilename(const std::string & s="") : InFilename(s) {}
	ControlTraceInFilename(const char * s) : InFilename(s) {}
	const char* TypeFamily() const;
	const Filter * Filters() const;
};
CLAM_TYPEINFOGROUP(BasicCTypeInfo, ControlTraceInFilename);

class ControlTraceReaderConfig  : public ProcessingConfig {
	DYNAMIC_TYPE_USING_INTERFACE
	( ControlTraceReaderConfig, 1, ProcessingConfig );

	DYN_ATTRIBUTE( 0, public, ControlTraceInFilename, TraceFile );

protected:
	void DefaultInit();
};

class ControlTraceReader : public Processing
{
public:
	ControlTraceReader();
	ControlTraceReader( const ProcessingConfig& cfg );
	virtual ~ControlTraceReader();

	const char* GetClassName() const { return "ControlTraceReader"; }
	const ProcessingConfig& GetConfig() const { return mConfig; }

	bool Do();

protected: // methods
	bool ConcreteConfigure( const ProcessingConfig& cfgObject );
	bool ConcreteStart();
	void RemoveOldControls();
	
protected: // attributes
	ControlTraceReaderConfig mConfig;
	ControlTraceData mTrace;
	ControlTraceData::EventList::iterator mIterator;
	unsigned int mRepeatCounter;
	OutControlArray mOutputs;
};


class ControlTraceOutFilename : public OutFilename
{
public:
	ControlTraceOutFilename(const std::string & s="") : OutFilename(s) {}
	ControlTraceOutFilename(const char * s) : OutFilename(s) {}
	const char* TypeFamily() const;
	const Filter * Filters() const;
};
CLAM_TYPEINFOGROUP(BasicCTypeInfo, ControlTraceOutFilename);

class ControlTraceWriterConfig  : public ProcessingConfig {
	DYNAMIC_TYPE_USING_INTERFACE
	( ControlTraceWriterConfig, 2, ProcessingConfig );

	DYN_ATTRIBUTE( 0, public, ControlTraceOutFilename, TraceFile );
	DYN_ATTRIBUTE( 1, public, TData, NumberOfInputs );

protected:
	void DefaultInit();
};

class ControlTraceWriter : public Processing
{
public:
	ControlTraceWriter();
	ControlTraceWriter( const ProcessingConfig& cfg );
	virtual ~ControlTraceWriter();

	const char* GetClassName() const { return "ControlTraceWriter"; }
	const ProcessingConfig& GetConfig() const { return mConfig; }

	bool Do();

protected: // methods
	bool ConcreteConfigure( const ProcessingConfig& cfgObject );
	bool ConcreteStop();
	void RemoveOldControls();
	
protected: // attributes
	ControlTraceWriterConfig mConfig;
	ControlTraceData mTrace;
	InControlArray mInputs;
};

} // CLAM namespace

#endif
