#include <sp/common/DataBuffer.h>

#include <fstream>
#include <iomanip>
#include <sstream>

namespace sp {

DataBuffer::DataBuffer() : m_ReadOffset(0) {}

DataBuffer::DataBuffer(std::size_t a_InitialSize) : m_Buffer(a_InitialSize), m_ReadOffset(0) {}

DataBuffer::DataBuffer(const DataBuffer& other) : m_Buffer(other.m_Buffer), m_ReadOffset(other.m_ReadOffset) {}

DataBuffer::DataBuffer(DataBuffer&& other) : m_Buffer(std::move(other.m_Buffer)), m_ReadOffset(std::move(other.m_ReadOffset)) {}

DataBuffer::DataBuffer(const std::string& str) : m_Buffer(str.begin(), str.end()), m_ReadOffset(0) {}

DataBuffer::DataBuffer(const DataBuffer& other, Data::difference_type offset) : m_ReadOffset(0) {
	m_Buffer.reserve(other.GetSize() - static_cast<std::size_t>(offset));
	std::copy(other.m_Buffer.begin() + offset, other.m_Buffer.end(), std::back_inserter(m_Buffer));
}

DataBuffer& DataBuffer::operator<<(const std::string& str) {
	std::size_t strlen = str.length() + 1;	// including null character
	Resize(GetSize() + strlen);
	std::memcpy(m_Buffer.data() + GetSize() - strlen, str.data(), strlen);
	return *this;
}

DataBuffer& DataBuffer::operator<<(const DataBuffer& data) {
	m_Buffer.insert(m_Buffer.end(), data.begin(), data.end());
	return *this;
}

DataBuffer& DataBuffer::operator>>(std::string& str) {
	std::size_t stringSize = strlen(reinterpret_cast<const char*>(m_Buffer.data()) + m_ReadOffset) + 1;	 // including null character
	str.resize(stringSize);
	std::copy(m_Buffer.begin() + static_cast<difference_type>(m_ReadOffset),
		m_Buffer.begin() + static_cast<difference_type>(m_ReadOffset + stringSize), str.begin());
	m_ReadOffset += stringSize;
	str.resize(stringSize - 1);
	return *this;
}

DataBuffer& DataBuffer::operator>>(DataBuffer& data) {
	data.Resize(GetSize() - m_ReadOffset);
	std::copy(m_Buffer.begin() + static_cast<difference_type>(m_ReadOffset), m_Buffer.end(), data.begin());
	m_ReadOffset = m_Buffer.size();
	return *this;
}

void DataBuffer::WriteSome(const char* buffer, std::size_t amount) {
	std::size_t end_pos = m_Buffer.size();
	m_Buffer.resize(m_Buffer.size() + amount);
	std::memcpy(m_Buffer.data() + end_pos, buffer, amount);
}

void DataBuffer::WriteSome(const std::uint8_t* buffer, std::size_t amount) {
	std::size_t end_pos = m_Buffer.size();
	m_Buffer.resize(m_Buffer.size() + amount);
	std::memcpy(m_Buffer.data() + end_pos, buffer, amount);
}

void DataBuffer::ReadSome(char* buffer, std::size_t amount) {
	assert(m_ReadOffset + amount <= GetSize());
	std::copy_n(m_Buffer.begin() + static_cast<difference_type>(m_ReadOffset), amount, buffer);
	m_ReadOffset += amount;
}


void DataBuffer::ReadSome(std::uint8_t* buffer, std::size_t amount) {
	assert(m_ReadOffset + amount <= GetSize());
	std::copy_n(m_Buffer.begin() + static_cast<difference_type>(m_ReadOffset), amount, buffer);
	m_ReadOffset += amount;
}


void DataBuffer::ReadSome(DataBuffer& buffer, std::size_t amount) {
	assert(m_ReadOffset + amount <= GetSize());
	buffer.Resize(amount);
	std::copy_n(m_Buffer.begin() + static_cast<difference_type>(m_ReadOffset), amount, buffer.begin());
	m_ReadOffset += amount;
}


DataBuffer& DataBuffer::operator=(const DataBuffer& other) {
	m_Buffer = other.m_Buffer;
	m_ReadOffset = other.m_ReadOffset;
	return *this;
}

DataBuffer& DataBuffer::operator=(DataBuffer&& other) {
	m_Buffer = std::move(other.m_Buffer);
	m_ReadOffset = std::move(other.m_ReadOffset);
	return *this;
}

void DataBuffer::SetReadOffset(std::size_t pos) {
	assert(pos <= GetSize());
	m_ReadOffset = pos;
}

std::size_t DataBuffer::GetSize() const {
	return m_Buffer.size();
}

std::size_t DataBuffer::GetRemaining() const {
	return m_Buffer.size() - m_ReadOffset;
}

DataBuffer::iterator DataBuffer::begin() {
	return m_Buffer.begin();
}

DataBuffer::iterator DataBuffer::end() {
	return m_Buffer.end();
}

DataBuffer::const_iterator DataBuffer::begin() const {
	return m_Buffer.begin();
}

DataBuffer::const_iterator DataBuffer::end() const {
	return m_Buffer.end();
}

std::ostream& operator<<(std::ostream& os, const DataBuffer& buffer) {
	for (unsigned char u : buffer)
		os << std::hex << std::setfill('0') << std::setw(2) << static_cast<int>(u) << " ";
	os << std::dec;
	return os;
}

void DataBuffer::ReadFile(const std::string& fileName) {
	std::ifstream file(fileName, std::istream::binary);
	std::ostringstream ss;
	ss << file.rdbuf();
	const std::string& s = ss.str();
	m_Buffer = DataBuffer::Data(s.begin(), s.end());
	m_ReadOffset = 0;
}

void DataBuffer::WriteFile(const std::string& fileName) const {
	std::ofstream file(fileName, std::ostream::binary);
	file.write(reinterpret_cast<const char*>(m_Buffer.data()), static_cast<std::streamsize>(m_Buffer.size()));
	file.flush();
}

}  // namespace sp