#include <string.h>
#include <assert.h>             /* assert */
#include <errno.h>
#include <stdio.h>              /* size_t */

#include "libircclient.h"

#include "data.h"
#include "events.h"
#include "threads.h"

#ifndef UNUSED
#define UNUSED(x) (void)(x)
#endif

char F_SPAM_THREADS = STOPPED;

THREAD_FUNCTION(gen_spam) {
    struct spam_params_t *sp = (struct spam_params_t *)arg;
    while (RUNNING == F_SPAM_THREADS) {
        if (irc_cmd_msg(sp->session, sp->channel, sp->phrase))
            break;
        if (sp->timer > 0)
            sleep((unsigned int)sp->timer);
    }
    return 0;
}

EVENT_SIGNATURE(start_spam) {
    struct irc_ctx_t *ctx;
    static struct spam_params_t spam1;
    static struct spam_params_t spam2;
    static struct spam_params_t spam3;
    thread_id_t tid;
    UNUSED(count);
    UNUSED(event);
    UNUSED(origin);
    UNUSED(params);
    ctx = (struct irc_ctx_t *)irc_get_ctx(session);
    spam1.session = spam2.session = spam3.session = session;
    spam1.channel = spam2.channel = spam3.channel = ctx->channel;
    spam1.phrase = "HEHE";
    spam2.phrase = "HAHA";
    spam3.phrase = "HUHU";
    spam1.timer = 2;
    spam2.timer = 3;
    spam3.timer = 4;
    printf("We just joined the channel %s; starting the spam threads\n", params[0]);
    F_SPAM_THREADS = RUNNING;
    if (CREATE_THREAD(&tid, gen_spam, &spam1)
            || CREATE_THREAD(&tid, gen_spam, &spam2)
            || CREATE_THREAD(&tid, gen_spam, &spam3))
        printf("CREATE_THREAD failed: %s\n", strerror(errno));
    else
        printf("Spammer thread was started successfully.\n");
}


void dump_event(irc_session_t * session, const char *event, const char *origin, const char **params, unsigned int count) {
    char buf[1024];
    unsigned int cnt;

    UNUSED(session);

    buf[0] = '\0';

    memset(buf, 0, sizeof buf);
    for (cnt = 0; cnt < count; cnt++) {
        if (cnt)
            strcat(buf, "|");

        strcat(buf, params[cnt]);
    }

    printf("Event \"%s\", origin: \"%s\", params: %d [%s]\n", event, origin ? origin : "NULL", cnt, buf);
}

EVENT_SIGNATURE(event_connect) {
    struct irc_ctx_t *ctx;

    UNUSED(event);
    UNUSED(origin);
    UNUSED(params);
    UNUSED(count);

    ctx = (struct irc_ctx_t *)irc_get_ctx(session);

    printf("Server: %s\nPort: %d\nNick: %s\nChannel: %s\n", ctx->server, ctx->port, ctx->nick, ctx->channel);
    irc_cmd_join(session, ctx->channel, 0);
}

EVENT_NUMERIC_SIGNATURE(event_numeric) {
    char buf[24];

    snprintf(buf, sizeof buf, "%d", event);

	dump_event (session, buf, origin, params, count);

    if (event > 400) {
        printf("ERROR %d: %s: %s %s %s %s\n", event, origin ? origin : "unknown", params[0], count > 1 ? params[1] : "", count > 2 ? params[2] : "", count > 3 ? params[3] : "");
    }
}

EVENT_SIGNATURE(event_channel) {
    struct irc_ctx_t *ctx;
    char nickbuf[128];

    UNUSED(event);
    UNUSED(params);
    UNUSED(count);

	dump_event (session, event, origin, params, count);

    if (NULL == origin || count < 2)
        return;

    irc_target_get_nick(origin, nickbuf, sizeof(nickbuf));

    if (strcmp(nickbuf, "Bubblegumdrop")) {
        return;
    }

    ctx = (struct irc_ctx_t *)irc_get_ctx(session);
    UNUSED(ctx);

    if (!strcmp(params[1], ".stop")) {
        irc_cmd_msg(session, params[0], ":x");
        F_SPAM_THREADS = STOPPED;
    }

    if (!strcmp(params[1], ".start")) {
        irc_cmd_msg(session, params[0], ":v");
        F_SPAM_THREADS = RUNNING;
        start_spam (session, ctx->nick, origin, params, count);
    }

    if (!strcmp(params[1], ".quit")) {
        F_MAIN_THREAD = STOPPED;
        F_IRC_THREAD = STOPPED;
        F_MAIN_THREAD = STOPPED;
        irc_cmd_quit(session, "Bye!");
    }

#if 0
    if (ctx->insolents.find(nickbuf) == ctx->insolents.end())
        ctx->insolents[nickbuf]
            = 0;

    ctx->insolents[nickbuf]++;

    printf("'%s' swears in the channel '%s' %d times\n", nickbuf, params[1], ctx->insolents[nickbuf]);

    switch (ctx->insolents[nickbuf]) {
    case 1:
        // Send a private message
        sprintf(text, "%s, please do not swear in this channel.", nickbuf);
        irc_cmd_msg(session, nickbuf, text);
        break;

    case 2:
        // Send a channel message
        sprintf(text, "%s, do not swear in this channel, or you'll leave it.", nickbuf);
        irc_cmd_msg(session, params[0], text);
        break;

    default:
        // Send a channel notice, and kick the insolent
        sprintf(text, "kicked %s from %s for swearing.", nickbuf, params[0]);
        irc_cmd_me(session, params[0], text);
        irc_cmd_kick(session, nickbuf, params[0], "swearing");
        break;
    }
#endif
}

EVENT_SIGNATURE(event_join) {
    struct irc_ctx_t *ctx;

    UNUSED(count);
    UNUSED(event);

    if (!origin)
        return;

    ctx = (struct irc_ctx_t *)irc_get_ctx(session);

    /*
     * We need to know whether WE are joining the channel, or someone else.
     * To do this, we compare the origin with our nick.
     * Note that we have set LIBIRC_OPTION_STRIPNICKS to obtain 'parsed' nicks.
     */
    if (!strcmp(origin, ctx->nick)) {
        /* start_spam (session, ctx->nick, origin, params, count); */
    } else {
        char textbuf[168];
        sprintf(textbuf, "Hey, %s, hi!", origin);
        irc_cmd_msg(session, params[0], textbuf);
    }
}

EVENT_SIGNATURE(event_nick) {
    char nickbuf[128];
    struct irc_ctx_t *ctx;

    UNUSED(event);
    UNUSED(params);

    if (!origin || count != 1)
        return;

    irc_target_get_nick(origin, nickbuf, sizeof(nickbuf));
    ctx = (struct irc_ctx_t *)irc_get_ctx(session);
    UNUSED(ctx);

#if 0
    if (ctx->insolents.find(nickbuf) != ctx->insolents.end()) {
        printf("%s has changed its nick to %s to prevent penalties - no way!\n", nickbuf, params[0]);
        ctx->insolents[params[0]] = ctx->insolents[nickbuf];
        ctx->insolents.erase(nickbuf);
    }
#endif
}