#include <IRCClient/client.hpp>
/*
#include <IRCClient/logger.hpp>
#include <IRCClient/plugin.hpp>
*/

int main(int argc, char *argv[]) {
/*
    if(argc > 2) {
        logger::log(logger::output_type::STDERR, "usage: {1} [config_file]", argv[0]);
        return 1;
    }
*/
    client::irc bot(
        "irc.freenode.net", // server to connect to
        "6667", // port to connect on
        "", // password
        false, // don't connect with ssl
        "squawker", // nick
        "squawker", // realname
        "A c++11 Utility bot written by nchambers", // ident
        "#cplusplus.com", // channels to join
        "." // command prefix
    );

    bot.on_connect([&bot]() -> void {
        bot.nickserv(client::ns::identify, <REDACTED>);
    });
/*
    bot.add_handler(client::input_type::privmsg, [](std::string channel, std::string user, std::string msg) -> void {
        logger::log(logger::output_type::STDOUT, "[{1}/{2}] {3}", user, channel, msg);
    });

    bot.add_handler(client::input_type::command, "load", [&bot](std::string channel, std::string user, std::string msg) -> void {
        bot.load_plugin(plugin::plugin(msg));

        if(bot.plugin_operation_successful()) {
            logger::log(logger::output_type::STDOUT, "successfully loaded plugin {1}", msg);
            bot.msg(channel, "{1}: successfully loaded plugin {2}", user, msg);
        }

        else {
            logger::log(logger::output_type::STDERR, "failure to load plugin {1}", msg);
            bot.msg(channel, "{1}: failure to load plugin {2}", user, msg);
        }
    });

    bot.add_handler(client::input_type::command, "unload", [&bot](std::string channel, std::string user, std::string msg) -> void {
        bot.unload_plugin(plugin::plugin(msg));

        if(bot.plugin_operation_successful()) {
            logger::log(logger::output_type::STDOUT, "successfully unloaded plugin {1}", msg);
            bot.msg(channel, "{1}: successfully unloaded plugin {2}", user, msg);
        }

        else {
            logger::log(logger::output_type::STDERR, "failure to unload plugin {1}", msg);
            bot.msg(channel, "{1}: failure to unload plugin {2}", user, msg);
        }
    });

    bot.add_handler(client::input_type::command, "reload", [&bot](std::string channel, std::string user, std::string msg) -> void {
        bot.reload_plugin(plugin::plugin(msg));

        if(bot.plugin_operation_successful()) {
            logger::log(logger::output_type::STDOUT, "successfully reloaded plugin {1}", msg);
            bot.msg(channel, "{1}: successfully reloaded plugin {2}", user, msg);
        }

        else {
            logger::log(logger::output_type::STDERR, "failure to reload plugin {1}", msg);
            bot.msg(channel, "{1}: failure to reload plugin {2}", user, msg);
        }
    });*/

    bot.run();
    return 0;
}

#ifndef _ROOT_SQUAWKER_IRCCLIENT_CLIENT_HPP__
#define _ROOT_SQUAWKER_IRCCLIENT_CLIENT_HPP__

#include <string>
#include <functional>

#include <boost/asio.hpp>

namespace client {
    enum class ns: int {
        identify=0,
    };

    enum class input_type: int {
        privmsg=0,
    };

    class irc {
    public:
        irc(std::string, std::string, std::string, bool, std::string, std::string, std::string, std::string, std::string);

        void on_connect(std::function<void()>);
        void nickserv(client::ns, std::string);
        void run();

        void send(std::string);

    private:
        void connect();
        std::string readline();

        std::string server;
        std::string port;
        std::string pass;
        bool use_ssl;
        std::string nick;
        std::string realname;
        std::string ident;
        std::string channels;
        std::string prefix;
        std::function<void()> on_connect_callback;
        boost::asio::io_service io_service;
        boost::asio::ip::tcp::socket socket;
    };
}

#endif

#include <IRCClient/client.hpp>
#include <iostream>
#include <sstream>
#include <array>

client::irc::irc(
    std::string server, std::string port, std::string pass,
    bool use_ssl, std::string nick, std::string realname,
    std::string ident, std::string channels, std::string prefix
) :
    server(server), port(port), pass(pass),
    use_ssl(use_ssl), nick(nick), realname(realname),
    ident(ident), channels(channels), prefix(prefix),
    on_connect_callback([]()->void{}), socket(this->io_service) {
}

void client::irc::on_connect(std::function<void()> on_connect_callback) {
    this->on_connect_callback = on_connect_callback;
}

void client::irc::nickserv(client::ns command, std::string arguments) {
    switch(command) {
    case client::ns::identify:
        this->send("nickserv identify " + arguments);
        break;
    }
}

void client::irc::run() {
    this->connect();

    while(true) {
        std::array<char, 128> buf;
        boost::system::error_code error;
        size_t len = this->socket.read_some(boost::asio::buffer(buf), error);

        if(error == boost::asio::error::eof) {
            break;
        }

        else if (error) {
            throw boost::system::system_error(error);
        }

        std::cout.write(buf.data(), len);
    }
}

void client::irc::send(std::string msg) {
    this->socket.write_some(boost::asio::buffer(msg + std::string("\r\n")));
}

void client::irc::connect() {
    boost::asio::ip::tcp::resolver resolver(this->io_service);
    boost::asio::ip::tcp::resolver::query query(this->server, this->port);
    boost::asio::ip::tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);

    boost::asio::connect(this->socket, endpoint_iterator);
    this->send("NICK " + this->nick);
    this->send("USER " + this->realname + " * * :" + this->ident);

    while(true) {
        std::string line = this->readline();
        std::cout << line << std::endl;

        if(line == ":squawker MODE squawker :+i") {
            break;
        }
    }

    this->on_connect_callback();
}

std::string client::irc::readline() {
    boost::asio::streambuf buffer;
    size_t received = boost::asio::read_until(this->socket, buffer, "\r\n");
    std::istream is(&buffer);
    std::string line;
    std::getline(is, line);
    return std::string(std::begin(line), std::end(line)-1);
}