#include "Server.hpp"
#include "Message.hpp"

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

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>

//Testing:
#include <fstream>
#include <iomanip>


namespace Plains {
namespace Resolver {

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

Server::Server(EventBus& eventBus)
  : _logger(Logger::getInstance()),
    _eventBus(eventBus)
{
    _logger.debug.ln ("Starting Resolver...");
    
    _logger.warn << "Testing some stuff..." << Logger::commit;
    //_logger.warn << "Message class overall size: " << sizeof(Message) << Logger::commit;
    //_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* message = new Message;
    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();
    */

    _stop = false;
    _thread = thread(&Server::run, this);
    _logger.debug.ln ("Resolver started");
}

Server::~Server() {
    _logger.debug.ln ("Stopping Resolver...");
    _stop = true;
    //_udpSocket->close();
    _thread.join();
    _logger.debug.ln ("Resolver stopped");
}

void Server::run() {
    //_ioContext.run();
    //doReceive();
    _logger.warn.ln ("Hi From resolver thread!");
    char msg[] = "Hello to you too!!!\n";

    int udpServerSocket, udpReadStatus;
    struct sockaddr_in serverAddress, clientAddress;
    socklen_t clientAddressLength;

    //binding the port to ip and port
    serverAddress.sin_family = AF_INET;
    serverAddress.sin_port = htons(PORT);
    serverAddress.sin_addr.s_addr = INADDR_ANY;
    clientAddressLength = sizeof(clientAddress);

    // Create receive buffer
    unsigned char buffer[65508] = { 0 }; // (2**16 = 65,536 − 8 byte UDP header − 20 byte IP header)

    // Create new UDP Socket
    if ((udpServerSocket = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        _logger.fatal.ln("socket creation error...");
    }

    // Bind UDP Socket
    if ((bind(udpServerSocket, (struct sockaddr*)&serverAddress, sizeof(serverAddress))) < 0) {
        _logger.fatal.ln("binding error...");
    }

    while(!_stop) {
        udpReadStatus = recvfrom(udpServerSocket, buffer, sizeof(buffer), 0, (struct sockaddr*)&clientAddress, &clientAddressLength);

        if (udpServerSocket < 0) {
            close(udpServerSocket);
            _logger.warn.ln("reading error...");
        }

        /*
        for(int i=0; i<udpReadStatus; ++i) {
            //std::cout << std::hex << (char)buffer[i];
            std::cout << std::setw(2) << static_cast<unsigned>(buffer[i]) << " ";
        }
        std::cout << std::endl << std::endl;
        */
       Message* message = (Message*) &buffer;

       //Spit out some header values for debugging.
       _logger.warn << "ID: "       << message->id();
       _logger.warn << " QR: "      << message->qr();
       _logger.warn << " OPCode: "  << message->opCode();
       _logger.warn << " AA: "      << message->aa();
       _logger.warn << " TC: "      << message->tc();
       _logger.warn << " RD: "      << message->rd();
       _logger.warn << " RA: "      << message->ra();
       _logger.warn << " RCode: "   << message->rCode();
       _logger.warn << " QDCount: " << message->qdCount();
       _logger.warn << " ANCount: " << message->anCount();
       _logger.warn << " NSCount: " << message->nsCount();
       _logger.warn << " ARCount: " << message->arCount();
       _logger.warn << Logger::commit;

        // Change message to response type and send back for testing
        message->qr(Message::QR::RESPONSE);
        //message->aa(Message::AA::AUTHORATATIVE);
        //message->ra(Message::RA::AVAILABLE);
        
        //if ( sendto(udpServerSocket, msg, strlen(msg), 0, (struct sockaddr*)&clientAddress, clientAddressLength) < 0 ) {
        if ( sendto(udpServerSocket, message->encode(), message->encodedSize(), 0, (struct sockaddr*)&clientAddress, clientAddressLength) < 0 ) {
            close(udpServerSocket);
            _logger.warn.ln("sending error...");
        }
    }

    close(udpServerSocket);
}

/*
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, std::size_t)
    {
        doReceive();
    });
}
*/




}}