def command_main(data, buffer, args):
  args = args.split()
  curr_buffer = weechat.current_buffer()
  curr_buffer_number = weechat.buffer_get_integer(curr_buffer, "number")

  if len(args) != 1 and len(args) != 2:
    weechat.prnt("", "You need to specify 1 or 2 buffers")
    return weechat.WEECHAT_RC_ERROR

  if len(args) == 2:
    weechat.command("", "/buffer %s" % args[0])
    first_buffer = weechat.current_buffer()
    first_buffer_number = weechat.buffer_get_integer(first_buffer, "number")

    weechat.command("", "/buffer %s" % args[1])
    second_buffer = weechat.current_buffer()
    second_buffer_number = weechat.buffer_get_integer(second_buffer, "number")
  else:
    first_buffer = weechat.current_buffer()
    first_buffer_number = weechat.buffer_get_integer(first_buffer, "number")

    weechat.command("", "/buffer %s" % args[0])
    second_buffer = weechat.current_buffer()
    second_buffer_number = weechat.buffer_get_integer(second_buffer, "number")
  
  weechat.buffer_set(first_buffer, "number", str(second_buffer_number))
  weechat.buffer_set(second_buffer, "number", str(first_buffer_number))

  weechat.command("", "/buffer %s" % str(curr_buffer_number))
  
  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

    current_buffer = w.current_buffer()
    length = w.buffer_get_integer(current_buffer,'input_length')
    cursor_pos = w.buffer_get_integer(current_buffer,'input_pos') + 1
    w.bar_item_update('tc')
    return w.WEECHAT_RC_OK

def sort_buffers(udata, signal, buf):
    bufs_dict = defaultdict(set)
    for buf in buffers():
        if weechat.buffer_get_integer(buf, "active") != 0:
           bufs_dict[weechat.buffer_get_integer(buf, "number")].add(buf)

    for i, bufs in enumerate(sorted(bufs_dict.values(), key=buffer_key), 1):
        buf = next(iter(bufs))
        weechat.buffer_set(buf, "number", str(i))
    return weechat.WEECHAT_RC_OK

def replace_misspelled_word(buffer):
    input_line = weechat.buffer_get_string(buffer, 'localvar_spell_correction_suggest_input_line')
    if not input_line:
        # remove spell_correction item
        weechat.buffer_set(buffer, 'localvar_del_spell_correction_suggest_item', '')
        weechat.bar_item_update('spell_correction')
        weechat.bar_item_update('spell_suggestion')
        return
    if OPTIONS['eat_input_char'].lower() == 'off' or input_line == '':
        input_pos = weechat.buffer_get_integer(buffer,'input_pos')
        # check cursor position
        if len(input_line) < int(input_pos) or input_line[int(input_pos)-1] == ' ' or input_line == '':
            input_line = weechat.buffer_get_string(buffer, 'input')

    weechat.buffer_set(buffer, 'localvar_del_spell_correction_suggest_input_line', '')

    localvar_aspell_suggest = get_localvar_aspell_suggest(buffer)

    # localvar_aspell_suggest = word,word2/wort,wort2
    if localvar_aspell_suggest:
        misspelled_word,aspell_suggestions = localvar_aspell_suggest.split(':')
        aspell_suggestions = aspell_suggestions.replace('/',',')
        aspell_suggestion_list = aspell_suggestions.split(',')
    else:
        return

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

    position = int(position)

    input_line = input_line.replace(misspelled_word, aspell_suggestion_list[position])
    if input_line[-2:] == '  ':
        input_line = input_line.rstrip()
        input_line = input_line + ' '

    weechat.buffer_set(buffer,'input',input_line)

    # set new cursor position. check if suggestion is longer or smaller than misspelled word
    input_pos = weechat.buffer_get_integer(buffer,'input_pos') + 1
    length_misspelled_word = len(misspelled_word)
    length_suggestion_word = len(aspell_suggestion_list[position])

    if length_misspelled_word < length_suggestion_word:
        difference = length_suggestion_word - length_misspelled_word
        new_position = input_pos + difference + 1
        weechat.buffer_set(buffer,'input_pos',str(new_position))

    weechat.buffer_set(buffer, 'localvar_del_spell_correction_suggest_item', '')
    weechat.bar_item_update('spell_suggestion')
    weechat.bar_item_update('spell_correction')

def replace_misspelled_word(buffer):
    input_line = weechat.buffer_get_string(buffer, "localvar_spell_correction_suggest_input_line")
    if not input_line:
        # remove spell_correction item
        weechat.buffer_set(buffer, "localvar_del_spell_correction_suggest_item", "")
        weechat.bar_item_update("spell_correction")
        return
    if OPTIONS["eat_input_char"].lower() == "off" or input_line == "":
        input_pos = weechat.buffer_get_integer(buffer, "input_pos")
        # check cursor position
        if len(input_line) < int(input_pos) or input_line[int(input_pos) - 1] == " " or input_line == "":
            input_line = weechat.buffer_get_string(buffer, "input")

    weechat.buffer_set(buffer, "localvar_del_spell_correction_suggest_input_line", "")

    localvar_aspell_suggest = get_localvar_aspell_suggest(buffer)

    # localvar_aspell_suggest = word,word2/wort,wort2
    if localvar_aspell_suggest:
        misspelled_word, aspell_suggestions = localvar_aspell_suggest.split(":")
        aspell_suggestions = aspell_suggestions.replace("/", ",")
        aspell_suggestion_list = aspell_suggestions.split(",")
    else:
        return

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

    position = int(position)

    input_line = input_line.replace(misspelled_word, aspell_suggestion_list[position])
    if input_line[-2:] == "  ":
        input_line = input_line.rstrip()
        input_line = input_line + " "

    weechat.buffer_set(buffer, "input", input_line)
    weechat.bar_item_update("spell_correction")

    # set new cursor position. check if suggestion is longer or smaller than misspelled word
    input_pos = weechat.buffer_get_integer(buffer, "input_pos") + 1
    length_misspelled_word = len(misspelled_word)
    length_suggestion_word = len(aspell_suggestion_list[position])

    if length_misspelled_word < length_suggestion_word:
        difference = length_suggestion_word - length_misspelled_word
        new_position = input_pos + difference + 1
        weechat.buffer_set(buffer, "input_pos", str(new_position))

    weechat.buffer_set(buffer, "localvar_del_spell_correction_suggest_item", "")

def cb_process_message(data, wbuffer, date, tags, displayed, highlight, prefix, message):
    """Delegates incoming messages to appropriate handlers."""
    tags = set(tags.split(","))
    functions = globals()
    is_public_message = tags.issuperset(TAGGED_MESSAGES["public message or action"])
    buffer_name = weechat.buffer_get_string(wbuffer, "name")
    display_count = weechat.buffer_get_integer(wbuffer, "num_displayed")
    dcc_buffer_regex = re.compile(r"^irc_dcc\.", re.UNICODE)
    dcc_buffer_match = dcc_buffer_regex.match(buffer_name)
    highlighted = False
    if highlight == "1":
        highlighted = True
    # Is this buffer currently displayed, with the 'ignore_active_window' setting on and the user not away?
    if display_count > 0 and weechat.config_get_plugin("ignore_active_window") == "on" and STATE["is_away"] == False:
        return weechat.WEECHAT_RC_OK
    # Private DCC message identifies itself as public.
    if is_public_message and dcc_buffer_match:
        notify_private_message_or_action(prefix, message, highlighted, buffer_name)
        return weechat.WEECHAT_RC_OK
    # Pass identified, untagged message to its designated function.
    for key, value in UNTAGGED_MESSAGES.items():
        match = value.match(message)
        if match:
            functions[DISPATCH_TABLE[key]](match)
            return weechat.WEECHAT_RC_OK
    # Pass identified, tagged message to its designated function.
    for key, value in TAGGED_MESSAGES.items():
        if tags.issuperset(value):
            functions[DISPATCH_TABLE[key]](prefix, message, highlighted, buffer_name)
            return weechat.WEECHAT_RC_OK
    return weechat.WEECHAT_RC_OK

def force_redraw(data, modifier, modifier_data, string):
    plugin, buffer_name = re.match('([^;]+);([^;]+)', modifier_data).group(1, 2)

    if weechat.buffer_get_integer(weechat.buffer_search(plugin, buffer_name), 'num_displayed') > 0:
        weechat.command(weechat.current_buffer(), '/window refresh')

    return string

def switch_current_buffer():
    """Save current buffer and ensure that it's visible, then if the
    buffer is elegible to be hidden, we add it to the list of the buffers
    to be hidden after a delay
    """
    global CURRENT_BUFFER
    global CURRENT_BUFFER_TIMER_HOOK

    previous_buffer = CURRENT_BUFFER
    CURRENT_BUFFER = weechat.current_buffer()

    if previous_buffer == CURRENT_BUFFER:
        return

    if weechat.buffer_get_integer(CURRENT_BUFFER, "hidden") == 1:
        weechat.buffer_set(CURRENT_BUFFER, "hidden", "0")

    if weechat.config_get_plugin("keep_open") != "off":
        if CURRENT_BUFFER_TIMER_HOOK is not None:
            weechat.unhook(CURRENT_BUFFER_TIMER_HOOK)
            CURRENT_BUFFER_TIMER_HOOK = None
            maybe_hide_buffer(previous_buffer)
        else:
            keep_alive_buffer(previous_buffer)

        CURRENT_BUFFER_TIMER_HOOK = weechat.hook_timer(MINIMUM_BUFFER_LIFE, 0, 1,
            "on_current_buffer_is_still_active_timeout", "")
    else:
        maybe_hide_buffer(previous_buffer)

def at_completion(data, buffer, command):
    if not config['enable']:
        return weechat.WEECHAT_RC_OK
    
    input = weechat.buffer_get_string(buffer, 'input')
    if input[0] != '/':
        buffer_name = weechat.buffer_get_string(buffer,'name')
        plugin_name = weechat.buffer_get_string(buffer,'plugin')
        # don't nick complete in core
        if plugin_name == 'core': return weechat.WEECHAT_RC_OK
        server_name = buffer_name.split('.')[0]
        if (server_name not in config['servers'] 
           or not check_buffers(buffer_name) ):
           return weechat.WEECHAT_RC_OK
        pos = weechat.buffer_get_integer(buffer, 'input_pos')
        if pos > 0 and (pos == len(input) or input[pos] == ' '):
            n = input.rfind(' ', 0, pos)
            e = input.find(' ',n)
            at = 0
            word = input[n+1:pos]
            if e != n :
              word = word[:e]
            if word[0] == '@':
                word = word[1:]
                at = 1
            nicklist = weechat.infolist_get('nicklist', buffer, '')
            if nicklist:
                nick = walk_nicklist(nicklist,word)
                if nick != "":
                    complete = '%[email protected]%s %s' %(input[:pos-len(word)-at],nick,input[pos:])
                    weechat.buffer_set(buffer, 'input', complete)
                    weechat.buffer_set(buffer, 'input_pos', str(pos - len(word) + len(nick)+2))
                    return weechat.WEECHAT_RC_OK_EAT
    return weechat.WEECHAT_RC_OK

def hexip_completion(data, buffer, command):
    input = weechat.buffer_get_string(buffer, 'input')
#    cmd = input.partition(' ')[0].strip('/')
#    if cmd not in weechat.config_get_plugin('commands_cmpl'):
#        # don't complete then
#        return WEECHAT_RC_OK
    pos = weechat.buffer_get_integer(buffer, 'input_pos')
    #debug('%r %s %s' %(input, len(input), pos))
    if pos >= 8 and (pos == len(input) or input[pos] == ' '):
        n = input.rfind(' ', 0, pos)
        word = input[n+1:pos]
        #debug(word)
        if not word:
            return WEECHAT_RC_OK
        replace = ''
        if is_hexip(word):
            replace = hex_to_ip(word)
        elif is_ip(word):
            replace = ip_to_hex(word)
        if replace:
            n = len(word)
            weechat.buffer_set(buffer, 'input', '%s%s%s' %(input[:pos-n], replace, input[pos:]))
            weechat.buffer_set(buffer, 'input_pos', str(pos - n + len(replace)))
            return WEECHAT_RC_OK_EAT
    return WEECHAT_RC_OK

def complete_cb(data, bufferptr, command):
    """ Apply transformation to input line in specified buffer """

    if command != "/input complete_next":
        return weechat.WEECHAT_RC_OK

    line = decode(weechat.buffer_get_string(bufferptr, 'input'))
    caret_pos = weechat.buffer_get_integer(bufferptr, 'input_pos')

    match = re.search('(:\w+$)', line[:caret_pos])
    if not match:
        return weechat.WEECHAT_RC_OK

    # tw = tabbed word
    tw = match.group(0)
    tw_length = len(tw)
    tw_start = caret_pos - tw_length
    tw_end = caret_pos

    completion = ""
    for key, value in EMOJIS.iteritems():
        if key.startswith(tw):
            completion = decode(value)
            break

    if completion:
        line = line[:tw_start] + completion + line[tw_end:]
        new_caret_pos = caret_pos - tw_length + len(completion)
        weechat.buffer_set(bufferptr, 'input', encode(line))
        weechat.buffer_set(bufferptr, 'input_pos', str(new_caret_pos))

    return weechat.WEECHAT_RC_OK

def minesweeper_timer_cb(data, remaining_calls):
    """Callback for timer."""
    global minesweeper
    if minesweeper['buffer'] and weechat.buffer_get_integer(minesweeper['buffer'], 'num_displayed') > 0:
        minesweeper['time'] += 1
    minesweeper_display_status()
    return weechat.WEECHAT_RC_OK

def translate_process_cb(data, command, rc, stdout, stderr):
    """Callback reading HTML data from website."""
    global translate
    if stdout != '':
        translate['stdout'] += stdout
    if int(rc) >= 0:
        translated = translate['stdout'].split('"')[1]
        translate['input_before'][0] = weechat.buffer_get_string(weechat.current_buffer(), 'input')
        translate['input_before'][1] = weechat.buffer_get_integer(weechat.current_buffer(), 'input_pos')
        if translate['options']['word']:
            # translate last word of input
            str_input = translate['input_before'][0]
            if str_input:
                pos = str_input.rfind(' ')
                if pos < 0:
                    str_input = translated
                else:
                    str_input = '%s %s' % (str_input[0:pos], translated)
            else:
                str_input = translated
            translate['input_after'][0] = str_input
        else:
            if translate['options']['before_marker']:
                translated = '%s%s' % (translate['options']['before_marker'], translated)
            translate['input_after'][0] = translated
        # set input with translation
        translate['input_after'][1] = len(translate['input_after'][0])
        weechat.buffer_set(weechat.current_buffer(), 'input', translate['input_after'][0])
        weechat.buffer_set(weechat.current_buffer(), 'input_pos', '%d' % translate['input_after'][1])
        translate['hook_process'] = ''
    elif int(rc) == WEECHAT_HOOK_PROCESS_ERROR:
        translate['hook_process'] = ''
    return weechat.WEECHAT_RC_OK

def is_displayed(buffer):
    """Returns True if buffer is in a window and the user is active. This is for not show
    notifications of a visible buffer while the user is doing something and wouldn't need to be
    notified."""
    window = weechat.buffer_get_integer(buffer, 'num_displayed')
    if window != 0:
        return not inactive()
    return False

def help_cb(data, buffer, args):
    global help_buf
    if help_buf is None:
        help_buf = weechat.buffer_new("vimode", '', '', "help_closed_cb", '')
    buf_num = weechat.buffer_get_integer(help_buf, "number")
    weechat.command('', "/buffer %s" % buf_num)
    weechat.prnt(help_buf, help_text)
    return weechat.WEECHAT_RC_OK

def urlbuf_print_cb(data, buffer, date, tags, displayed, highlight, prefix, message):
    """ Called when a message is printed. """
    global urlbuf_buffer, urlbuf_tags

    # Exit immediately if the buffer does not exist
    if not urlbuf_buffer:
        return weechat.WEECHAT_RC_OK

    # Exit if there is not wanted tag in the message
    tagslist = tags.split(",")
    if not "notify_message" in tagslist:
        if weechat.config_get_plugin("display_private") == "on":
           if not "notify_private" in tagslist:
               return weechat.WEECHAT_RC_OK
        else:
           return weechat.WEECHAT_RC_OK

    # Exit if the message came into a buffer that is on the skip list
    buffer_number = str(weechat.buffer_get_integer(buffer, "number"))
    skips = set(weechat.config_get_plugin("skip_buffers").split(","))
    if buffer_number in skips:
        return weechat.WEECHAT_RC_OK

    if weechat.config_get_plugin("display_active_buffer") == "off":
        if buffer_number == weechat.buffer_get_integer(weechat.current_buffer(), "number"):
            return weechat.WEECHAT_RC_OK

    # Process all URLs from the message
    for url in urlRe.findall(message):
        output = ""

        if weechat.config_get_plugin("skip_duplicates") == "on":
            if is_url_listed(urlbuf_buffer, url):
                continue

        if weechat.config_get_plugin("display_buffer_number") == "on":
            output += "%s%-2d " % (weechat.color("reset"), weechat.buffer_get_integer(buffer, "number"))

        if weechat.config_get_plugin("display_nick") == "on":
            output += "%s " % (prefix)

        # Output the formatted URL into the buffer
        weechat.prnt(urlbuf_buffer, output + url)

    return weechat.WEECHAT_RC_OK

def go_start(buffer):
    """ Start go on buffer """
    global saved_input, saved_input_pos, old_input, buffers_pos
    hook_all()
    saved_input = weechat.buffer_get_string(buffer, "input")
    saved_input_pos = weechat.buffer_get_integer(buffer, "input_pos")
    weechat.buffer_set(buffer, "input", "")
    old_input = None
    buffers_pos = 0

def get_input_line(buffer, right):
    input_line = w.buffer_get_string(buffer, 'input')
    input_pos = w.buffer_get_integer(buffer, 'input_pos')
    if right == 1:
        return input_line[input_pos:]
    elif right == -1: #Left
        return input_line[:input_pos]
    else:
        return input_line

def go_start(buf):
    """Start go on buffer."""
    global saved_input, saved_input_pos, old_input, buffers_pos
    go_hook_all()
    saved_input = weechat.buffer_get_string(buf, 'input')
    saved_input_pos = weechat.buffer_get_integer(buf, 'input_pos')
    weechat.buffer_set(buf, 'input', '')
    old_input = None
    buffers_pos = 0

def command_run_cb (data, signal, signal_data):
    if tc_options['warn_command'] == '':
        return w.WEECHAT_RC_OK
    global length, cursor_pos, tc_input_text
    current_buffer = w.current_buffer()
    cursor_pos = w.buffer_get_integer(current_buffer,'input_pos') + 1
    if (cursor_pos -1) == 0:
        tc_action_cb()
    return w.WEECHAT_RC_OK