#include "stdafx.h"
#include "SmartStructBuffer.h"
#include<iostream>
#include <assert.h>
#include <stdexcept>
#include "Daten.h"
#include <fstream>

using namespace std;



SmartStructBuffer::SmartStructBuffer(int strSize /*=5*/)
{
	const int MIN_BUF_SIZE = sizeof(Daten);
	m_size = 0; // Size in Bytes
	m_maxSize = (strSize < MIN_BUF_SIZE ? MIN_BUF_SIZE :strSize); // if maxSz ist < als sz dann MaxSize = grцЯter von zwei 
	m_buff = new char [m_maxSize];
}
SmartStructBuffer::SmartStructBuffer (const SmartStructBuffer& other) // Kopie Konstruktor
{
	m_maxSize = other.GetmaxSize();
	m_size = other.GetSize();
	m_buff = new char [m_maxSize];
	memcpy(m_buff, other.GetRawBuffer(), m_size);
}
Daten SmartStructBuffer::operator [](int p)
{
	if((p +1) * sizeof(Daten) >= m_size + 1 ||  p < 0 )
		throw out_of_range ("offset ist out of range");
	else
	{
		Daten *pDaten;
		pDaten = (Daten*)(m_buff + p * sizeof(Daten));

		return *pDaten;	
	}
}
SmartStructBuffer & SmartStructBuffer::operator = (const SmartStructBuffer & other)
{
	for(int i = 0; i<m_size; i++)
		m_buff[i] = other.m_buff[i];
	return *this;
}
SmartStructBuffer::~SmartStructBuffer(void)
{
	delete [] m_buff;
}
int SmartStructBuffer::GetSize() const
{
	return m_size; // wie viel Bytes belegt
}
int SmartStructBuffer::GetmaxSize() const
{
	return m_maxSize; // letzte Element in Array
}
Daten SmartStructBuffer::getAtPos(int p)
{
	if((p +1) * sizeof(Daten) >= m_size + 1 ||  p < 0 )
		throw out_of_range ("offset ist out of range");
	else
	{
		Daten *pDaten;
		pDaten = (Daten*)(m_buff + p * sizeof(Daten));

		return *pDaten;	
	}
}
void SmartStructBuffer::IncreaseSize(int newSize)
{
	m_maxSize = m_size + newSize; // Neue grцЯe von m_buff
	char *newArray = new char[m_maxSize]; // Neue Array erstellen
	memcpy(newArray,m_buff,m_size);
	//for(int i = 0; i<m_size; i++)
	//{
	//	newArray[i]= m_buff[i]  ; // Kopie von Elementen
	//	}
	delete [] m_buff;
	m_buff = newArray;
}
void SmartStructBuffer::Add(const Daten& data)
{
	//Habe ich genug Platz fьr eine Struktur?
	if(m_maxSize - m_size < sizeof(Daten))
	{
		//wenn nicht, dann mindestens um die GrцЯe der Struktur vergrцЯen
		IncreaseSize(sizeof(Daten)*3);

		char *newArray = new char[m_maxSize]; // Neue Array erstellen
		memcpy(newArray,m_buff,m_size);
		delete [] m_buff;
		m_buff = newArray;
	}

	memcpy(m_buff + m_size, (char*)&data, sizeof(Daten));
	m_size = m_size + sizeof(Daten);
	//for (int i = 0; i< sizeof(Daten); i++)
	//{
	//(*m_buff + m_size +i)= *((char*)data+i) ; // Element einfьgen am Ende Array
	//}
}
void SmartStructBuffer::Clear()
{
	m_size = 0;
}
void SmartStructBuffer::DatenAnPosErsetzen(int p, const Daten &data)
{
	if((p +1) * sizeof(Daten) >= m_size + 1 ||  p < 0 )
		throw out_of_range ("offset ist out of range");
	else
		Daten *pDaten;
	Daten *pDaten = (Daten*)(m_buff + p*sizeof(Daten));
	*pDaten = data;
}
void SmartStructBuffer::InsertAtPos(int p, const Daten &data)
{
	Daten daten(-1); 

	Daten *ptr = (Daten*)(m_buff); // Prьfung der Daten
	if(m_maxSize < m_size + sizeof(Daten)) // Wenn buff zu klein ist
	{
		IncreaseSize(m_size + sizeof(Daten)); // m_buff vergrцЯern
	}
	p = p*sizeof(Daten);

	memmove(m_buff + p + sizeof(Daten), m_buff + p, m_size - p);

	//for(int i =  m_size-1; i >= p ; i-- ) // von rechts  bis position
	//{
	//	*(m_buff+i+ sizeof(Daten)) = *(m_buff+i) ; // Verschiebung
	//}
	*(Daten*)(m_buff + p) = data; // data auf position speichern
	m_size = m_size + sizeof(Daten); // m_size vergrцЯen
}
void  SmartStructBuffer::RemoveAtPos(int p)
{
	if((p +1) * sizeof(Daten) >= m_size + 1 ||  p < 0 )
		throw out_of_range ("offset ist out of range");

	p = p*sizeof(Daten);
	memmove(m_buff + p,m_buff + p + sizeof(Daten), m_size - p - sizeof(Daten));
	//for(int i = p; i < m_size-1; i++) // von p nach rechts
	//{
	//	m_buff[i] = m_buff[i + sizeof(Daten)];
	//}
	m_size = m_size - sizeof(Daten);
}

std::ostream& operator << (std::ostream& os,const Daten& data)
{
	os << " Struktur: \n" <<" int " <<data.i <<", \n" << " float "<< data.f<< ", \n" <<" double " << data.d << ", \n" <<" char " <<data.c << std::endl;

	return os;
}
bool SmartStructBuffer::WriteToFile(const char* &filename)
{
	fstream myFile( filename,ios::binary | ios::out);
	if(!myFile.is_open())
	{
		cerr << "Fehler beim &#214;ffnen der Datei " << filename << endl;
		return false;
	}
	else
	{
		myFile.write((char*)&m_maxSize, sizeof(m_maxSize));
		myFile.write((char*)&m_size, sizeof(m_size));
		myFile.write(m_buff, sizeof(m_buff));
	}
	myFile.close();
	return true;

}
bool SmartStructBuffer::ReadFromFile(const char* &filename)
{
	fstream myFile (filename, ios::binary | ios::in);
	if(!myFile.is_open())
	{
		cerr << "Fehler beim &#214;ffnen der Datei " << filename << endl;
		return false;
	}
	else
	{
		myFile.read((char*)&m_maxSize, sizeof(m_maxSize));
		myFile.read((char*)&m_size, sizeof(m_size));
		delete[] m_buff;
		m_buff = new char [m_maxSize];

		char *newArray = new char[m_maxSize]; // Neue Array erstellen
		memcpy(newArray,m_buff,m_size);
		delete [] m_buff;
		m_buff = newArray;

		myFile.read(m_buff, sizeof(m_buff));
	}
	myFile.close();
	return true;

}

int main()
{
	SmartStructBuffer sb(sizeof(Daten));

	const int IT = 5;
	for(int i = 0; i < IT; i++)
	{
		Daten s(i);
		sb.Add(s);
	}
	const char* pFILENAME = "D:\\01.bin";
	sb.WriteToFile(pFILENAME);
	
	SmartStructBuffer sb2(123);
	sb2.ReadFromFile(pFILENAME);	
	assert(sb.GetmaxSize() == sb2.GetmaxSize());
	for(int i =0; i < sb2.GetSize(); i++)
	{
		assert(sb[i] == sb2[i]);
	}
	return 0;
}

bool SmartStructBuffer::WriteToFile(const char* &filename)
{
	fstream myFile( filename,ios::binary | ios::out);
	if(!myFile.is_open())
	{
		cerr << "Fehler beim &#214;ffnen der Datei " << filename << endl;
		return false;
	}
	else
	{
		myFile.write((char*)&m_maxSize, sizeof(m_maxSize));
		myFile.write((char*)&m_size, sizeof(m_size));
	        myFile.write((char*)&m_buff, sizeof(m_buff));
	}
	myFile.close();
	return true;

}
bool SmartStructBuffer::ReadFromFile(const char* &filename)
{
	fstream myFile (filename, ios::binary | ios::in);
	if(!myFile.is_open())
	{
		cerr << "Fehler beim &#214;ffnen der Datei " << filename << endl;
		return false;
	}
	else
	{
		myFile.read((char*)&m_maxSize, sizeof(m_maxSize));
		myFile.read((char*)&m_size, sizeof(m_size));

		delete[] m_buff;

		m_buff = new char [m_maxSize];
		m_buff = new char[m_size];

		memcpy(m_buff, &m_buff, sizeof(m_buff) );

		myFile.read((char*)&m_buff, sizeof(m_buff));
	}
	myFile.close();
	return true;
}