def input_delete_cb(data, signal, signal_data):
    buffer = signal
    delete_localvar_replace_mode(buffer)
    weechat.buffer_set(buffer, 'localvar_del_spell_correction_suggest_item', '')
    weechat.buffer_set(buffer, 'localvar_del_spell_correction_suggest_input_line', '')
    weechat.bar_item_update('spell_correction')
    return weechat.WEECHAT_RC_OK

def urlbar_cmd(data, buffer, args):
    """ Callback for /url command. """
    global urls, DISPLAY_ALL

    if args == "list":
        if urls:
            DISPLAY_ALL = True
            weechat.command("", '/bar show urlbar')
            weechat.bar_item_update("urlbar_urls")
        else:
            weechat.prnt('', 'URL list empty.')
    if args == "show":
        weechat.command('', '/bar show urlbar')
    elif args == 'hide':
        weechat.command("", "/bar hide urlbar")
    elif args == 'toggle':
        weechat.command("", "/bar toggle urlbar")
    elif args == 'clear':
        urls = []
    elif args.startswith('load'):
        urlbar_load_url(*args.split())
    else:
        weechat.command("", "/help %s" % SCRIPT_COMMAND)

    return weechat.WEECHAT_RC_OK

def input_text_changed_cb(data, signal, signal_data):
    global multiline_input

    if multiline_input == "1":
        return weechat.WEECHAT_RC_OK

    buffer = signal_data
    if not buffer:
        return weechat.WEECHAT_RC_OK

    tab_complete, position, aspell_suggest_item = get_position_and_suggest_item(buffer)
    if not position or not aspell_suggest_item:
        return weechat.WEECHAT_RC_OK

    # 1 = cursor etc., 2 = TAB
    if tab_complete != "0":
        if not aspell_suggest_item:
            aspell_suggest_item = ""
        weechat.buffer_set(
            buffer, "localvar_set_spell_correction_suggest_item", "%s:%s:%s" % ("0", position, aspell_suggest_item)
        )
        weechat.bar_item_update("spell_correction")
        return weechat.WEECHAT_RC_OK

    if OPTIONS["auto_replace"].lower() == "on":
        replace_misspelled_word(buffer)  # also remove localvar_suggest_item
        return weechat.WEECHAT_RC_OK

    #    weechat.buffer_set(buffer, 'localvar_set_spell_correction_suggest_item', '%s:%s:' % ('0','-1'))
    weechat.bar_item_update("spell_correction")
    return weechat.WEECHAT_RC_OK

def urlbar_print_cb(data, buffer, time, tags, displayed, highlight, prefix, message):


    buffer_name = get_buffer_name(buffer, long=True)
    # Skip ignored buffers
    for ignored_buffer in weechat.config_get_plugin('ignore').split(','):
        if ignored_buffer.lower() == buffer_name.lower():
            return weechat.WEECHAT_RC_OK

    # Clean list of URLs
    for i in range(len(urls) - int(weechat.config_get_plugin('remember_amount'))):
        # Delete the oldest
        urls.pop(0)

    for url in urlRe.findall(message):
        urlobject = URL(url, get_buffer_name(buffer), time, prefix)
        # Do not add duplicate URLs
        if urlobject in urls:
            continue
        urls.append(urlobject)
        if weechat.config_get_plugin('use_popup') == 'on':
            # Check if URL is in current buffer
            if weechat.config_get_plugin('display_current_only') == 'on' and weechat.current_buffer() == buffer:
                popup()
            if weechat.config_get_plugin('display_current_only') != 'on':
                popup()

        weechat.bar_item_update("urlbar_urls")

    return weechat.WEECHAT_RC_OK

def responsive_cb(data, signal, signal_data):
    term_height = int(weechat.info_get("term_height", ""))
    term_width = int(weechat.info_get("term_width", ""))

    try:
        apply_layout = None
        for layout, width, height in LAYOUT_LIST:
            if term_height <= int(height) or term_width <= int(width):
                apply_layout = layout
                break

        if apply_layout is None:
            # Always apply the last layout if term width/height is larger than configured layouts
            apply_layout = LAYOUT_LIST[-1][0]

        if layout_exist(apply_layout) and not layout_current(apply_layout):
            _print("Applying layout %s" % apply_layout)
            weechat.command("", "/layout apply %s" % apply_layout)
            toggle_nick_list(apply_layout)

        weechat.bar_item_update("rlayout")
    except ValueError:
        _print("Height or width is not in number form, ignoring.")

    return weechat.WEECHAT_RC_OK

def timeline_prompt_cb(data, signal, signal_data):
    """Tweets from the timeline buffer, also shows how long your tweet is."""
    global buffers
    if  wc.current_buffer() != buffers['__TIMELINE']:
        return wc.WEECHAT_RC_OK
    wc.bar_item_update('tweet_counter')
    return wc.WEECHAT_RC_OK

def aspell_suggest_cb(data, signal, signal_data):
    buffer = signal_data
    if OPTIONS["auto_pop_up_item"].lower() == "on":
        auto_suggest_cmd_cb("", buffer, "")
        weechat.buffer_set(buffer, "localvar_del_spell_correction_suggest_input_line", "")
    weechat.bar_item_update("spell_suggest")
    return weechat.WEECHAT_RC_OK

def tc_bar_item_update (data=None, signal=None, signal_data=None):
    '''Updates bar item'''
    '''May be used as a callback or standalone call.'''
    global length, cursor_pos, tc_input_text

    w.bar_item_update('tc')
    return w.WEECHAT_RC_OK

def delete_localvar_replace_mode(buffer):
    if OPTIONS['replace_mode'].lower() == "on":
        weechat.buffer_set(buffer, 'localvar_del_inline_replace_mode', '')
        weechat.buffer_set(buffer, 'localvar_del_inline_suggestions', '')
        weechat.buffer_set(buffer, 'localvar_del_save_position_of_word', '')
        weechat.buffer_set(buffer, 'localvar_del_current_cursor_pos', '')
        weechat.bar_item_update('spell_suggestion')

def timer_cb(data, remaining_calls):
    """Timer callback."""
    global cmdhelp_hooks
    if cmdhelp_hooks['modifier']:
        unhook(('modifier',))
        weechat.bar_item_update('input_text')
    return weechat.WEECHAT_RC_OK

def urlbar_print_cb(data, buffer, time, tags, displayed, highlight, prefix, message):


    buffer_name = get_buffer_name(buffer, long=True)
    # Skip ignored buffers
    for ignored_buffer in weechat.config_get_plugin('ignore').split(','):
        if ignored_buffer.lower() == buffer_name.lower():
            return weechat.WEECHAT_RC_OK

    # Clean list of URLs
    for i in range(len(urls) - int(weechat.config_get_plugin('remember_amount'))):
        # Delete the oldest
        urls.pop(0)

    for url in urlRe.findall(message):
        urlobject = URL(url, get_buffer_name(buffer), time, prefix)
        # Do not add duplicate URLs
        if urlobject in urls:
            continue
        urls.append(urlobject)
        if weechat.config_get_plugin('use_popup') == 'on':
            weechat.command("", "/bar show urlbar")
            # auto hide bar after delay
            try:
                weechat.command('', '/wait %s /bar hide urlbar' %
                        int(weechat.config_get_plugin('visible_seconds')))
            except ValueError:
                weechat.prnt('', 'Invalid visible_seconds')

        weechat.bar_item_update("urlbar_urls")

    return weechat.WEECHAT_RC_OK

def command_cb(data, buf, args):
    try:
        args = shlex.split(args)
    except:
        return weechat.WEECHAT_RC_ERROR

    if len(args) == 2 and args[0] == b'enable':
        server, channel = get_buffer_info(buf)
        channel_data[u'{0}.{1}'.format(server, channel)] = WeeSodiumChannel(
            args[1])

        weechat.prnt(buf, "This conversation is now encrypted.")
        weechat.bar_item_update(SCRIPT_NAME)

        return weechat.WEECHAT_RC_OK
    elif len(args) == 1 and args[0] == b'disable':
        server, channel = get_buffer_info(buf)
        del channel_data[u'{0}.{1}'.format(server, channel)]

        weechat.prnt(buf, "This conversation is no longer encrypted.")
        weechat.bar_item_update(SCRIPT_NAME)

        return weechat.WEECHAT_RC_OK
    else:
        return weechat.WEECHAT_RC_ERROR

def message_out_cb(data, modifier, modifier_data, string):
    """Outgoing message callback."""
    result = ''

    # If any exception is raised in this function, WeeChat will send the
    # outgoing message, which could be something that the user intended to be
    # encrypted. This paranoid exception handling ensures that the system
    # fails closed and not open.
    try:
        debug(('message_out_cb', data, modifier, modifier_data, string))

        parsed = parse_irc_privmsg(utf8_decode(string))
        debug(('parsed message', parsed))

        # skip processing messages to public channels
        if parsed['to_channel']:
            return string

        server = utf8_decode(modifier_data)

        to_user = irc_user(parsed['to_nick'], server)
        local_user = current_user(server)

        context = ACCOUNTS[local_user].getContext(to_user)

        if parsed['text'].startswith(potr.proto.OTRTAG) and \
                not OTR_QUERY_RE.match(parsed['text']):
            if not has_otr_end(parsed['text']):
                debug('in OTR message')
                context.in_otr_message = True
            else:
                debug('complete OTR message')
            result = string
        elif context.in_otr_message:
            if has_otr_end(parsed['text']):
                context.in_otr_message = False
                debug('in OTR message end')
            result = string
        else:
            debug(('context send message', parsed['text'], parsed['to_nick'],
                   server))

            try:
                ret = context.sendMessage(
                    potr.context.FRAGMENT_SEND_ALL,
                    utf8_encode(parsed['text']))

                if ret:
                    debug(('sendMessage returned', ret))
                    result = utf8_encode('PRIVMSG %s :%s' % (
                            parsed['to_nick'], utf8_decode(ret)))
            except potr.context.NotEncryptedError, err:
                if err.args[0] == potr.context.EXC_FINISHED:
                    context.print_buffer(
                        """Your message was not sent. End your private conversation:\n/otr finish %s %s""" % (
                            parsed['to_nick'], server))
                else:
                    raise

        weechat.bar_item_update(SCRIPT_NAME)

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 slack_websocket_cb(data, fd):
    server = data
    try:
        data = servers.find(server).ws.recv()
        message_json = json.loads(data)
        #this magic attaches json that helps find the right dest
        message_json['myserver'] = server
    except:
        return w.WEECHAT_RC_OK
    #dispatch here
    if message_json.has_key("type"):
        function_name = message_json["type"]
    else:
        function_name = "unknown"
    try:
        proc[function_name](message_json)
        dbg(function_name)
    except KeyError:
        pass
        if function_name:
            dbg("Function not implemented: %s\n%s" % (function_name, message_json))
        else:
            dbg("Function not implemented\n%s" % (message_json))
    w.bar_item_update("slack_typing_notice")
    return w.WEECHAT_RC_OK

def input_move_cb(data, signal, signal_data):
    buffer = signal

    if OPTIONS['replace_mode'].lower() == "on" and weechat.buffer_get_string(buffer,'localvar_inline_replace_mode') == "1":
        delete_localvar_replace_mode(buffer)
        weechat.buffer_set(buffer, 'localvar_del_spell_correction_suggest_item', '')
#        tab_complete,position,aspell_suggest_items = weechat.buffer_get_string(buffer,'localvar_inline_suggestions').split(':',2)
#        weechat.buffer_set(buffer, 'localvar_set_inline_suggestions', '%s:%s:%s' % ('1',position,aspell_suggest_items))
        return weechat.WEECHAT_RC_OK

    tab_complete,position,aspell_suggest_item = get_position_and_suggest_item(buffer)

    localvar_aspell_suggest = get_localvar_aspell_suggest(buffer)
    if not localvar_aspell_suggest:
        return weechat.WEECHAT_RC_OK

    misspelled_word,aspell_suggestions = localvar_aspell_suggest.split(':')

    if not aspell_suggest_item in aspell_suggestions:
        aspell_suggestion_list = aspell_suggestions.split(',',1)
        weechat.buffer_set(buffer, 'localvar_set_spell_correction_suggest_item', '%s:%s:%s' % ('1',0,aspell_suggestion_list[0]))
        weechat.bar_item_update('spell_correction')
        return weechat.WEECHAT_RC_OK

    weechat.buffer_set(buffer, 'localvar_set_spell_correction_suggest_item', '%s:%s:%s' % ('1',position,aspell_suggest_item))

    return weechat.WEECHAT_RC_OK

def buffer_switch_cb(data, signal, signal_data):
    """Callback for buffer switched.

    Used for updating the status bar item when it is in a root bar.
    """
    weechat.bar_item_update(SCRIPT_NAME)

    return weechat.WEECHAT_RC_OK

def updateTimer(data, cals):
    # Write out time spent online to file, first the last reset time and then the number of seconds spent connected
    counter_file = open(filename, 'w')
    counter_file.writelines([last_reset_ctime, str(write_value), '\n'])
    counter_file.close()
    # Update weechat bar
    weechat.bar_item_update('irctimer')
    return weechat.WEECHAT_RC_OK

def filtered_update_cb(data, signal, signal_data):
    global filter_status
    if signal == "filters_disabled":
        filter_status = 0
    if signal == "filters_enabled":
        filter_status = 1
    weechat.bar_item_update(SCRIPT_NAME)
    return weechat.WEECHAT_RC_OK

def gweather_data_cb(data, command, rc, stdout, stderr):
    '''
    Callback for the data fetching process.
    '''
    global last_city, last_lang, last_run, last_format
    global gweather_hook_process, gweather_stdout, gweather_output

    if rc == weechat.WEECHAT_HOOK_PROCESS_ERROR or stderr != '':
        weechat.prnt('', '%sgweather: Weather information fetching failed: %s' % (\
            weechat.prefix("error"), stderr))
        return weechat.WEECHAT_RC_ERROR

    if stdout:
        gweather_stdout += stdout

    if int(rc) < 0:
        # Process not ready
        return weechat.WEECHAT_RC_OK

    # Update status variables for succesful run
    last_run = time()
    last_city = weechat.config_get_plugin('city')
    last_lang = weechat.config_get_plugin('language')
    last_format = weechat.config_get_plugin('format')
    gweather_hook_process = ''

    if not gweather_stdout:
        return weechat.WEECHAT_RC_OK

    try:
        # The first row should contain "content-type" from HTTP header
        content_type, xml_response = gweather_stdout.split('\n', 1)
    except:
        # Failed to split received data in two at carridge return
        weechat.prnt('', '%sgweather: Invalid data received' % (weechat.prefix("error")))
        gweather_stdout = ''
        return weechat.WEECHAT_RC_ERROR

    gweather_stdout = ''

    # Determine the used character set in the response
    try:
        charset = content_type.split('charset=')[1]
    except:
        charset = 'utf-8'

    if charset.lower() != 'utf-8':
        xml_response = xml_response.decode(charset).encode('utf-8')

    # Feed the respose to parser and parsed data to formatting
    weather_data = parse_google_weather(xml_response)
    gweather_output = format_weather(weather_data)

    # Request bar item to update to the latest "gweather_output" 
    weechat.bar_item_update('gweather')

    return weechat.WEECHAT_RC_OK