#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/write.hpp>
#include <boost/asio/read.hpp>
#include <boost/exception/all.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/thread.hpp>
#include <iostream>

using namespace boost;
using namespace boost::asio;
using namespace boost::posix_time;
using namespace boost::system;
using namespace std;

namespace {

const char * const CONNECTION_UNAVAILABLE("error.connection-unavailable");
const char * const RESOLVE_ERROR("error.resolve");
struct host_name;
struct port_value;

ip::tcp::endpoint createEndpoint(const string &hostName, unsigned int port) {
    io_service ioService;
    ip::tcp::resolver resolver(ioService);
    ip::tcp::resolver::query query(hostName, lexical_cast<string>(port), ip::tcp::resolver::query::numeric_service);
    try {
        ip::tcp::resolver::iterator resolve(resolver.resolve(query));
        if (resolve != ip::tcp::resolver::iterator()) {
            return *resolve;
        }
    } catch (...) {
        error_info<host_name, string> nameInfo(hostName);
        error_info<port_value, unsigned int> portInfo(port);
        exception_ptr nested(current_exception());
        runtime_error error(RESOLVE_ERROR);
        BOOST_THROW_EXCEPTION(enable_error_info(error) << nameInfo << portInfo << errinfo_nested_exception(nested));
    }
    error_info<host_name, string> nameInfo(hostName);
    error_info<port_value, unsigned int> portInfo(port);
    BOOST_THROW_EXCEPTION(enable_error_info(runtime_error(CONNECTION_UNAVAILABLE)) << nameInfo << portInfo);
}

void onSuccess(const error_code &error, size_t bytes_transferred) {
}

class ServerReceive {
private:
    volatile bool ready;
    string result;
public:
    ServerReceive() :
            ready(false) {
    }

    ~ServerReceive() {
    }

    void operator()() {
        io_service io;
        try {
            ip::tcp::socket socket(io);
            ip::tcp::acceptor acceptor(io, ip::tcp::endpoint(ip::tcp::v4(), 32768));
            acceptor.listen();
            ready = true;
            acceptor.accept(socket);
            char data[] = { '\0', '\0', '\0', '\0', '\0' };
            async_read(socket, buffer(data, 4), &onSuccess);
            // Illegal instruction
            io.run();
            result = data;
        } catch (const std::exception &ex) {
            result = ex.what();
            ready = true;
        }
    }

    const string &getResult() const {
        return result;
    }

    volatile bool isReady() const {
        return ready;
    }
};

}

int main(int argc, char *argv[]) {
    ServerReceive serverReceive;
    thread server(ref(serverReceive));
    while (!serverReceive.isReady()) {
        this_thread::sleep(milliseconds(100));
    }
    io_service io;
    ip::tcp::socket socket(io);
    socket.connect(createEndpoint("127.0.0.1", 32768));
    asio::write(socket, buffer("asdf", 4));
    server.join();
    cout << "Result: " << serverReceive.getResult() << endl;
}