#include "eyd_compressor.hh"

namespace EydLib {

	/*
	class BitCompressor {
		private:
			BitGroup _last_group;
			int _last_count;
			std::list<BitGroup> _compressed;

		public:
			BitCompressor();

			void clear();
			void append(BitGroup bg);
			std::list<BitGroup> flush();
			bool hasContent();
	};
	*/

	BitCompressor::BitCompressor(){
	}

	void BitCompressor::clear(){
		// we clear everything
		_last_count = 0;
		_compressed.clear();
	}

	void BitCompressor::flushRleData(){
		BitGroup len;
		_compressed.push_back(_rle);
		len.setValue(_last_count);
		_compressed.push_back(len);
		_compressed.push_back(_last_group);	
		_last_count = 0;
	}

	void BitCompressor::flushRawData(){
		int i;
		for (i=0; i<_last_count; i++){
			// FIXME: on duplique les RLE trouvés
			_compressed.push_back(_last_group);
		}
		_last_count = 0;
	}

	void BitCompressor::append(BitGroup data){
		// take the data and make it smaller...
		if (_last_count > 0) {
			// there are data in the compressor
			if (data != _last_group){
				// we have to empty the compressed list
				if (_last_count < 4){
					// not efficient
					if ((_last_count > 1) && (_last_group == _rle)) {
						// 1 RLE gives 2 RLE
						// 2 RLE gives 4 RLE... let compress it...
						this->flushRleData();
					} else {
						this->flushRawData();
					}
				} else {
					// efficient ! lets compress it !
					this->flushRleData();
				}
			} else {
				// nothing to do... wait for another different data...
			}
		} else {
			// it is the first bitgroup
		}
		_last_group = data;
		_last_count++;
	}

	std::list<BitGroup> BitCompressor::flush(){
		// we add the data from _last* to the outlist
		std::list<BitGroup> result;
		result = _compressed;
		_compressed.clear();
		return result;
	}

	bool BitCompressor::hasContent(){
		return (!_compressed.empty());
	}
}