#include <cstdio>
#include <memory>
#include <cstring>

template<typename T>
Buffer<T>::Buffer(size_t capacity)
: m_capacity(capacity)
, m_len(0)
, m_wi(0)
, m_ri(0)
, m_data{nullptr, nullptr}
{
    m_data[0] = new T[capacity];
    m_data[1] = new T[capacity];
}

template<typename T>
Buffer<T>::~Buffer()
{
    delete [] m_data[0];
    delete [] m_data[1];
}

template<typename T>
size_t Buffer<T>::len()
{
    return m_len;
}

template<typename T>
size_t Buffer<T>::capacity()
{
    return m_capacity;
}

template<typename T>
void Buffer<T>::clear()
{
    m_len = 0;
    m_wi = 0;
    m_ri = 0;
}

template<typename T>
T* Buffer<T>::data_w()
{
    return &bufferActive()[m_wi];
}

template<typename T>
T* Buffer<T>::data_r()
{
    return &bufferActive()[m_ri];
}

template<typename T>
size_t Buffer<T>::write(const T *pData, size_t len)
{
	len = std::min(m_capacity - m_len, len);
	size_t numWritten = 0;
	while(len)
	{
		size_t num_remain = m_capacity - m_wi;
		size_t actual_len = std::min(num_remain, len);

		memcpy(data_w(), pData, actual_len*sizeof(T));
		produce(actual_len);
		len -= actual_len;
		pData += actual_len;
		numWritten += actual_len;
	}
	return numWritten;

}

template<typename T>
size_t Buffer<T>::read(T* pData, size_t len)
{
	len = std::min(m_len, len);
	size_t numRead = 0;
	while(len)
	{
		size_t num_remain = m_capacity - m_ri;
		size_t actual_len = std::min(num_remain, len);

		memcpy(pData, data_r(), actual_len*sizeof(T));
		len -= actual_len;
		pData += actual_len;
		consume(actual_len);
	}
	return numRead;

}

template<typename T>
typename Buffer<T>::Result Buffer<T>::consume(size_t len)
{
	if (len > m_len)
	{
		RETURN_OR_EXCEPT(Result::Err_InvalidSize);
	}
	m_len -= len;

	m_ri += len;
	if (m_ri >= m_capacity)
	{
		m_ri -= m_capacity;
	}
	return Result::Ok;
}

template<typename T>
typename Buffer<T>::Result Buffer<T>::produce(size_t len)
{
	if (len > (m_capacity - m_len))
	{
		RETURN_OR_EXCEPT(Result::Err_InvalidSize);
	}
	m_len += len;

	m_wi += len;
	if (m_wi >= m_capacity)
	{
		m_wi -= m_capacity;
	}
	return Result::Ok;
}

template<typename T>
void Buffer<T>::print(const char *prefix)
{
	make_contigious();
	T *data = data_r();
	printf("%s", prefix);
	for (size_t i=0; i < m_len; i++)
	{
		printf("%f ", data[i]);
	}
	printf("\n");
}