def log_to_mongo(data, signal, raw_message):
    """ Parse a raw IRC message and insert it into a mongo collection """

    global mongo_collection

    parsed_message = weechat.info_get_hashtable('irc_message_parse', { 'message': raw_message })

    log_entry = {
        'server': signal.split(',')[0],
        'nick': parsed_message['nick'],
        'host': parsed_message['host'],
        'command': parsed_message['command'],
        'channel': parsed_message['channel'],
        'arguments': parsed_message['arguments']
    }

    if 'text' in parsed_message and len(parsed_message['text']) > 0:
        log_entry['text'] = parsed_message['text']
    elif log_entry['command'] == 'PRIVMSG':
        # fallback for pre-1.3 weechat
        log_entry['text'] = log_entry['arguments'].split(' :', 1)[-1]

    # denote any URLs
    if 'text' in log_entry and re.search(HTTP_PATTERN, log_entry['text']):
        log_entry['urls'] = re.findall(HTTP_PATTERN, log_entry['text'])

    mongo_collection.insert(log_entry)

    return weechat.WEECHAT_RC_OK

def do_unencrypt(data, signal, signal_data):
    #wc.prnt(wc.current_buffer(), "===>\tentered do_unencrypt")

    dict = wc.info_get_hashtable("irc_message_parse", { "message": signal_data } )
    #for d in dict:
    #    wc.prnt(wc.current_buffer(), "==>\t%s" % d)
    #    wc.prnt(wc.current_buffer(), "===>\t%s" % dict[d])

    # channel info
    nick = dict['nick']
    server = signal.split(",")[0]
    channel = dict['channel']
    buffer = wc.info_get("irc_buffer", "%s,%s" % (server, channel) )

    # get and unencrypt
    dirty = dict['arguments'].split(':')[1]
    clean = dirty[2:] #clean = dirty[-2:]
    clean = enc(clean)[0]


    ## put the data back onto the screen
    if dirty[0]=='#' and dirty[1]=='#':
        if buffer:
            wc.prnt(buffer, "[%s]\t%s" % (nick, clean))
    return wc.WEECHAT_RC_OK

def get_hashtable(string):
    parsed = weechat.info_get_hashtable('irc_message_parse', dict(message=string))
    try:
        parsed['message'] = parsed['arguments'].split(' :', 1)[1]
    except:
        parsed['message'] = ""
    match = regex_get_user.match(parsed['host'])
    result = match.groupdict()

    parsed['user'] = result['from_user']
    parsed['host'] = result['from_host']

    if OPTIONS['debug'] == 'on':
        weechat.prnt("","debug_mode: hashtable")
        weechat.prnt("","string: %s" % string)
        weechat.prnt("","nick: %s" % parsed['nick'])
        weechat.prnt("","from_user: %s" % parsed['user'])
        weechat.prnt("","from_host: %s" % parsed['host'])
        weechat.prnt("","channel: %s" % parsed['channel'])
        weechat.prnt("","message: %s" % parsed['message'])
        weechat.prnt("","arguments: %s" % parsed['arguments'])
        regex_get_channel=re.match(r'#(.*)',parsed['arguments'])
        if channel != '':
            weechat.prnt("",regex_get_channel.group())
        weechat.prnt("","---end---")
    return parsed

def twitch_roomstate(data, modifier, server, string):
    message = weechat.info_get_hashtable(
        'irc_message_parse', {"message": string})
    buffer = weechat.buffer_search(
        "irc", "%s.%s" % (server, message['channel']))
    for tag in message['tags'].split(';'):
        if tag == 'subs-only=0':
            weechat.buffer_set(buffer, 'localvar_set_subs', '')
        if tag == 'subs-only=1':
            weechat.buffer_set(buffer, 'localvar_set_subs', '1')
        if tag == 'r9k=0':
            weechat.buffer_set(buffer, 'localvar_set_r9k', '')
        if tag == 'r9k=1':
            weechat.buffer_set(buffer, 'localvar_set_r9k', '1')
        if tag == 'emote-only=0':
            weechat.buffer_set(buffer, 'localvar_set_emote', '')
        if tag == 'emote-only=1':
            weechat.buffer_set(buffer, 'localvar_set_emote', '1')
        if tag.startswith('slow='):
            value = tag.split('=')[-1]
            if value == '0':
                weechat.buffer_set(buffer, 'localvar_set_slow', '')
            if value > '0':
                weechat.buffer_set(buffer, 'localvar_set_slow', value)
        twitch_main('', buffer, 'bs')
    return ''

def seamless_cb(data, modifier, modifier_data, string):
    info = weechat.info_get_hashtable("irc_message_parse", {"message": string})
    info["server"] = modifier_data
    channel = info["channel"]
    buf_p = weechat.buffer_search("==", "irc." + info["server"] + "." + channel)
    if not buf_p:
        debug("no buffer for %s" % "irc." + info["server"] + "." + info["channel"])
        return string
    text = info.get("text", info["arguments"].split(" :", 1)[1])
    action = re.match(r"^\x01.*\x01", text)
    if action:
        # CTCP
        if not re.match(r"^\x01ACTION\b", text):
            # A CTCP other than ACTION, do nothing.
            return string
        text = re.sub(r"^\x01ACTION |\x01$", "", text)
        prefix = "action_"
    else:
        # Regular PRIVMSG
        prefix = "privmsg_"
    for nick, servers in _nicks:
        if servers and not (info["server"] in servers):
            continue
        nick_re = r"^%s" % re.escape(nick)
        if not re.match(nick_re, info["nick"]):
            continue
        debug("%s is a valid server." % info["server"])
        debug("%s matches %s" % (nick_re, nick))
        debug(string)
        for bot in _bots:
            result = reformat(string, info, bot, prefix, text)
            if result:
                return result
    return string

def privmsg(data, signal, signal_data):
    (server, signal) = signal.split(",")
    channels = wc.config_get_plugin('channels').replace(',', '|')
    api_key = wc.config_get_plugin('api_key')
    if re.match('^\${sec\.data\.(.*)}$', api_key):
        api_key = wc.string_eval_expression(api_key, {}, {}, {})
    bots_list = wc.config_get_plugin('other_bots').split(",")
    details = wc.info_get_hashtable("irc_message_parse", {"message": signal_data, "server": server})
    youtube_regex_match = re.compile(r'(.*https?://)?(www\.)?(youtube|youtu|youtube-nocookie)\.(com|be)/(watch\?v=|embed/|v/|.+\?v=)?([a-zA-Z0-9_-]{11})').match(details['text'])
    buffer_name = details['channel']
    buffer_pointer = wc.info_get("irc_buffer", "%s,%s" % (server, buffer_name))
    channels_regex = re.compile(r'(%s)' % (channels), re.I)
    bots_exist = False
    if channels_regex.match(buffer_name) and youtube_regex_match:
        if not bots_list == "not_set":
            for other_bots in bots_list:
                bots_test = wc.nicklist_search_nick(buffer_pointer, "", other_bots)
                if bots_test:
                    bots_exist = True
        if not bots_exist:
            if not api_key == "not_set":
                vid_id = youtube_regex_match.group(6)
                rvt = requests.get('https://www.googleapis.com/youtube/v3/videos/?id={0}&part=snippet&key={1}'.format(vid_id, api_key))
                rvc = requests.get('https://www.googleapis.com/youtube/v3/videos/?id={0}&part=statistics&key={1}'.format(vid_id, api_key))
                try:
                    vid_title = rvt.json()['items'][0]['snippet']['title'].encode('utf-8')
                    vid_channel = rvt.json()['items'][0]['snippet']['channelTitle'].encode('utf-8')
                    vid_views = rvc.json()['items'][0]['statistics']['viewCount']
                    wc.command("", r"/msg {0} [Youtube] {1} | Channel: {2} | Views: {3}".format(buffer_name, vid_title, vid_channel, vid_views))
                except:
                    wc.command("", r"/msg {0} [Youtube] Error getting video info.".format(buffer_name))
            else:
                wc.command("", r"/msg {0} Youtube api key not set.".format(buffer_name))
    return wc.WEECHAT_RC_OK

def get_hashtable(string):
    parsed = weechat.info_get_hashtable("irc_message_parse", dict(message=string))
    try:
        parsed["message"] = parsed["arguments"].split(" :", 1)[1]
    except:
        parsed["message"] = ""
    return parsed

def unhide_buffer_cb(data, signal, signal_data):
    """Unhide a buffer on new activity.

    This callback unhides the buffer in which a new message has been received.
    If configuration option ``unhide_low`` is enabled,
    buffers with only low messages (like JOIN, PART, etc.) will be unhidden as well.
    """
    server = signal.split(",")[0]
    message = weechat.info_get_hashtable(
        "irc_message_parse",
        {"message": signal_data})
    channel = message["channel"]
    hotlist = hotlist_dict()
    buffer = weechat.info_get("irc_buffer", "{},{}".format(server, channel))

    if not buffer in hotlist.keys():
        # just some background noise
        return WEECHAT_RC_OK

    if (weechat.config_get_plugin("unhide_low") == "on"
            and hotlist[buffer]["count_low"] > 0
            or hotlist[buffer]["count_message"] > 0
            or hotlist[buffer]["count_private"] > 0
            or hotlist[buffer]["count_highlight"] > 0):
        weechat.buffer_set(buffer, "hidden", "0")

    return WEECHAT_RC_OK

def on_channel_mode(data, signal, signal_data):
    """Whenever a channel mode is set."""

    if w.config_get_plugin("disabled") in ["true", "yes"]:
        return w.WEECHAT_RC_OK

    parsed = w.info_get_hashtable("irc_message_parse", {"message": signal_data})

    server = signal.split(",")[0]
    channel = parsed["channel"]

    if not should_match(server, channel):
        return w.WEECHAT_RC_OK

    chars = w.config_get_plugin("matching_modes")
    modes_set = parsed["text"].split(" ")[0]
    found = False

    for c in chars:
        if c in modes_set:
            found = True
            break

    if not found:
        return w.WEECHAT_RC_OK

    modes = parse_modes(parsed["text"])

    for mode in modes:
        mode["setter"] = parsed["nick"]
        match_mode(server, channel, mode)

    return w.WEECHAT_RC_OK

def get_hashtable(string):
    parsed = weechat.info_get_hashtable("irc_message_parse", dict(message=string))
    try:
        parsed["message"] = parsed["arguments"].split(" :", 1)[1]
    except:
        parsed["message"] = ""
    match = regex_get_user.match(parsed["host"])
    result = match.groupdict()

    parsed["user"] = result["from_user"]
    parsed["host"] = result["from_host"]

    if OPTIONS["debug"] == "on":
        weechat.prnt("", "debug_mode: hashtable")
        weechat.prnt("", "string: %s" % string)
        weechat.prnt("", "nick: %s" % parsed["nick"])
        weechat.prnt("", "from_user: %s" % parsed["user"])
        weechat.prnt("", "from_host: %s" % parsed["host"])
        weechat.prnt("", "channel: %s" % parsed["channel"])
        weechat.prnt("", "message: %s" % parsed["message"])
        weechat.prnt("", "arguments: %s" % parsed["arguments"])
        regex_get_channel = re.match(r"#(.*)", parsed["arguments"])
        if channel != "":
            weechat.prnt("", regex_get_channel.group())
        weechat.prnt("", "---end---")
    return parsed

def parse_privmsg(message):
    weechat_result = weechat.info_get_hashtable('irc_message_parse',
                                                {'message': message})
    if weechat_result['command'].upper() == 'PRIVMSG':
        args = weechat_result['arguments'].decode('utf-8', 'replace')
        target, text = args.split(' ', 1)
        if text.startswith(':'):
            text = text[1:]

        result = {
            'from': weechat_result['host'].decode('utf-8', 'replace'),
            'to': target,
            'text': text,
        }

        if target[0] in ('#', '&', '!', '+'):
            result['to_channel'] = target
            result['to_nick'] = None
        else:
            result['to_channel'] = None
            result['to_nick'] = target

        return result
    else:
        raise Exception("Failed parsing PRIVMSG")

def stop_typing(data, signal, signal_data):
    msg_hash = w.info_get_hashtable(
        "irc_message_parse", {"message": signal_data } )
    if msg_hash["nick"] in typing:
        del typing[msg_hash["nick"]]
    w.bar_item_update("bitlbee_typing_notice")
    return w.WEECHAT_RC_OK

def getbuffer(modifier_data, string):
  msg = weechat.info_get_hashtable("irc_message_parse",{ "message": string })
  if weechat.info_get('irc_is_channel', '{moddata},{channel}'.format(moddata=modifier_data, channel=msg['channel'])) == '1':
    name = msg['channel']
  else:
    name = msg['nick']
  buffer_full_name = '{moddata}.{name}'.format(moddata=modifier_data, name=name)
  return weechat.buffer_search("irc", buffer_full_name)

def handle_globaluserstate(data, modifier, modifier_data, string):
    """Handles a GLOBALUSERSTATE"""
    if modifier_data not in (twitch_settings["twitch_server"], twitch_settings["group_server"]):
        return string
    parsed = weechat.info_get_hashtable("irc_message_parse", {"message": string})
    # All we're interested in are user tags
    update_user(user_self["name"], parse_tags(parsed["tags"])[1])
    return ""

def twitch_privmsg(data, modifier, server_name, string):
    if not server_name in OPTIONS['servers'].split():
        return string
    message = weechat.info_get_hashtable(
        'irc_message_parse', {"message": string})
    if message['channel'].startswith('#'):
        return string
    newmsg = 'PRIVMSG #%s :/w %s %s' % (message['nick'],message['nick'],message['text'])
    return newmsg

def handle_query(data, signal, signal_data):
    global buffer_data
    # data: empty string
    # signal: <server>,irc_in_PRIVMSG
    # signal_data: whole message unparsed
    # parse the message
    parsed = weechat.info_get_hashtable("irc_message_parse",
                                        {"message": signal_data})
    # where should we answer?
    server = signal.split(",")[0]
    channel = parsed["channel"]
    current_nick = weechat.info_get("irc_nick", server)
    user = parsed["nick"]
    message = parsed["text"]

    if channel == current_nick:
        # we got a message through a private query, refuse it
        buffer_out = weechat.info_get("irc_buffer", server + "," + user)
        # close private buffers, but not server buffers
        # localvar_type can assume five values: private, channel, server, weechat and ""
        if weechat.buffer_get_string(buffer_out,"localvar_type") == "private":
            weechat.command(buffer_out, "How about speaking to me in public?")
            weechat.buffer_close(buffer_out)
    else:
        # query came from public channel
        if message.startswith(current_nick + ":"): # it's a command to our bot
            query = message.split(":")[1].strip() # remove the part before the colon, and lead/trail whitespaces
            s = query.split(" ", 1)
            command = s[0].lower() # command is case-insensitive
            args = s[1] if len(s) == 2 else ""
            target = "{0},{1}".format(server, channel) # this is the key to the dict containing the lists
            if command == "coin":
                out_msg = _coin()
            elif command == "help":
                out_msg = _help(user)
            elif command == "dice":
                out_msg = _dice(args)
            elif command == "server":
                out_msg = _server()
            elif command == "about":
                out_msg = _about()
            elif command == "rps":
                out_msg = _rps(user, args)
            elif command == "list":
                out_msg = _list(target,user,args)
            elif command == "coffee":
                out_msg = _coffee()
            elif command == "eightball":
                out_msg = _8ball()
            else:
                out_msg = "Unrecognized command. Type '{0}: help' to get a list of commands".format(current_nick)

            buffer_out = weechat.info_get("irc_buffer", server + "," + channel)
            if weechat.buffer_get_string(buffer_out,"localvar_type") == "channel":
                weechat.command(buffer_out, out_msg)

    return weechat.WEECHAT_RC_OK # must always return this or WEECHAT_RC_ERROR

def parse_message(irc_message, server=None):
    # parse the message
    message_dict = {"message": irc_message}
    parsed = weechat.info_get_hashtable("irc_message_parse", message_dict)
    if server:
        parsed["server"] = server
    # remove the channel part from PRIVMSG arguments
    message = ":".join(parsed["arguments"].split(":")[1:])
    return(parsed, message)

def twitch_whisper(data, modifier, modifier_data, string):
    message = weechat.info_get_hashtable(
        'irc_message_parse', {"message": string})
    if message['tags']: string = '@'+message['tags']+' '
    else: string = ''
    string += ':'+message['host']
    string += ' PRIVMSG'
    string += ' '+message['arguments']
    return string

def handle_userstate(data, modifier, modifier_data, string):
    """Handles a USERSTATE"""
    if modifier_data not in (twitch_settings["twitch_server"], twitch_settings["group_server"]):
        return string
    parsed = weechat.info_get_hashtable("irc_message_parse", {"message": string})
    # We're not interested in tags like emote-set etc.
    _, user_tags, channel_tags = parse_tags(parsed["tags"])
    update_user(user_self["name"], user_tags, parsed["text"], channel_tags)
    return ""

def parse_message(signal_data):
	hashtable = weechat.info_get_hashtable("irc_message_parse", {"message": signal_data})

	# parse arguments string into usable pieces
	args = hashtable["arguments"].split(":", 1)
	hashtable["args"] = args[0].split()
	if len(args) > 1:
		hashtable["text"] = args[1]

	return hashtable