#include <distorm.h>

#include <boost/program_options.hpp>
#include <boost/filesystem.hpp>
#include <boost/asio.hpp>
#include <boost/asio/post.hpp>

#include <iostream>
#include <fstream>

#include "le_file.hpp"
#include "le_parse_util.hpp"

#include "common.hpp"

static boost::asio::io_context io_context;
static le::File file;
static boost::asio::local::stream_protocol::socket connection_socket(io_context);

static uint32_t message_size;

void action_handler(boost::system::error_code const& error, size_t)
{
    if(!error)
    {
    }

    boost::asio::post(io_context, [](){
        connection_socket.async_receive(boost::asio::buffer(&message_size, sizeof message_size), 0, action_handler);
    });
}

void accept_handler(boost::system::error_code const& error)
{
    if(!error)
    {
        uint32_t binary_size = determine_binary_size(file);
        BinarySizeMessage size_message {
            .binary_size = binary_size
        };
        connection_socket.send(boost::asio::buffer(&size_message, sizeof size_message));

        BinaryBaseOffsetMessage offset_message;
        connection_socket.receive(boost::asio::buffer(&offset_message, sizeof offset_message));

        std::vector<uint8_t> binary = load_binary(file);
        relocate(file, binary, binparse::Offset32(offset_message.offset));

        uint32_t base_address = file.object_table.entries.at(file.le_header.EIP_object).reloc_base_address;
        BinaryLoadMessage message {
            .eip = file.le_header.EIP + base_address + offset_message.offset
        };

        connection_socket.send(boost::asio::buffer(&message, sizeof message));
        connection_socket.send(boost::asio::buffer(binary, binary.size()));

        boost::asio::post(io_context, [](){
            connection_socket.async_receive(boost::asio::buffer(&message_size, sizeof message_size), 0, action_handler);
        });
    }
}

int main(int argc, char* argv[])
{
    boost::program_options::options_description description;
    description.add_options()
        ("help,h", "produces this help message")
        ("exe,e", boost::program_options::value<std::string>(), "The LE executable to parse the header for.")
    ;

    boost::program_options::variables_map vm;
    boost::program_options::store(boost::program_options::parse_command_line(argc, argv, description), vm);
    boost::program_options::notify(vm);

    if(vm.count("help")) {
        std::cout << description << std::endl;
        return 0;
    }

    boost::filesystem::path file_path;
    if(vm.count("exe")) {
        std::string exe_file = vm["exe"].as<std::string>();

        if(boost::filesystem::exists(exe_file)) {
            if(!boost::filesystem::is_directory(exe_file)) {
                file_path = exe_file;
            } else {
                std::cerr << exe_file << " is a folder" << std::endl;
                std::cerr << std::endl;
                std::cerr << description << std::endl;
                return -1;
            }
        } else {
            std::cerr << "file: " << exe_file << " does not exist" << std::endl;
            std::cerr << std::endl;
            std::cerr << description << std::endl;
            return -1;
        }
    } else {
        std::cerr << "Option \"exe_file\" is required";
        std::cerr << std::endl;
        std::cerr << description << std::endl;
        return -1;
    }

    std::ifstream file_stream(file_path, std::ios::binary);
    file_stream.unsetf(std::ios::skipws);
    file = le::parse_file(file_stream);

    boost::filesystem::remove(socket_name);

    boost::asio::local::stream_protocol::endpoint ep(socket_name);
    boost::asio::local::stream_protocol::acceptor acceptor(io_context, ep);
    acceptor.async_accept(connection_socket, accept_handler);

    io_context.run();

    boost::filesystem::remove(socket_name);
    return 0;
}