#include "Server.hpp"
#include "Message.hpp"
#include <fstream>

#include <memory>
#include <utility>
#include <vector>
#include <ctime>


namespace Plains {
namespace Resolver {

using asio::ip::udp;
using asio::ip::tcp;

static char* byteToHex(char c) {
    static char* out = new char[3];
    out[2] = 0x0; //Terminate string
    const char* dict = "0123456789ABCDEF";
    char left  = c & 0xF; //Mask upper 4 bits on the right
    char right = c >> 4;
    out[0] = dict[right];
    out[1] = dict[left];
    return out;
}

static char* intToHex(unsigned byteCount, int c) {
    //static char* out = new char[byteCount*3+1];
    static char* out = new char[32];
    const char* byte = (char*)&c;

    //printf("%x\n", c);
    //printf("%x\n", byte[0] & 0xFF);
    //printf("%x\n", byte[1] & 0xFF);
    

    out[byteCount*3] = 0x0; //Terminate string
    //out[4] = 0xE; //Terminate string
    for (unsigned i = 0; i < byteCount; i++) {
        //std::cout << "i(" << i << ") ";
        //char byte = (c >> (i*8)) & 0xFF;
        const char* nibble = byteToHex(byte[i]);
        out[i*3]     = nibble[0];
        out[i*3+1]   = nibble[1];
        out[i*3+2]   = ' ';
        //std::cout <<  "Char1(" << out[0] << ") Char2(" << out[1] << ") Char3(" << out[2] << ")" << std::endl;
    }
    return out;
}

Server::Server(Logger& logger, EventBus& eventBus)
  : _logger(logger),
    _eventBus(eventBus)
{
    _logger.debug.ln ("Starting Resolver...");
    //throw Exception("Testi");
/*
    _logger.debug << "Testing some stuff..." << Logger::commit;
    _logger.debug << "Message header overall size: " << sizeof(Message::Header) << Logger::commit;
//    _logger.debug << "Message::Header size:" << sizeof(Message::Header) << endl;
//    _logger.debug << "Message::QR:RESPONSE Enum:" << Message::QR::RESPONSE << endl;

    std::fstream myfile;
    std::streampos beg,end;
    myfile.open ("/tmp/packet.bin", std::ios::in | std::ios::binary);
    myfile.seekg (0, std::ios::end);
    end = myfile.tellg();
    myfile.seekg (0, std::ios::beg);
    beg = myfile.tellg();
    const unsigned long size = end-beg;
    Message::Header* header = new Message::Header;
    myfile.read ((char*)header, sizeof(Message));
    _logger.debug << "size is: " << size << " bytes." << Logger::commit;

    _logger.debug << "Header: " << Logger::commit;
    //_logger.debug << "ID: " << 0x1ef8 <<
    _logger.debug << "ID: " << intToHex(2, header->id) <<
    "   QR: " << byteToHex(header->qr) <<
    "   OPCode: " << byteToHex(header->opCode) << Logger::commit <<
    "Authoritive Answer: " << byteToHex(header->aa) << Logger::commit <<
    "Truncation Flag: " << byteToHex(header->tc) << Logger::commit <<
    "Recursion Desired: " << byteToHex(header->rd) << Logger::commit <<
    "Recursion Available: " << byteToHex(header->ra) << Logger::commit <<
    "RCode: " << byteToHex(header->rCode) << Logger::commit <<
    "Question Count: " << intToHex(2, header->qdCount) << Logger::commit <<
    "Answer Record Count: " << intToHex(2, header->anCount) << Logger::commit <<
    "Authority Record Count: " << intToHex(2, header->nsCount) << Logger::commit <<
    "Additional Record Count: " << intToHex(2, header->arCount) << Logger::commit;
    myfile.close();
    //Testing over
    _logger.debug << "Done testing" << Logger::commit;
*/
    _udpSocket = new udp::socket(_ioContext, udp::endpoint(udp::v4(), 8853));
    _ioContext.run();
    doReceive();
    _logger.debug.ln ("Resolver started");
}

Server::~Server() {
    _logger.debug.ln ("Stopping Resolver...");
    _udpSocket->close();
    _logger.debug.ln ("Resolver stopped");
}

//void Server::run() {
//    _ioContext.run();
//    doReceive();
//}

void Server::doReceive()
{
    _udpSocket->async_receive_from(
        asio::buffer(_data, 1024), _sender_endpoint,
        [this](std::error_code ec, std::size_t bytes_recvd)
    {
        if (!ec && bytes_recvd > 0) {
            doSend(bytes_recvd);
        }
        else {
            doReceive();
        }
    });
}

void Server::doSend(std::size_t length)
{
    _udpSocket->async_send_to (
        asio::buffer(_data, length), _sender_endpoint,
        [this](std::error_code /*ec*/, std::size_t /*_bytessent*/)
    {
        doReceive();
    });
}





}}