" Function for getting the verbose mode level
function! s:GetVerboseMode(...)
    let verbose = &verbose
    if exists("g:autoformat_verbosemode ")
      if g:autoformat_verbosemode > verbose
        let verbose = g:autoformat_verbosemode
      endif
    endif
    return verbose
endfunction

" Function for finding the formatters for this filetype
" Result is stored in b:formatters
function! s:FindFormatters(...)
    " Detect verbosity
    let verbose = s:GetVerboseMode()

    " Extract filetype to be used
    let ftype = a:0 ? a:1 : &filetype
    " Support composite filetypes by replacing dots with underscores
    let compoundtype = substitute(ftype, "[.]", "_", "g")
    if ftype =~? "[.]"
        " Try all super filetypes in search for formatters in a sane order
        let ftypes = [compoundtype] + split(ftype, "[.]")
    else
        let ftypes = [compoundtype]
    endif

    " Support multiple formatters per file type
    let run_all_formatters_var = "g:run_all_formatters_".compoundtype
    if exists(run_all_formatters_var)
        let b:run_all_formatters = eval(run_all_formatters_var)
    else
        let b:run_all_formatters = 0
    endif

    " Warn for backward incompatible configuration
    let old_formatprg_var = "g:formatprg_".compoundtype
    let old_formatprg_args_var = "g:formatprg_args_".compoundtype
    let old_formatprg_args_expr_var = "g:formatprg_args_expr_".compoundtype
    if exists(old_formatprg_var) || exists(old_formatprg_args_var) || exists(old_formatprg_args_expr_var)
        echohl WarningMsg |
          \ echomsg "WARNING: the options g:formatprg_<filetype>, g:formatprg_args_<filetype> and g:formatprg_args_expr_<filetype> are no longer supported as of June 2015, due to major backward-incompatible improvements. Please check the README for help on how to configure your formatters." |
          \ echohl None
    endif

    " Detect configuration for all possible ftypes
    let b:formatters = []
    for supertype in ftypes
        let formatters_var = "b:formatters_".supertype
        if !exists(formatters_var)
            let formatters_var = "g:formatters_".supertype
        endif
        if !exists(formatters_var)
            " No formatters defined
            if verbose > 0
                echoerr "No formatters defined for supertype ".supertype
            endif
        else
            let formatters = eval(formatters_var)
            if type(formatters) != type([])
                echoerr formatters_var." is not a list"
            else
                let b:formatters = b:formatters + formatters
            endif
        endif
    endfor

    if len(b:formatters) == 0
        " No formatters defined
        if verbose > 0
            echoerr "No formatters defined for filetype '".ftype."'."
        endif
        return 0
    endif
    return 1
endfunction


" Try all formatters, starting with the currently selected one, until one
" works. If none works, autoindent the buffer.
function! s:TryAllFormatters(...) range
    " Detect verbosity
    let verbose = s:GetVerboseMode()

    " Make sure formatters are defined and detected
    if !call('<SID>FindFormatters', a:000)
        " No formatters defined
        if verbose > 0
            echomsg "No format definitions are defined for this filetype."
        endif
        call s:Fallback()
        return 0
    endif

    " Make sure index exist and is valid
    if !exists('b:current_formatter_index')
        let b:current_formatter_index = 0
    endif
    if b:current_formatter_index >= len(b:formatters)
        let b:current_formatter_index = 0
    endif

    " Try all formatters, starting with selected one
    let s:index = b:current_formatter_index

    " Save if at least one formatter was successful
    let l:formatter_run_successfully = 0

    while 1
        " Formatter definition must be existent
        let formatdef_var = 'b:formatdef_'.b:formatters[s:index]
        if !exists(formatdef_var)
            let formatdef_var = 'g:formatdef_'.b:formatters[s:index]
        endif
        if !exists(formatdef_var)
            echoerr "No format definition found in '".formatdef_var."'."
            return 0
        endif

        " Eval twice, once for getting definition content,
        " once for getting the final expression
        let b:formatprg = eval(eval(formatdef_var))

        if verbose > 1
            echomsg "Trying definition from ".formatdef_var
            echomsg "Evaluated formatprg: ".b:formatprg
        endif

        " Detect if +python or +python3 is available, and call the corresponding function
        if !has("python") && !has("python3")
            echohl WarningMsg |
                \ echomsg "WARNING: vim has no support for python, but it is required to run the formatter!" |
                \ echohl None
            return 1
        endif
        if has("python3")
            if verbose > 1
                echomsg "Using python 3 code..."
            endif
            let success = s:TryFormatterPython3()
        else
            if verbose > 1
                echomsg "Using python 2 code..."
            endif
            let success = s:TryFormatterPython()
        endif

        let s:index = (s:index + 1) % len(b:formatters)

        if success == 0
            if verbose > 1
                echomsg "Definition in '".formatdef_var."' was successful."
            endif
            " Check if we can run few formatters in row
            if b:run_all_formatters == 1
                let l:formatter_run_successfully += 1
                if s:index != b:current_formatter_index
                    if verbose > 1
                        echomsg "Running next chained formatter."
                    endif
                endif
            else
                return 1
            endif
        else
            if verbose > 0
                echomsg "Definition in '".formatdef_var."' was unsuccessful."
            endif
        endif

        if s:index == b:current_formatter_index
            if b:run_all_formatters == 1 && l:formatter_run_successfully >= 1
                if verbose > 1
                    echomsg l:formatter_run_successfully." formatters were successfuly run."
                endif
                return 1
            else
                if verbose > 0
                    echomsg "No format definitions were successful."
                endif
                " Tried all formatters, none worked
                call s:Fallback()
                return 0
            endif
        endif
    endwhile
endfunction

function! s:Fallback()
    " Detect verbosity
    let verbose = s:GetVerboseMode()

    if exists('b:autoformat_remove_trailing_spaces') ? b:autoformat_remove_trailing_spaces == 1 : g:autoformat_remove_trailing_spaces == 1
        if verbose > 1
            echomsg "Removing trailing whitespace..."
        endif
        call s:RemoveTrailingSpaces()
    endif

    if exists('b:autoformat_retab') ? b:autoformat_retab == 1 : g:autoformat_retab == 1
        if verbose > 1
            echomsg "Retabbing..."
        endif
        retab
    endif

    if exists('b:autoformat_autoindent') ? b:autoformat_autoindent == 1 : g:autoformat_autoindent == 1
        if verbose > 1
            echomsg "Autoindenting..."
        endif
        " Autoindent code
        exe "normal! gg=G"
    endif

endfunction


" Call formatter
" If stderr is empty, apply result, return 0
" Otherwise, return 1

" +python version
function! s:TryFormatterPython()
    " Detect verbosity
    let verbose = s:GetVerboseMode()

python << EOF
import vim, subprocess, os
from subprocess import Popen, PIPE
text = os.linesep.join(vim.current.buffer[:]) + os.linesep
formatprg = vim.eval('b:formatprg')
verbose = bool(int(vim.eval('verbose')))

env = os.environ.copy()
if int(vim.eval('exists("g:formatterpath")')):
    extra_path = vim.eval('g:formatterpath')
    env['PATH'] = os.pathsep.join(extra_path) + os.pathsep + env['PATH']

# When an entry is unicode, Popen can't deal with it in Python 2.
# As a pragmatic fix, we'll omit that entry.
newenv = {}
for key,val in env.iteritems():
    if type(key) == type(val) == str:
        newenv[key] = val
env=newenv
p = subprocess.Popen(formatprg, env=env, shell=True, stdin=PIPE, stdout=PIPE, stderr=PIPE)
stdoutdata, stderrdata = p.communicate(text)

formattername = vim.eval('b:formatters[s:index]')
if stderrdata:
    if verbose > 0:
        print('Formatter {} stderr: {}'.format(formattername, stderrdata))
if p.returncode > 0:
    if verbose > 0:
        print('Formatter {} gives nonzero returncode: {}'.format(formattername, p.returncode))
    vim.command('return 1')
else:
    # It is not certain what kind of line endings are being used by the format program.
    # Therefore we simply split on all possible eol characters.
    possible_eols = ['\r\n', os.linesep, '\r', '\n']

    # Often shell commands will append a newline at the end of their output.
    # It is not entirely clear when and why that happens.
    # However, extra newlines are almost never required, while there are linters that complain
    # about superfluous newlines, so we remove one empty newline at the end of the file.
    for eol in possible_eols:
        eol_len = len(eol)
        if len(stdoutdata) > 0 and stdoutdata[-eol_len:] == eol:
            stdoutdata = stdoutdata[:-eol_len]

    lines = [stdoutdata]
    for eol in possible_eols:
        lines = [splitline for line in lines for splitline in line.split(eol)]

    if vim.current.buffer[:] != lines:
        vim.current.buffer[:] = lines
EOF

    return 0
endfunction

" +python3 version
function! s:TryFormatterPython3()
    " Detect verbosity
    let verbose = s:GetVerboseMode()

python3 << EOF
import vim, subprocess, os
from subprocess import Popen, PIPE

# The return code is `failure`, unless otherwise specified
vim.command('return 1')

text = bytes(os.linesep.join(vim.current.buffer[:]) + os.linesep, 'utf-8')
formatprg = vim.eval('b:formatprg')
verbose = bool(int(vim.eval('verbose')))
env = os.environ.copy()
if int(vim.eval('exists("g:formatterpath")')):
    extra_path = vim.eval('g:formatterpath')
    env['PATH'] = os.pathsep.join(extra_path) + os.pathsep + env['PATH']

try:
    p = subprocess.Popen(formatprg, env=env, shell=True, stdin=PIPE, stdout=PIPE, stderr=PIPE)
    stdoutdata, stderrdata = p.communicate(text)
except (BrokenPipeError, IOError):
    if verbose > 0:
        raise
else:
    formattername = vim.eval('b:formatters[s:index]')
    if stderrdata:
        if verbose > 0:
            print('Formatter {} stderr: {}'.format(formattername, stderrdata))
    if p.returncode > 0:
        if verbose > 0:
            print('Formatter {} gives nonzero returncode: {}'.format(formattername, p.returncode))
    elif not stdoutdata:
        if verbose > 0:
            print('Formatter {} gives empty result: {}'.format(formattername, stderrdata))
    else:
        # It is not certain what kind of line endings are being used by the format program.
        # Therefore we simply split on all possible eol characters.
        possible_eols = ['\r\n', os.linesep, '\r', '\n']

        stdoutdata = stdoutdata.decode('utf-8')

        # Often shell commands will append a newline at the end of their output.
        # It is not entirely clear when and why that happens.
        # However, extra newlines are almost never required, while there are linters that complain
        # about superfluous newlines, so we remove one empty newline at the end of the file.
        for eol in possible_eols:
            eol_len = len(eol)
            if len(stdoutdata) > 0 and stdoutdata[-eol_len:] == eol:
                stdoutdata = stdoutdata[:-eol_len]

        lines = [stdoutdata]
        for eol in possible_eols:
            lines = [splitline for line in lines for splitline in line.split(eol)]

        if vim.current.buffer[:] != lines:
            vim.current.buffer[:] = lines
        vim.command('return 0')
EOF
endfunction


" Create a command for formatting the entire buffer
" Save and recall window state to prevent vim from jumping to line 1
" Write and read viminfo to restore marks
command! -nargs=? -range=% -complete=filetype -bar
    \ Autoformat let winview=winsaveview()|wviminfo|<line1>,<line2>call s:TryAllFormatters(<f-args>)|call winrestview(winview)|rviminfo

" Create a command for formatting a single line, or range of lines
" Save and recall window state to prevent vim from jumping to line 1
" Write and read viminfo to restore marks
command! -nargs=? -range -complete=filetype -bar
    \ AutoformatLine let winview=winsaveview()|wviminfo|<line1>,<line2>call s:TryAllFormatters(<f-args>)|call winrestview(winview)|rviminfo


" Functions for iterating through list of available formatters
function! s:NextFormatter()
    call s:FindFormatters()
    if !exists('b:current_formatter_index')
        let b:current_formatter_index = 0
    endif
    let b:current_formatter_index = (b:current_formatter_index + 1) % len(b:formatters)
    echomsg 'Selected formatter: '.b:formatters[b:current_formatter_index]
endfunction

function! s:PreviousFormatter()
    call s:FindFormatters()
    if !exists('b:current_formatter_index')
        let b:current_formatter_index = 0
    endif
    let l = len(b:formatters)
    let b:current_formatter_index = (b:current_formatter_index - 1 + l) % l
    echomsg 'Selected formatter: '.b:formatters[b:current_formatter_index]
endfunction

function! s:CurrentFormatter()
    call s:FindFormatters()
    if !exists('b:current_formatter_index')
        let b:current_formatter_index = 0
    endif
    echomsg 'Selected formatter: '.b:formatters[b:current_formatter_index]
endfunction

" Create commands for iterating through formatter list
command! NextFormatter call s:NextFormatter()
command! PreviousFormatter call s:PreviousFormatter()
command! CurrentFormatter call s:CurrentFormatter()

" Other commands
function! s:RemoveTrailingSpaces()
    let user_gdefault = &gdefault
    try
        set nogdefault
        silent! %s/\s\+$
    finally
        let &gdefault = user_gdefault
    endtry
endfunction
command! RemoveTrailingSpaces call s:RemoveTrailingSpaces()