#include <iostream>
#include <iomanip>
#include <cctype>

#include "binbuf.h"

// Insert a string using a length byte followed by it's characters.
// For DNS requests, the limit is 63 characters, for the basic format
// 255 character limit.  This method performs no check on all that,
// so don't abuse it.
void BinaryBuffer::puts(std::string s) {
	put8(s.length());
	for(auto x: s) put(x);
}

// Get a string by reading a length byte then that many characters.
std::string BinaryBuffer::gets() {
	int len = get();
	std::string ret;
	while(len--) ret.push_back(get());
	return ret;
}

/*
 * Put a host name as a series of lenth/data strings ending with a zero
 * byte, per RFC 1035
 */
void BinaryBuffer::puthost(string host)
{
	int start = 0;
	while(start < host.length()) {
		int next = host.find(".", start);
		if(next == string::npos) next = host.length();
		puts(host.substr(start,next-start));
		start = next + 1;
	}
	puts("");
}

/*
 * Get a segment starting with a length.  If accum is not empty, add a .
 * then add characters until either a forward or terminator.  Returns
 * the location that stopped it.
 */
unsigned int BinaryBuffer::segment(unsigned int start, string &accum)
{
	unsigned ct = m_data[start++];
	if(accum != "") accum.push_back('.');
	while(ct--) {
		accum.push_back(m_data[start++]);
	}
	return start;
}

/*
 * Get a host name as a series of lenth/data strings, obeying the offset
 * compression semantics, per RFC 1035.
 */
string BinaryBuffer::gethost()
{
	string ret = "";

	// Reads segments which are in place until end or reference.
	while(m_data[m_rwloc] != 0 && !is_jump(m_data[m_rwloc]))
	{
		m_rwloc = segment(m_rwloc,ret);
	}

	// If we're done, we stop.
	unsigned int loc = m_rwloc++;
	if(m_data[loc] == 0) {
		// Terminator.  We're done, and m_wrloc is past terminator.
		return ret;
	} else {
		// Jump.  We continue, and m_wrloc is only half way past,
		// so we need to advance it again.
		++m_rwloc;
	}

	// Process any back references.
	do {
		if(is_jump(m_data[loc]))
			loc = (((static_cast<unsigned>(m_data[loc])) << 8) |
			       (static_cast<unsigned>(m_data[loc+1])))
				& 0x03fff;
		loc = segment(loc,ret);
	} while(m_data[loc]);

	return ret;
}

// Dump the contents up to the location, or the indicated size.
void BinaryBuffer::dump(int limit, std::ostream &strm) const
{
	static const int bytes_per_group = 4;
	static const int groups_per_line = 5;
	static const int bytes_per_line = bytes_per_group * groups_per_line;

	if(limit < 0) limit = m_rwloc;

	unsigned int line = 0;
	while(limit > 0) {
		int linelimit = limit > bytes_per_line ? bytes_per_line : limit;

		strm << " " << std::setw(3) << std::setfill('0') << std::right
		     << std::dec << line << " ";
		int grct = bytes_per_group;
		for(int i = 0; i < bytes_per_line; ++i) {
			if(i < linelimit) {
				strm << std::setw(2) << std::setfill('0')
				     << std::right << std::hex
				     << static_cast<unsigned int>
					(m_data[line+i]);
			} else {
				strm << "  ";
			}
			
			if(--grct <= 0) {
				strm << " ";
				grct = bytes_per_group;
			}
		}
		strm << "  ";
		for(int i = 0; i < linelimit; ++i) {
			char ch = static_cast<char>(m_data[line+i]);
			if(isprint(ch))
				strm << ch;
			else
				strm << ".";
		}
		strm << std::endl;

		limit -= linelimit;
		line += linelimit;
	}
}