// Copyright © 2017-2018 Mikael Berthe <mikael@lilotux.net>

//

// Licensed under the MIT license.

// Please see the LICENSE file is this directory.

package cmd

import (

	"bytes"

	"io"

	"os"

	"strings"

	"github.com/spf13/cobra"

)

var completionCmd = &cobra.Command{

	Use:       "completion bash|zsh",

	Short:     "Generate shell completion",

	ValidArgs: []string{"bash", "zsh"},

	Run: func(cmd *cobra.Command, args []string) {

		if len(args) < 1 {

			errPrint("Please specify your shell")

			os.Exit(1)

		}

		switch args[0] {

		case "bash":

			if err := runCompletionBash(os.Stdout, RootCmd); err != nil {

				errPrint("Error: %s", err.Error())

				os.Exit(1)

			}

		case "zsh":

			if err := runCompletionZsh(os.Stdout, RootCmd); err != nil {

				errPrint("Error: %s", err.Error())

				os.Exit(1)

			}

		default:

			errPrint("Only bash is supported at the moment")

			os.Exit(1)

		}

	},

}

func init() {

	RootCmd.AddCommand(completionCmd)

}

func runCompletionBash(out io.Writer, c *cobra.Command) error {

	return c.GenBashCompletion(out)

}

// Many thanks to the Kubernetes project for this one!

func runCompletionZsh(out io.Writer, c *cobra.Command) error {

	const zshInitialization = `# Copyright 2016 The Kubernetes Authors.

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

#     http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

__madonctl_bash_source() {

	alias shopt=':'

	alias _expand=_bash_expand

	alias _complete=_bash_comp

	emulate -L sh

	setopt kshglob noshglob braceexpand

	source "$@"

}

__madonctl_type() {

	# -t is not supported by zsh

	if [ "$1" == "-t" ]; then

		shift

		# fake Bash 4 to disable "complete -o nospace". Instead

		# "compopt +-o nospace" is used in the code to toggle trailing

		# spaces. We don't support that, but leave trailing spaces on

		# all the time

		if [ "$1" = "__madonctl_compopt" ]; then

			echo builtin

			return 0

		fi

	fi

	type "$@"

}

__madonctl_compgen() {

	local completions w

	completions=( $(compgen "$@") ) || return $?

	# filter by given word as prefix

	while [[ "$1" = -* && "$1" != -- ]]; do

		shift

		shift

	done

	if [[ "$1" == -- ]]; then

		shift

	fi

	for w in "${completions[@]}"; do

		if [[ "${w}" = "$1"* ]]; then

			echo "${w}"

		fi

	done

}

__madonctl_compopt() {

	true # don't do anything. Not supported by bashcompinit in zsh

}

__madonctl_declare() {

	if [ "$1" == "-F" ]; then

		whence -w "$@"

	else

		builtin declare "$@"

	fi

}

__madonctl_ltrim_colon_completions()

{

	if [[ "$1" == *:* && "$COMP_WORDBREAKS" == *:* ]]; then

		# Remove colon-word prefix from COMPREPLY items

		local colon_word=${1%${1##*:}}

		local i=${#COMPREPLY[*]}

		while [[ $((--i)) -ge 0 ]]; do

			COMPREPLY[$i]=${COMPREPLY[$i]#"$colon_word"}

		done

	fi

}

__madonctl_get_comp_words_by_ref() {

	cur="${COMP_WORDS[COMP_CWORD]}"

	prev="${COMP_WORDS[${COMP_CWORD}-1]}"

	words=("${COMP_WORDS[@]}")

	cword=("${COMP_CWORD[@]}")

}

__madonctl_filedir() {

	local RET OLD_IFS w qw

	__debug "_filedir $@ cur=$cur"

	if [[ "$1" = \~* ]]; then

		# somehow does not work. Maybe, zsh does not call this at all

		eval echo "$1"

		return 0

	fi

	OLD_IFS="$IFS"

	IFS=$'\n'

	if [ "$1" = "-d" ]; then

		shift

		RET=( $(compgen -d) )

	else

		RET=( $(compgen -f) )

	fi

	IFS="$OLD_IFS"

	IFS="," __debug "RET=${RET[@]} len=${#RET[@]}"

	for w in ${RET[@]}; do

		if [[ ! "${w}" = "${cur}"* ]]; then

			continue

		fi

		if eval "[[ \"\${w}\" = *.$1 || -d \"\${w}\" ]]"; then

			qw="$(__madonctl_quote "${w}")"

			if [ -d "${w}" ]; then

				COMPREPLY+=("${qw}/")

			else

				COMPREPLY+=("${qw}")

			fi

		fi

	done

}

__madonctl_quote() {

    if [[ $1 == \'* || $1 == \"* ]]; then

        # Leave out first character

        printf %q "${1:1}"

    else

        printf %q "$1"

    fi

}

autoload -U +X bashcompinit && bashcompinit

# use word boundary patterns for BSD or GNU sed

LWORD='[[:<:]]'

RWORD='[[:>:]]'

if sed --help 2>&1 | grep -q GNU; then

	LWORD='\<'

	RWORD='\>'

fi

__madonctl_convert_bash_to_zsh() {

	sed \

	-e 's/declare -F/whence -w/' \

	-e 's/local \([a-zA-Z0-9_]*\)=/local \1; \1=/' \

	-e 's/flags+=("\(--.*\)=")/flags+=("\1"); two_word_flags+=("\1")/' \

	-e 's/must_have_one_flag+=("\(--.*\)=")/must_have_one_flag+=("\1")/' \

	-e "s/${LWORD}_filedir${RWORD}/__madonctl_filedir/g" \

	-e "s/${LWORD}_get_comp_words_by_ref${RWORD}/__madonctl_get_comp_words_by_ref/g" \

	-e "s/${LWORD}__ltrim_colon_completions${RWORD}/__madonctl_ltrim_colon_completions/g" \

	-e "s/${LWORD}compgen${RWORD}/__madonctl_compgen/g" \

	-e "s/${LWORD}compopt${RWORD}/__madonctl_compopt/g" \

	-e "s/${LWORD}declare${RWORD}/__madonctl_declare/g" \

	-e "s/\\\$(type${RWORD}/\$(__madonctl_type/g" \

	<<'BASH_COMPLETION_EOF'

`

	const zshTail = `

BASH_COMPLETION_EOF

}

__madonctl_bash_source <(__madonctl_convert_bash_to_zsh)

`

	buf := new(bytes.Buffer)

	out.Write([]byte(zshInitialization))

	err := c.GenBashCompletion(buf)

	script := strings.Replace(buf.String(), "flaghash[${flagname}]", `flaghash[workaround]`, -1)

	out.Write([]byte(script))

	out.Write([]byte(zshTail))

	return err

}