#include "eyd_compressor_rle1.hh"

namespace EydLib {

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

		public:
			BitCompressorRle1();

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

	BitCompressorRle1::BitCompressorRle1(int size) : _rle(size) {
		_group_size = size;
		_last_count = 0;
	}

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

	void BitCompressorRle1::flushRleData(){
		BitGroup len(_group_size);  
		_compressed.push_back(_rle);
		printf("Last count %d\n", _last_count);
		printf("Max cellsize %d\n", len.maxValue());
		len.setValue(_last_count);
		_compressed.push_back(len);
		_compressed.push_back(_last_group);	
		_last_count = 0;
	}

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

	void BitCompressorRle1::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...
				// maybe the count is bigger than the len-cell can store ?
				if (_last_count >= _rle.maxValue()){
					this->flushRleData();
				}
			}
		} else {
			// it is the first bitgroup
		}
		_last_group = data;
		_last_count++;
	}

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

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