# shellcheck shell=bash

_get_subprojects_dir() {
  # TODO: meson-info/intro-projectinfo.json has the info for the subproject
  # directory, but we can't know what the build directory is in these contexts.
  # Let's default to subprojects.

  # Get subprojects directory. All subprojects subcommands support --sourcedir,
  # so if that argument was passed, use it to find subprojects.
  subprojects_dir="subprojects"
  for (( i=${#COMP_WORDS[@]} - 1; i >= 0; i-- )); do
    # Exit early if we have made our way back to the command
    if [[ "${COMP_WORDS[$i]}" = "subprojects" ]]; then
      break
    fi

    prev=$((i - 1))
    if [[ $prev -gt 0 ]] && [[ "${COMP_WORDS[$prev]}" = "--sourcedir" ]]; then
      subprojects_dir="${COMP_WORDS[$i]}"
      break
    fi
  done

  echo "$subprojects_dir"
}

_subprojects() {
  subprojects_dir=$(_get_subprojects_dir)
  pushd "$subprojects_dir" &>/dev/null || return
    local COMPREPLY=()
    _filedir
    # _filedir for whatever reason can't reason about symlinks, so -d will them.
    # Filter out wrap files with this expression.
    IFS=$'\n' echo "${COMPREPLY[*]}" | grep -vE '\.wrap$' | xargs
  popd &>/dev/null
}

_wraps() {
  subprojects_dir=$(_get_subprojects_dir)
  db="$subprojects_dir/wrapdb.json"
  if [[ ! -f "$db" ]]; then
    return
  fi

  document=$(cat "$db")
  wraps=($(python3 -c 'import sys, json
for wrap in json.load(sys.stdin).keys():
  print(wrap)
' <<< "$document"))
  echo "${wraps[@]}"
}

_meson() {
  command="${COMP_WORDS[1]}"
  subcommands=(
      setup
      configure
      dist
      install
      introspect
      init
      test
      wrap
      subprojects
      help
      rewrite
      compile
      devenv
      env2mfile
  )

  if [[ " ${subcommands[*]} " =~ " ${command} " ]]; then
      "_meson-$command" "${COMP_WORDS[@]:1}"
  else
      _meson-setup "${COMP_WORDS[@]}"
  fi
} &&
complete -F _meson meson

_meson_complete_option() {
  option_string=$1

  if [[ $# -eq 2 ]] && ! [[ "$option_string" == *=* ]]; then
    option_string="$option_string=$2"
  fi

  if [[ "$option_string" == *=* ]]; then
    _meson_complete_option_value "$option_string"
  else
    _meson_complete_option_name "$option_string"
  fi
}

_meson_complete_option_name() {
  option=$1
  options=($(python3 -c 'import sys, json
for option in json.load(sys.stdin):
  print(option["name"])
' <<< "$(_meson_get_options)"))
  compopt -o nospace
  COMPREPLY=($(compgen -W '${options[@]}' -S= -- "$option"))
}

_meson_complete_option_value() {
  cur=$1
  option_name=${cur%%=*}
  option_value=${cur#*=}

  if _meson_complete_filedir "$option_name" "$option_value"; then
    return
  fi

  options=($(python3 -c 'import sys, json
for option in json.load(sys.stdin):
  if option["name"] != "'$option_name'":
    continue
  choices = []
  if option["type"] == "boolean":
    choices.append("true")
    choices.append("false")
  elif option["type"] == "combo":
    for choice in option["choices"]:
      choices.append(choice)
  elif option["type"] == "feature":
    choices.append("auto")
    choices.append("enabled")
    choices.append("disabled")
  for choice in choices:
    if choice.startswith("'$cur'"):
      print(choice)
' <<< "$(_meson_get_options)"))
  COMPREPLY=("${options[@]}")
}

_meson_get_options() {
  local options
  for builddir in "${COMP_WORDS[@]}"; do
    if [[ -d "$builddir" ]]; then
      break
    fi
    builddir=.
  done
  options=$(meson introspect "$builddir" --buildoptions 2>/dev/null) &&
  echo "$options" ||
  echo '[]'
}

_meson_complete_filedir() {
  _filedir_in() {
    pushd "$1" &>/dev/null
      local COMPREPLY=()
      _filedir
      echo "${COMPREPLY[@]}"
    popd &>/dev/null
  }

  option=$1
  cur=$2
  case $option in
    prefix |\
    bindir |\
    datadir |\
    includedir |\
    infodir |\
    libdir |\
    licensedir |\
    libexecdir |\
    localedir |\
    localstatedir |\
    mandir |\
    sbindir |\
    sharedstatedir |\
    sysconfdir |\
    python.platlibdir |\
    python.purelibdir |\
    pkg-config-path |\
    build.pkg-config-path |\
    cmake-prefix-path |\
    build.cmake-prefix-path)
      _filedir -d
      ;;

    cross-file)
      _filedir
      COMPREPLY+=($(_filedir_in "$XDG_DATA_DIRS"/meson/cross))
      COMPREPLY+=($(_filedir_in /usr/local/share/meson/cross))
      COMPREPLY+=($(_filedir_in /usr/share/meson/cross))
      COMPREPLY+=($(_filedir_in "$XDG_DATA_HOME"/meson/cross))
      COMPREPLY+=($(_filedir_in ~/.local/share/meson/cross))
      ;;

    native-file)
      _filedir
      COMPREPLY+=($(_filedir_in "$XDG_DATA_DIRS"/meson/native))
      COMPREPLY+=($(_filedir_in /usr/local/share/meson/native))
      COMPREPLY+=($(_filedir_in /usr/share/meson/native))
      COMPREPLY+=($(_filedir_in "$XDG_DATA_HOME"/meson/native))
      COMPREPLY+=($(_filedir_in ~/.local/share/meson/native))
      ;;

    *)
      return 1;;
  esac
  return 0
}

_meson_compgen_options() {
  local -r cur=$1

  if [[ ${cur:0:2} == -- ]]; then
    COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}' -- "${cur:2}"))
  elif [[ ${cur:0:1} == - ]]; then
    if [[ ${#cur} == 1 ]]; then
      # Only add longopts if cur not "-something"
      COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}' -- ""))
    fi

    COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}' -- "${cur:1}"))
  else
    return 1
  fi

  return 0
}

_meson_common_setup_configure_longopts=(
  help
  prefix
  bindir
  datadir
  includedir
  infodir
  libdir
  licensedir
  libexecdir
  localedir
  localstatedir
  mandir
  sbindir
  sharedstatedir
  sysconfdir
  auto-features
  backend
  genvslite
  buildtype
  debug
  default-library
  errorlogs
  install-umask
  layout
  optimization
  prefer-static
  stdsplit
  strip
  unity
  unity-size
  warnlevel
  werror
  wrap-mode
  force-fallback-for
  vsenv
  pkgconfig.relocatable
  python.bytecompile
  python.install-env
  python.platlibdir
  python.purelibdir
  python.allow-limited-api
  pkg-config-path
  build.pkg-config-path
  cmake-prefix-path
  build.cmake-prefix-path
  clearcache
)

_meson-setup() {
  shortopts=(
    h
    D
    v
  )

  longopts=(
    ${_meson_common_setup_configure_longopts[@]}
    native-file
    cross-file
    version
    fatal-meson-warnings
    reconfigure
    wipe
  )

  local cur prev
  if _get_comp_words_by_ref cur prev &>/dev/null; then
    if [[ ${prev:0:2} == -- ]] && _meson_complete_option "${prev:2}" "$cur"; then
      return
    elif [[ ${prev:0:1} == - ]] && [[ ${prev:1:2} != - ]] && _meson_complete_option "${prev:1}"; then
      return
    fi
  fi

  if _get_comp_words_by_ref -n '=' cur prev &>/dev/null; then
    if [[ $prev == -D ]]; then
      _meson_complete_option "$cur"
      return
    fi
  else
    cur="${COMP_WORDS[COMP_CWORD]}"
  fi

  if ! _meson_compgen_options "$cur"; then
    _filedir -d
    if [[ -z $cur ]]; then
      COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}'))
      COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}'))
    fi

    if [[ $COMP_CWORD == 1 ]]; then
      COMPREPLY+=($(compgen -W '${subcommands[*]}' -- "$cur"))
    fi
  fi
}

_meson-configure() {
  shortopts=(
    h
    D
  )

  longopts=(
    ${_meson_common_setup_configure_longopts[@]}
    no-pager
  )

  local cur prev
  if _get_comp_words_by_ref -n '=' cur prev &>/dev/null; then
    if [[ $prev == -D ]]; then
      _meson_complete_option "$cur"
      return
    fi
  else
    cur="${COMP_WORDS[COMP_CWORD]}"
  fi

  if ! _meson_compgen_options "$cur"; then
    for dir in "${COMP_WORDS[@]}"; do
      if [[ -d "$dir" ]]; then
        break
      fi
      dir=.
    done
    if [[ ! -d "$dir/meson-private" ]]; then
      _filedir -d
    fi

    if [[ -z $cur ]]; then
      COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}'))
      COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}'))
    fi
  fi
}

_meson-dist() {
  shortopts=(
    h
    C
    j
  )

  longopts=(
    allow-dirty
    help
    formats
    include-subprojects
    no-tests
    num-processes
  )

  local cur prev
  if _get_comp_words_by_ref -n ':' cur prev &>/dev/null; then
    case $prev in
      -C)
        _filedir -d
        return
        ;;

      -j | --num-processes)
        # number, can't be completed
        return
        ;;

      --formats)
        formats=(
          xztar
          gztar
          zip
        )

        COMPREPLY+=($(compgen -W '${formats[*]}' -- "$cur"))
        return
        ;;
    esac
  else
    cur="${COMP_WORDS[COMP_CWORD]}"
  fi

  if ! _meson_compgen_options "$cur"; then
    if [[ -z $cur ]]; then
      COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}'))
      COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}'))
    fi
  fi
}

_meson-install() {
  shortopts=(
    h
    n
    q
    C
  )

  longopts=(
    help
    no-rebuild
    only-changed
    quiet
    destdir
    dry-run
    skip-subprojects
    tags
    strip
  )

  local cur prev
  if _get_comp_words_by_ref -n ':' cur prev &>/dev/null; then
    for i in "${!COMP_WORDS[@]}"; do
      opt="${COMP_WORDS[i]}"
      dir="${COMP_WORDS[i+1]}"
      case "$opt" in
        -C)
          break
          ;;
      esac
      dir=.
    done

    case $prev in
      -C | --destdir)
        _filedir -d
        return
        ;;

      --tags)
        tags=$(meson introspect "$dir" --install-plan | python3 -c 'import sys, json
targets = json.load(sys.stdin)["targets"]
for target, attributes in targets.items():
  print(attributes["tag"])
' 2> /dev/null)

        if [[ $? == 0 ]]; then
          COMPREPLY+=($(compgen -W '${tags[*]}' -- "$cur"))
        fi
        return
        ;;
    esac
  else
    cur="${COMP_WORDS[COMP_CWORD]}"
  fi

  if ! _meson_compgen_options "$cur"; then
    if [[ -z $cur ]]; then
      COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}'))
      COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}'))
    fi
  fi
}

_meson-introspect() {
  shortopts=(
    h
    a
    i
    f
  )

  longopts=(
    ast
    benchmarks
    buildoptions
    buildsystem-files
    dependencies
    scan-dependencies
    installed
    install-plan
    projectinfo
    targets
    tests
    backend
    all
    indent
    force-object-output
  )

  local cur prev
  if ! _get_comp_words_by_ref cur prev &>/dev/null; then
    cur="${COMP_WORDS[COMP_CWORD]}"
  fi

  if ! _meson_compgen_options "$cur"; then
    for dir in "${COMP_WORDS[@]}"; do
      if [[ -d "$dir" ]]; then
        break
      fi
      dir=.
    done
    if [[ ! -d "$dir/meson-private" ]]; then
      _filedir -d
    fi

    if [ -z "$cur" ]; then
      COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}'))
      COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}'))
    fi
  fi
}

_meson-init() {
  shortopts=(
    h
    C
    n
    e
    d
    l
    b
    f
  )

  longopts=(
    help
    name
    executable
    deps
    language
    build
    builddir
    force
    type
    version
  )

  if ! _meson_compgen_options "$cur"; then
    if [[ -z $cur ]]; then
      COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}'))
      COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}'))
    fi
  fi
}

_meson-test() {
  shortopts=(
    h
    j
    q
    v
    t
    C
  )

  longopts=(
    help
    maxfail
    repeat
    no-rebuild
    gdb
    gdb-path
    interactive
    list
    wrapper
    suite
    no-suite
    no-stdsplit
    print-errorlogs
    benchmark
    logbase
    num-processes
    verbose
    quiet
    timeout-multiplier
    setup
    max-lines
    test-args
  )

  local cur prev
  if _get_comp_words_by_ref -n ':' cur prev &>/dev/null; then
    case $prev in
      --maxfail | --repeat)
        # number, can't be completed
        return
        ;;

      --wrapper)
        _command_offset "$COMP_CWORD"
        return
        ;;

      --gdb-path)
        _filedir
        return
        ;;

      -C)
        _filedir -d
        return
        ;;

      --suite | --no-suite)
        for i in "${!COMP_WORDS[@]}"; do
          opt="${COMP_WORDS[i]}"
          dir="${COMP_WORDS[i+1]}"
          case "$opt" in
            -C)
              break
              ;;
          esac
          dir=.
        done

        suites=$(meson introspect "$dir" --tests | python3 -c 'import sys, json;
for test in json.load(sys.stdin):
  for suite in test["suite"]:
    print(suite)
' 2> /dev/null)

        if [[ $? == 0 ]]; then
          COMPREPLY+=($(compgen -W '${suites[*]}' -- "$cur"))
          __ltrim_colon_completions "$cur"
        fi
        return
        ;;

      --logbase)
        # free string, can't be completed
        return
        ;;

      -j | --num-processes)
        # number, can't be completed
        return
        ;;

      -t | --timeout-multiplier)
        # number, can't be completed
        return
        ;;

      --setup)
        # TODO
        return
        ;;

      --test-args)
        return
        ;;
    esac
  else
    cur="${COMP_WORDS[COMP_CWORD]}"
  fi

  if ! _meson_compgen_options "$cur"; then
    for dir in "${COMP_WORDS[@]}"; do
      if [[ -d "$dir" ]]; then
        break
      fi
      dir=.
    done

    if [[ ! -d "$dir/meson-private" ]]; then
      _filedir -d
    fi

    for i in "${!COMP_WORDS[@]}"; do
      opt="${COMP_WORDS[i]}"
      dir="${COMP_WORDS[i+1]}"
      case "$opt" in
        -C)
          break
          ;;
      esac
      dir=.
    done

    tests=$(meson introspect "$dir" --tests | python3 -c 'import sys, json;
for test in json.load(sys.stdin):
  print(test["name"])
' 2> /dev/null)

    if [[ $? == 0 ]]; then
      COMPREPLY+=($(compgen -W '${tests[*]}' -- "$cur"))
    fi

    if [ -z "$cur" ]; then
      COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}' -- "${cur:2}"))
      COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}' -- "${cur:1}"))
    fi
  fi
}

_meson-wrap() {
  shortopts=(
    h
  )

  longopts=(
    help
  )

  subcommands=(
    info
    install
    list
    promote
    search
    status
    update
    update-db
  )

  for i in "$@"; do
    if [[ " ${subcommands[*]} " =~ " $i " ]]; then
      "_meson-wrap-$i" "${COMP_WORDS[i]:1}"
      return
    fi
  done

  local cur prev
  if ! _get_comp_words_by_ref cur prev &>/dev/null; then
    cur="${COMP_WORDS[COMP_CWORD]}"
  fi

  if ! _meson_compgen_options "$cur"; then
    COMPREPLY+=($(compgen -W '${subcommands[*]}' -- "$cur"))
    if [[ -z $cur ]]; then
      COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}'))
      COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}'))
    fi
  fi
}

_meson-wrap-info() {
  shortopts=(
    h
  )

  longopts=(
    allow-insecure
    help
  )

  local cur prev
  if ! _get_comp_words_by_ref cur prev &>/dev/null; then
    cur="${COMP_WORDS[COMP_CWORD]}"
  fi

  if ! _meson_compgen_options "$cur"; then
    if [[ -z $cur ]]; then
      COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}'))
      COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}'))
    fi
  fi

  read -ra wraps < <(_wraps)
  COMPREPLY+=($(compgen -W '${wraps[*]}' -- "$cur"))
}

_meson-wrap-install() {
  shortopts=(
    h
  )

  longopts=(
    allow-insecure
    help
  )

  local cur prev
  if ! _get_comp_words_by_ref cur prev &>/dev/null; then
    cur="${COMP_WORDS[COMP_CWORD]}"
  fi

  if ! _meson_compgen_options "$cur"; then
    if [[ -z $cur ]]; then
      COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}'))
      COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}'))
    fi
  fi

  read -ra wraps < <(_wraps)
  COMPREPLY+=($(compgen -W '${wraps[*]}' -- "$cur"))
}

_meson-wrap-list() {
  shortopts=(
    h
  )

  longopts=(
    allow-insecure
    help
  )

  local cur prev
  if ! _get_comp_words_by_ref cur prev &>/dev/null; then
    cur="${COMP_WORDS[COMP_CWORD]}"
  fi

  if ! _meson_compgen_options "$cur"; then
    if [[ -z $cur ]]; then
      COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}'))
      COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}'))
    fi
  fi
}

_meson-wrap-promote() {
  shortopts=(
    h
  )

  longopts=(
    help
  )

  local cur prev
  if ! _get_comp_words_by_ref cur prev &>/dev/null; then
    cur="${COMP_WORDS[COMP_CWORD]}"
  fi

  if ! _meson_compgen_options "$cur"; then
    if [[ -z $cur ]]; then
      _filedir
      COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}'))
      COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}'))
    fi
  fi
}

_meson-wrap-search() {
  shortopts=(
    h
  )

  longopts=(
    allow-insecure
    help
  )

  local cur prev
  if ! _get_comp_words_by_ref cur prev &>/dev/null; then
    cur="${COMP_WORDS[COMP_CWORD]}"
  fi

  if ! _meson_compgen_options "$cur"; then
    if [[ -z $cur ]]; then
      COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}'))
      COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}'))
    fi
  fi

  read -ra wraps < <(_wraps)
  COMPREPLY+=($(compgen -W '${wraps[*]}' -- "$cur"))
}

_meson-wrap-status() {
  shortopts=(
    h
  )

  longopts=(
    allow-insecure
    help
  )

  local cur prev
  if ! _get_comp_words_by_ref cur prev &>/dev/null; then
    cur="${COMP_WORDS[COMP_CWORD]}"
  fi

  if ! _meson_compgen_options "$cur"; then
    if [[ -z $cur ]]; then
      COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}'))
      COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}'))
    fi
  fi
}

_meson-wrap-update() {
  shortopts=(
    h
    j
  )

  longopts=(
    allow-insecure
    force
    help
    num-processes
    sourcedir
    types
  )

  local cur prev
  if _get_comp_words_by_ref cur prev &>/dev/null; then
    case $prev in
      --sourcedir)
        _filedir -d
        return
        ;;

      --types)
        types=(
          file
          git
          hg
          svn
        )

        COMPREPLY+=($(compgen -W '${types[*]}' -- "$cur"))
        return
        ;;

      -j | --num-processes)
        # number, can't be completed
        return
        ;;
    esac
  else
    cur="${COMP_WORDS[COMP_CWORD]}"
  fi

  if ! _meson_compgen_options "$cur"; then
    if [[ -z $cur ]]; then
      COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}'))
      COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}'))
    fi
  fi

  COMPREPLY+=($(_subprojects))
}

_meson-wrap-update-db() {
  shortopts=(
    h
  )

  longopts=(
    allow-insecure
    help
  )

  local cur prev
  if ! _get_comp_words_by_ref cur prev &>/dev/null; then
    cur="${COMP_WORDS[COMP_CWORD]}"
  fi

  if ! _meson_compgen_options "$cur"; then
    if [[ -z $cur ]]; then
      COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}'))
      COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}'))
    fi
  fi
}

_meson-subprojects() {
  shortopts=(
    h
  )

  longopts=(
    help
  )

  subcommands=(
    checkout
    download
    foreach
    packagefiles
    purge
    update
  )

  for i in "$@"; do
    if [[ " ${subcommands[*]} " =~ " $i " ]]; then
      "_meson-subprojects-$i" "${COMP_WORDS[i]:1}"
      return
    fi
  done

  local cur prev
  if ! _get_comp_words_by_ref cur prev &>/dev/null; then
    cur="${COMP_WORDS[COMP_CWORD]}"
  fi

  if ! _meson_compgen_options "$cur"; then
    COMPREPLY+=($(compgen -W '${subcommands[*]}' -- "$cur"))
    if [[ -z $cur ]]; then
      COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}'))
      COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}'))
    fi
  fi
}

_meson-subprojects-checkout() {
  shortopts=(
    b
    h
    j
  )

  longopts=(
    allow-insecure
    help
    num-processes
    sourcedir
    types
  )

  local cur prev
  if _get_comp_words_by_ref cur prev &>/dev/null; then
    case $prev in
      --sourcedir)
        _filedir -d
        return
        ;;

      --types)
        types=(
          file
          git
          hg
          svn
        )

        COMPREPLY+=($(compgen -W '${types[*]}' -- "$cur"))
        return
        ;;

      -j | --num-processes)
        # number, can't be completed
        return
        ;;
    esac
  else
    cur="${COMP_WORDS[COMP_CWORD]}"
  fi

  if ! _meson_compgen_options "$cur"; then
    if [[ -z $cur ]]; then
      COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}'))
      COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}'))
    fi
  fi

  COMPREPLY+=($(_subprojects))
}

_meson-subprojects-download() {
  shortopts=(
    h
    j
  )

  longopts=(
    allow-insecure
    help
    num-processes
    sourcedir
    types
  )

  local cur prev
  if _get_comp_words_by_ref cur prev &>/dev/null; then
    case $prev in
      --sourcedir)
        _filedir -d
        return
        ;;

      --types)
        types=(
          file
          git
          hg
          svn
        )

        COMPREPLY+=($(compgen -W '${types[*]}' -- "$cur"))
        return
        ;;

      -j | --num-processes)
        # number, can't be completed
        return
        ;;
    esac
  else
    cur="${COMP_WORDS[COMP_CWORD]}"
  fi

  if ! _meson_compgen_options "$cur"; then
    if [[ -z $cur ]]; then
      COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}'))
      COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}'))
    fi
  fi

  COMPREPLY+=($(_subprojects))
}

_meson-subprojects-foreach() {
  shortopts=(
    h
    j
  )

  longopts=(
    allow-insecure
    help
    num-processes
    sourcedir
    types
  )

  local cur prev
  if _get_comp_words_by_ref cur prev &>/dev/null; then
    case $prev in
      --sourcedir)
        _filedir -d
        return
        ;;

      --types)
        types=(
          file
          git
          hg
          svn
        )

        COMPREPLY+=($(compgen -W '${types[*]}' -- "$cur"))
        return
        ;;

      -j | --num-processes)
        # number, can't be completed
        return
        ;;
    esac
  else
    cur="${COMP_WORDS[COMP_CWORD]}"
  fi

  if ! _meson_compgen_options "$cur"; then
    if [[ -z $cur ]]; then
      COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}'))
      COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}'))
    fi
  fi

  COMPREPLY+=($(_subprojects))
}

_meson-subprojects-packagefiles() {
  shortopts=(
    h
    j
  )

  longopts=(
    allow-insecure
    apply
    help
    num-processes
    save
    sourcedir
    types
  )

  local cur prev
  if _get_comp_words_by_ref cur prev &>/dev/null; then
    case $prev in
      --sourcedir)
        _filedir -d
        return
        ;;

      --types)
        types=(
          file
          git
          hg
          svn
        )

        COMPREPLY+=($(compgen -W '${types[*]}' -- "$cur"))
        return
        ;;

      -j | --num-processes)
        # number, can't be completed
        return
        ;;

      --apply | --save)
        return
        ;;
    esac
  else
    cur="${COMP_WORDS[COMP_CWORD]}"
  fi

  if ! _meson_compgen_options "$cur"; then
    if [[ -z $cur ]]; then
      COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}'))
      COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}'))
    fi
  fi

  COMPREPLY+=($(_subprojects))
}

_meson-subprojects-purge() {
  shortopts=(
    h
    j
  )

  longopts=(
    allow-insecure
    confirm
    help
    include-cache
    num-processes
    sourcedir
    types
  )

  local cur prev
  if _get_comp_words_by_ref cur prev &>/dev/null; then
    case $prev in
      --sourcedir)
        _filedir -d
        return
        ;;

      --types)
        types=(
          file
          git
          hg
          svn
        )

        COMPREPLY+=($(compgen -W '${types[*]}' -- "$cur"))
        return
        ;;

      -j | --num-processes)
        # number, can't be completed
        return
        ;;

      --apply | --save)
        return
        ;;
    esac
  else
    cur="${COMP_WORDS[COMP_CWORD]}"
  fi

  if ! _meson_compgen_options "$cur"; then
    if [[ -z $cur ]]; then
      COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}'))
      COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}'))
    fi
  fi

  COMPREPLY+=($(_subprojects))
}

_meson-subprojects-update() {
  shortopts=(
    h
    j
  )

  longopts=(
    allow-insecure
    help
    num-processes
    rebase
    reset
    sourcedir
    types
  )

  local cur prev
  if _get_comp_words_by_ref cur prev &>/dev/null; then
    case $prev in
      --sourcedir)
        _filedir -d
        return
        ;;

      --types)
        types=(
          file
          git
          hg
          svn
        )

        COMPREPLY+=($(compgen -W '${types[*]}' -- "$cur"))
        return
        ;;

      -j | --num-processes)
        # number, can't be completed
        return
        ;;

      --rebase | --reset)
        return
        ;;
    esac
  else
    cur="${COMP_WORDS[COMP_CWORD]}"
  fi

  if ! _meson_compgen_options "$cur"; then
    if [[ -z $cur ]]; then
      COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}'))
      COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}'))
    fi
  fi

  COMPREPLY+=($(_subprojects))
}

_meson-help() {
  longopts=(
    setup
    configure
    dist
    install
    introspect
    init
    test
    wrap
    subprojects
    rewrite
    compile
    devenv
    env2mfile
  )

  local cur prev
  if _get_comp_words_by_ref cur prev &>/dev/null; then
    COMPREPLY+=($(compgen -W '${longopts[*]}' -- "$cur"))
  fi
}

_meson-rewrite() {
  : TODO
}

_meson-compile() {
  shortopts=(
    h
    C
    j
    l
    v
  )

  longopts=(
    help
    clean
    jobs
    load-average
    verbose
    ninja-args
    vs-args
    xcode-args
  )

  local cur prev
  if _get_comp_words_by_ref cur prev &>/dev/null; then
    if [[ ${prev:0:2} == -- ]] && _meson_complete_option "${prev:2}" "$cur"; then
      return
    elif [[ ${prev:0:1} == - ]] && [[ ${prev:1:2} != - ]] && _meson_complete_option "${prev:1}"; then
      return
    fi
  else
    cur="${COMP_WORDS[COMP_CWORD]}"
  fi

  if ! _meson_compgen_options "$cur"; then
    _filedir -d

    if [[ -z $cur ]]; then
      COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}'))
      COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}'))
    fi
  fi
}

_meson-devenv() {
  shortopts=(
    h
    w
  )

  longopts=(
    dump
    dump-format
    help
    workdir
  )

  local cur prev
  if _get_comp_words_by_ref -n ':' cur prev &>/dev/null; then
    case $prev in
      -C | -w | --workdir)
        _filedir -d
        return
        ;;

      --dump)
        _filedir
        return
        ;;

      --dump-format)
        dump_formats=(
          sh
          export
          vscode
        )

        COMPREPLY+=($(compgen -W '${dump_formats[*]}' -- "$cur"))
        return
        ;;
    esac
  else
    cur="${COMP_WORDS[COMP_CWORD]}"
  fi

  if ! _meson_compgen_options "$cur"; then
    if [[ -z $cur ]]; then
      COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}'))
      COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}'))
    fi
  fi
}

_meson-env2mfile() {
  shortopts=(
    h
    o
  )

  longopts=(
    cpu
    cpu-family
    cross
    debarch
    endian
    gccsuffix
    help
    kernel
    native
    subsystem
    system
  )

  local cur prev
  if _get_comp_words_by_ref -n ':' cur prev &>/dev/null; then
    case $prev in
      --endian)
        endianness=(
          big
          little
        )

        COMPREPLY+=($(compgen -W '${endianness[*]}' -- "$cur"))
        return
        ;;

      -o)
        _filedir
        return
        ;;
    esac
  else
    cur="${COMP_WORDS[COMP_CWORD]}"
  fi

  if ! _meson_compgen_options "$cur"; then
    if [[ -z $cur ]]; then
      COMPREPLY+=($(compgen -P '--' -W '${longopts[*]}'))
      COMPREPLY+=($(compgen -P '-' -W '${shortopts[*]}'))
    fi
  fi
}
