/*! \file pibytearray.h
 * \ingroup Core
 * \~\brief
 * \~english Byte array
 * \~russian Байтовый массив
*/
/*
	PIP - Platform Independent Primitives
	Byte array
	Ivan Pelipenko peri4ko@yandex.ru, Andrey Bychkov work.a.b@yandex.ru

	This program is free software: you can redistribute it and/or modify
	it under the terms of the GNU Lesser General Public License as published by
	the Free Software Foundation, either version 3 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 Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public License
	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef PIBYTEARRAY_H
#define PIBYTEARRAY_H

#include "pichar.h"
#include "pibinarystream.h"
#include <stdio.h>

class PIString;
class PIByteArray;


//! \ingroup Core
//! \~\brief
//! \~english The %PIByteArray class provides an array of bytes.
//! \~russian Класс %PIByteArray представляет собой массив байтов.
class PIP_EXPORT PIByteArray: public PIDeque<uchar>, public PIBinaryStream<PIByteArray>
{
public:
	typedef ::PIMemoryBlock RawData DEPRECATEDM("use PIMemoryBlock instead");

	//! \~english Constructs an empty byte array
	//! \~russian Создает пустой байтовый массив
	PIByteArray() {;}

	//! \~english Constructs copy of byte array "o"
	//! \~russian Создает копию байтового массива "o"
	PIByteArray(const PIByteArray & o): PIDeque<uchar>(o) {}

	//! \~english Constructs copy of byte array "o"
	//! \~russian Создает копию байтового массива "o"
	PIByteArray(const PIDeque<uchar> & o): PIDeque<uchar>(o) {}

	PIByteArray(PIByteArray && o): PIDeque<uchar>(std::move(o)) {}

	//! \~english Constructs 0-filled byte array with size "size"
	//! \~russian Создает заполненный "0" байтовый массив размером "size"
	PIByteArray(const uint size) {resize(size);}

	//! \~english Constructs byte array from data "data" and size "size"
	//! \~russian Создает байтовый массив из данных по указателю "data" размером "size"
	PIByteArray(const void * data, const uint size): PIDeque<uchar>((const uchar*)data, size_t(size)) {}

	//! \~english Constructs byte array with size "size" filled by "t"
	//! \~russian Создает заполненный "t" байтовый массив размером "size"
	PIByteArray(const uint size, uchar t): PIDeque<uchar>(size, t) {}


	//! \~english Return resized byte array
	//! \~russian Возвращает копию байтового массива с измененным размером
	PIByteArray resized(uint new_size) const {PIByteArray ret(new_size); memcpy(ret.data(), data(), new_size); return ret;}

	//! \~english Return sub-array starts from "index" and has "count" or less bytes
	//! \~russian Возвращает подмассив с данными от индекса "index" и размером не более "count"
	PIByteArray getRange(size_t index, size_t count) const {
		return PIDeque<uchar>::getRange(index, count);
	}


	//! \~english Convert data to Base 64 and return this byte array
	//! \~russian Преобразует данные в Base 64 и возвращает текущий массив
	PIByteArray & convertToBase64();

	//! \~english Convert data from Base 64 and return this byte array
	//! \~russian Преобразует данные из Base 64 и возвращает текущий массив
	PIByteArray & convertFromBase64();

	//! \~english Return converted to Base 64 data
	//! \~russian Возвращает копию байтового массива, преобразованного в Base 64
	PIByteArray toBase64() const;

	PIByteArray & compressRLE(uchar threshold = 192);
	PIByteArray & decompressRLE(uchar threshold = 192);
	PIByteArray compressedRLE(uchar threshold = 192) {PIByteArray ba(*this); ba.compressRLE(threshold); return ba;}
	PIByteArray decompressedRLE(uchar threshold = 192) {PIByteArray ba(*this); ba.decompressRLE(threshold); return ba;}

	//! \~english Return string representation of data, each byte in "base" base, separated by spaces
	//! \~russian Возвращает текстовое представление байтового массива, каждый байт в "base" системе, с пробелами
	PIString toString(int base = 16) const;

	//! \~english
	//! Returns a hex encoded copy of the byte array, without spaces.
	//! The hex encoding uses the numbers 0-9 and the letters a-f.
	//! \~russian
	//! Возвращает шестнадцатеричное представление массива, без пробелов.
	//! Оно использует цифры 0-9 и буквы a-f.
	PIString toHex() const;

	//! \~english Add to the end data "data" with size "size"
	//! \~russian Добавляет в конец массива данные по указателю "data" размером "size"
	PIByteArray & append(const void * data_, int size_) {uint ps = size(); enlarge(size_); memcpy(data(ps), data_, size_); return *this;}

	//! \~english Add to the end byte array "data"
	//! \~russian Добавляет в конец массива содержимое массива "data"
	PIByteArray & append(const PIByteArray & data_) {uint ps = size(); enlarge(data_.size_s()); memcpy(data(ps), data_.data(), data_.size()); return *this;}
	
	//! \~english Add to the end "t"
	//! \~russian Добавляет в конец массива байт "t"
	PIByteArray & append(uchar t) {push_back(t); return *this;}

	//! \~english Returns 8-bit checksum
	//! \~russian Возвращает 8-битную контрольную сумму
	uchar checksumPlain8(bool inverse = true) const;

	//! \~english Returns 32-bit checksum
	//! \~russian Возвращает 32-битную контрольную сумму
	uint checksumPlain32(bool inverse = true) const;

	//! \~english Returns hash of content
	//! \~russian Возвращает хэш содержимого
	uint hash() const;

	void operator =(const PIDeque<uchar> & d) {resize(d.size()); memcpy(data(), d.data(), d.size());}

	PIByteArray & operator =(const PIByteArray & o) {if (this == &o) return *this; clear(); append(o); return *this;}

	PIByteArray & operator =(PIByteArray && o) {swap(o); return *this;}

	static PIByteArray fromUserInput(PIString str);

	static PIByteArray fromHex(PIString str);

	//! \~english Return converted from Base 64 data
	//! \~russian Возвращает массив из Base 64 представления
	static PIByteArray fromBase64(const PIByteArray & base64);
	static PIByteArray fromBase64(const PIString & base64);


	bool binaryStreamAppendImp(const void * d, size_t s) {
		append(d, s);
		return true;
	}
	bool binaryStreamTakeImp(void * d, size_t s) {
		if (size() < s)
			return false;
		memcpy(d, data(), s);
		remove(0, s);
		return true;
	}

};

//! \relatesalso PIByteArray
//! \~english Byte arrays compare operator
//! \~russian Оператор сравнения
inline bool operator <(const PIByteArray & v0, const PIByteArray & v1) {
	if (v0.size() == v1.size()) {
		if (v0.isEmpty()) return false;
		return memcmp(v0.data(), v1.data(), v0.size()) < 0;
	}
	return v0.size() < v1.size();
}

//! \relatesalso PIByteArray
//! \~english Byte arrays compare operator
//! \~russian Оператор сравнения
inline bool operator >(const PIByteArray & v0, const PIByteArray & v1) {
	if (v0.size() == v1.size()) {
		if (v0.isEmpty()) return false;
		return memcmp(v0.data(), v1.data(), v0.size()) > 0;
	}
	return v0.size() > v1.size();
}

//! \relatesalso PIByteArray
//! \~english Byte arrays compare operator
//! \~russian Оператор сравнения
inline bool operator ==(const PIByteArray & v0, const PIByteArray & v1) {
	if (v0.size() == v1.size()) {
		if (v0.isEmpty()) return true;
		return memcmp(v0.data(), v1.data(), v0.size()) == 0;
	}
	return false;
}

//! \relatesalso PIByteArray
//! \~english Byte arrays compare operator
//! \~russian Оператор сравнения
inline bool operator !=(const PIByteArray & v0, const PIByteArray & v1) {
	if (v0.size() == v1.size()) {
		if (v0.isEmpty()) return false;
		return memcmp(v0.data(), v1.data(), v0.size()) != 0;
	}
	return true;
}

#ifdef PIP_STD_IOSTREAM
//! \relatesalso PIByteArray \brief Output to std::ostream operator
inline std::ostream & operator <<(std::ostream & s, const PIByteArray & ba);
#endif

//! \relatesalso PIByteArray
//! \~english Output operator to \a PICout
//! \~russian Оператор вывода в \a PICout
PIP_EXPORT PICout operator <<(PICout s, const PIByteArray & ba);


BINARY_STREAM_WRITE(PIByteArray) {
	s.binaryStreamAppend((int)v.size_s());
	s.binaryStreamAppend(v.data(), v.size());
	return s;
}
BINARY_STREAM_READ(PIByteArray) {
	v.resize(s.binaryStreamTakeInt());
	s.binaryStreamTake(v.data(), v.size());
	return s;
}


//! \relatesalso PIByteArray
//! \~english Returns PIByteArray::hash() of "ba"
//! \~russian Возвращает PIByteArray::hash() от "ba"
template<> inline uint piHash(const PIByteArray & ba) {return ba.hash();}

//! \relatesalso PIByteArray
//! \~english Swap contents betwee "f" and "s"
//! \~russian Меняет содержимое массивов "f" и "s"
template<> inline void piSwap(PIByteArray & f, PIByteArray & s) {f.swap(s);}


//! \relatesalso PIByteArray
//! \~english Store "value" to bytearray and returns it
//! \~russian Сохраняет "value" в байтовый массив и возвращает его
template <typename T> PIByteArray piSerialize(const T & value) {
	PIByteArray ret;
	ret << value;
	return ret;
}

//! \relatesalso PIByteArray
//! \~english Restore type "T" from bytearray "data" and returns it
//! \~russian Извлекает тип "T" из байтового массива "data" и возвращает его
template <typename T> T piDeserialize(const PIByteArray & data) {
	T ret;
	if (!data.isEmpty()) {
		PIByteArray ba(data);
		ba >> ret;
	}
	return ret;
}


#endif // PIBYTEARRAY_H