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

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


namespace Plains {
namespace Resolver {

using asio::ip::udp;

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 << "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

    _socket = new udp::socket(_io_context, udp::endpoint(udp::v4(), 8853));
}

Server::~Server() {
    
}

void Server::run() {
    _io_context.run();
    do_receive();
}

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

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



}}