#!/bin/bash

__rvm_meta() {
  rvm_meta_author="Wayne E. Seguin"
  rvm_meta_author_email="wayneeseguin@gmail.com"
  rvm_meta_website="http://rvm.beginrescueend.com/"
  rvm_meta_version="${rvm_version}"
}

__rvm_version() { __rvm_meta ; echo "rvm ${rvm_meta_version} by ${rvm_meta_author} (${rvm_meta_author_email}) [${rvm_meta_website}]" ; }

__rvm_usage() { cat "${rvm_path:-$HOME/.rvm}/README" | ${PAGER:-less} ; }

__rvm_parse_args() {
  if [[ ! -z "$(echo "$*" | awk '/trace/')" ]] ; then echo "$*" ; fi

  while [[ $# -gt 0 ]] ; do
    rvm_token="$1" ; shift
    case "$rvm_token" in
      install|uninstall|path|info|setup|version|srcdir|list|reset|debug|reload|implode|readline|gemsync|update|iconv|openssl|ncurses|zlib|readline)
        rvm_action=$rvm_token
      ;;

      use)
        rvm_action=$rvm_token
        if [[ "ruby" = "$1" ]] ; then shift ; fi
      ;;

      inspect)
        rvm_action=$rvm_token
        rvm_ruby_args=$*
        rvm_parse_break=1
      ;;

      rm|remove)
        rvm_action="remove"
      ;;

      system|default)
        rvm_action=${rvm_action:-use}
        rvm_ruby_interpreter="$rvm_token"
        rvm_ruby_string="$rvm_token"
      ;;

      jruby|ree|macruby|rbx|rubinius|mput|shyouhei|default|all)
        rvm_ruby_interpreter="$rvm_token"
        rvm_action="${rvm_action:-use}"
        if match "$1" "^[0-9]\.[0-9]" ; then rvm_ruby_version=$1 ; shift ; fi
      ;;

      gems|gemset)
        rvm_action="gems"
        if [[ "name" = "$1" ]] || [[ "dir" = "$1" ]] || [[ "list" = "$1" ]] || [[ "empty" = "$1" ]] || [[ "delete" = "$1" ]] ; then
          eval "rvm_${1}_flag=1" ; shift
        elif [[ "dump" = "$1" ]] || [[ "$1" = "load" ]] ; then
          eval "rvm_${1}_flag=1" ; shift
        else
          rvm_use_flag=1 # Default is to use the (named) gem set.
        fi
      ;;

      gemdir)
        rvm_action=$rvm_token
        if [[ "system" = "$1" ]] ; then rvm_ruby_interpreter="system" ; shift ; fi
        if [[ "user" = "$1"  ]]   ; then rvm_ruby_interpreter="user"   ; shift ; fi
        rvm_ruby_interpreter="${rvm_ruby_interpreter:-current}"
      ;;

      --load|load|dump|clear)
        rvm_action="gems"
        eval "rvm_${rvm_token}_flag=1"
      ;;

      gemdup)
        rvm_action=$rvm_token
        if [[ -z "$1" ]] ; then
          rvm_ruby_interpreter="default"
        elif [[ "system" = "$1" ]] ; then
          rvm_ruby_interpreter=$1 ; shift
        elif [[ "user" = "$1" ]] ; then
          rvm_ruby_interpreter=$1 ; shift
        elif [[ "default" = "$1" ]] ; then
          rvm_ruby_interpreter=$1 ; shift
        else
          rvm_ruby_interpreter=$1 ; shift
          rvm_ruby_version=$2 ; shift
        fi
      ;;

      -S|-e)
        rvm_action="ruby"
        rvm_ruby_args="$rvm_token '$@'"
        rvm_parse_break=1
      ;;

      do|ruby|rake|gem|rubydo|rakedo|gemdo)
        if [[ "do" = "$rvm_action" ]] ; then rvm_action="ruby" ; fi
        rvm_action=$(echo $rvm_token | sed 's#do##g')
        if [[ "rake" = "$rvm_action" ]] || [[ "gem" = "$rvm_action" ]] || [[ "ruby" = "$rvm_action" ]] ; then
          if [[ -z "$1" ]] ; then
            if [[ "gem" = "$rvm_action" ]] || [[ "ruby" = "$rvm_action" ]] ; then
              rvm_action="error"
              rvm_error_message="the '$rvm_action' actions must be followed by arguments."
            fi
          elif [[ "-S" = "$1" ]] || [[ "-e" = "$1" ]] ; then
            rvm_action="ruby"
            flag="$1" ; shift
            rvm_ruby_args="$flag '$@'"
            rvm_parse_break=1
          else
            rvm_ruby_args="$*"
            rvm_parse_break=1
          fi
        else
          if match "$1" "^-" ; then
            unset rvm_ruby_version
          else
            if match "$1" "^[0-9]" ; then
              rvm_ruby_version=$(echo "$1" | tr ',' ' ') ; shift
              unset rvm_ruby_interpreter
            else
              if [[ "jruby" = "$1" ]] || [[ "rbx" = "$1" ]] || [[ "rubinius" = "$1" ]] || [[ "macruby" = "$1" ]] || [[ "ree" = "$1" ]] || [[  "mput" = "$1" ]]  || [[  "shyouhei" = "$1" ]] ; then
                rvm_ruby_interpreter=$1 ; shift
              else
                unset rvm_ruby_interpreter rvm_ruby_version
              fi
            fi
          fi
        fi
      ;;

      benchmark|bench)
        rvm_action="benchmark"
      ;;

      specs|tests)
        rvm_action="do"
        rvm_ruby_args="rake $rvm_token"
      ;;

      #1.8|1.8.0|1.8.1|1.8.2|1.8.3|1.8.4|1.8.5|1.8.6|1.8.7|1.9|1.9.1|1.9.2)
      #  rvm_ruby_interpreter=${rvm_ruby_interpreter:-ruby}
      #  rvm_ruby_version="$rvm_token"
      #  rvm_action=${rvm_action:-use}
      #;;

      #1.2.0|1.3|1.3.0|1.3.1|1.4|1.4.0)
      #  if [[ "1.3" = "$rvm_token" ]] ; then
      #    rvm_ruby_version="1.3.1"
      #  elif [[ "1.4" = "$rvm_token" ]] ; then
      #    rvm_ruby_version="1.4.0"
      #  else
      #    rvm_ruby_version="$rvm_token"
      #  fi
      #  rvm_ruby_interpreter=${rvm_ruby_interpreter:-jruby}
      #  rvm_action=${rvm_action:-use}
      #;;

      -v|--version)
        if [[ -z "$1" ]] ; then
          rvm_action="version"
        else
          rvm_ruby_version="$1"
          shift
        fi
      ;;

      --repository|--repo|--url)
        rvm_ruby_repo_url=$rvm_token
      ;;

      --ree-options)
        if [[ ! -z "$1" ]] ; then
          rvm_ree_options="$(echo $1 | tr ',' ' ')" ; shift
        else
          rvm_action="error"
          rvm_error_message="--ree-options *must* be followed by... well... options."
        fi
      ;;

      -t|--tag)
        rvm_ruby_tag="$1";
        rvm_action="${rvm_action:-use}"
        shift
      ;;

      --head)
        if [[ -z "$rvm_ruby_string" ]] ; then rvm_ruby_string="head"; else rvm_ruby_string="${rvm_ruby_string}-head" ; fi
        rvm_ruby_revision="head"
        rvm_head_flag=1
        rvm_action="${rvm_action:-use}"
      ;;

      --rev|--revision)
        rvm_ruby_revision="$1";
        rvm_action="${rvm_action:-use}"
        shift
      ;;

      -b|--branch)
        rvm_ruby_branch="$1";
        rvm_action="${rvm_action:-use}"
        shift
      ;;

      --bin)
        if [[ "update" = "$rvm_action" ]] ; then
          rvm_bin_flag=1
        else
          rvm_bin_path="$1" ; shift
        fi
        ;;

      -j)
        if [[ ! -z "$1" ]] ; then
          rvm_make_flags="$rvm_make_flags -j$1"
          shift
        else
          rvm_action="error"
          rvm_error_message="-j *must* be followed by an integer (normally the # of CPU's in your machine)."
        fi
      ;;

      -C|--configure)
        if [[ ! -z "$1" ]] ; then
          rvm_ruby_configure_flags="$(echo $1 | tr ',' ' ')"
          shift
        else
          rvm_action="error"
          rvm_error_message="--configure *must* be followed by configure flags."
        fi
      ;;

      -r|--require)
        if [[ -z "$1" ]] ; then
          rvm_action="error"
          rvm_error_message="-r|--require *must* be followed by a library name."
        else
          rvm_ruby_require="$rvm_ruby_require -r$1"
          shift
        fi
      ;;

      -I|--include)
        if [[ -z "$1" ]] ; then
          rvm_action="error"
          rvm_error_message="-I|--include *must* be followed by a path."
        else
          rvm_ruby_load_path="$rvm_ruby_load_path:$1"
          shift
        fi
      ;;

      -f|--file)
        rvm_action="ruby"
        rvm_ruby_file="$1"
        shift
      ;;

      default|system)
        rvm_action="use"
        rvm_ruby_interpreter="system"
        rvm_ruby_string="$rvm_token"
      ;;

      --install)            rvm_install_on_use_flag=1          ;;
      -h|--help|usage|help) rvm_action=help                    ;;
      --prefix)             rvm_prefix_path="$1"       ; shift ;;
      -G|--gems)            rvm_gem_path="$1"          ; shift ;;
      --source)             rvm_src_path="$1"          ; shift ;;
      --archives)           rvm_archives_path="$1"     ; shift ;;
      --make)               rvm_ruby_make="$1"         ; shift ;;
      --make-install)       rvm_ruby_make_install="$1" ; shift ;;
      --nice)               rvm_niceness="$1"          ; shift ;;
      -l|--level)           rvm_ruby_patch_level="p$1" ; shift ;;
      # TODO: handle this below better (if $1 is null)
      -m|--gem-set)         rvm_gem_set_name="$1"      ; shift ;;
      --sdk)                rvm_sdk="$1"               ; shift ;;
      --archflags)          rvm_archflags="$1"         ; shift ;;

      tests|specs)          rvm_action="tests"                 ;;
      --trace)              eval "rvm_$(echo $rvm_token | sed 's#-##g')_flag=1" ; set -x ;;

      --self|--gem|--rubygems|--reconfigure|--default|--debug|--force|--all|--dump|--summary|--jit|--latest|--yaml|--json|--archive|--shebang|--env|--path|--tail|--delete)
        eval "rvm_$(echo $rvm_token | sed 's#-##g')_flag=1"
      ;;

      reboot|flush|asdf|damnit|wtf|argh|work|workdamnit|BOOM|boom|wth)
        $rvm_action="reboot"
      ;;

      --)
        rvm_ruby_args="$*"
        rvm_parse_break=1
      ;;

      *)
        if [[ ! -z "$rvm_token" ]] ; then
          if [[ "gems" = "$rvm_action" ]] ; then
            if match "$rvm_token" "^.+%.+$" ; then
              rvm_gem_set_name="$(echo "$rvm_token" | awk -F'%' '{print $2}')"
              rvm_ruby_string="$(echo "$rvm_token" | awk -F'%' '{print $1}')"
            elif [[ ! -z "$(echo "$rvm_token" | awk '/\.gems$/')" ]] ; then
              rvm_file_name="$(echo "$rvm_token" | sed 's#\.gems##g').gems"
              # elif [[ ! -z "$(echo "$rvm_token" | awk '/\.gems$/')" ]] ; then
            else
              rvm_gem_set_name="$(echo "$rvm_token" | sed 's#\.gems##g')"
              rvm_file_name="$rvm_gem_set_name.gems"
            fi
          elif [[ ! -z "$(echo "$rvm_token" | awk '/,/')" ]] ; then
            rvm_ruby_version="$rvm_token"
            if [[ -z "$rvm_action" ]] ; then
              rvm_action="do" # Not sure if we really want to do this but we'll try it out.
            fi
          elif match "$rvm_token" "^.+%.+$" ; then
            rvm_gem_set_name="$(echo "$rvm_token" | awk -F'%' '{print $2}')"
            rvm_ruby_string="$(echo "$rvm_token" | awk -F'%' '{print $1}')"
          elif match "$rvm_token" "-" ; then
            rvm_ruby_string="$rvm_token"
          elif match "$rvm_token" "^[0-9].[0-9]" ; then
            rvm_ruby_string="$rvm_token"
            rvm_action="${rvm_action:-use}"
          elif match "$rvm_token" "^ree" ; then
            rvm_ruby_string="$rvm_token"
            rvm_action="${rvm_action:-use}"
          else
            if match "$rvm_token" "\.rb$" ; then # we have a specified ruby script
              rvm_ruby_args=$rvm_token
              rvm_ruby_file=$rvm_token
              if [[ -z "$rvm_action" ]] ; then
                rvm_action="ruby" # Not sure if we really want to do this but we'll try it out.
              fi
            else
              rvm_action="error"
              rvm_error_message="Unrecognized command line argument: '$rvm_token'"
            fi
          fi
        else
          rvm_action="error"
          rvm_error_message="Unrecognized command line argument(s): '$rvm_token $@'"
        fi
        if [[ "error" = "$rvm_action" ]] ; then
          break;
        fi

    esac

    if [[ -z "$rvm_action" ]] && [[ ! -z "$rvm_ruby_string" ]]  ; then rvm_action="use" ; fi
    if [[ ! -z "$rvm_parse_break" ]] || [[ ! -z "$rvm_error_message" ]] ; then unset rvm_parse_break; break; fi
  done

  if [[ ! -z "$rvm_error_message" ]] ; then __rvm_pushpop ; return 1 ; fi
}

rvm() {

  trap '__rvm_cleanup_variables ; rm -rf "/tmp/rvm/$$" >/dev/null 2>&1' 0 1 2 3 15

  # Check that this is the current version.
  disk_version=$(cat "${rvm_path:-$HOME/.rvm}/lib/VERSION.yml" | tail -n 3 | sed 's/^.*: //g' | tr "\n" '.' | sed 's/\.$//')
  if [[ "${rvm_version}" != "${disk_version}" ]] && [[ "reload" != "$1" ]]; then
    echo -e "A newer version of rvm has been installed ($disk_version) than is loaded ($rvm_version), please do one of the following:\n  * 'rvm reload'\n  * open a new shell\n  * source your shell init scripts"
    return 1
  fi

  __rvm_cleanup_variables
  __rvm_load_rvmrc
  __rvm_initialize
  __rvm_load_defaults
  __rvm_parse_args $@

  if [[ -z "$rvm_trace_flag" ]] ; then set +x ; else set -x ; fi
  result=0
  case "$rvm_action" in
    use)           __rvm_use              ; result=$?  ;;
    gemdir)        __rvm_gemdir           ; result=$?  ;;
    gemdup)        __rvm_gemdup           ; result=$?  ;;
    srcdir)        __rvm_source_dir       ; result=$?  ;;
    list)          __rvm_list             ; result=$?  ;;
    version)       __rvm_version          ; result=$?  ;;
    reset)         __rvm_reset            ; result=$?  ;;
    implode)       __rvm_implode          ; result=$?  ;;
    update)        __rvm_update           ; result=$?  ;;
    readline)      __rvm_readline_install ; result=$?  ;;
    reboot)        __rvm_reboot           ; result=$?  ;;
    usage|help)    __rvm_usage            ; result=$?  ;;
    benchmark)     __rvm_benchmark        ; result=$?  ;;
    inspect)       __rvm_inspect          ; result=$?  ;;
    gems)          __rvm_gems             ; result=$?  ;;
    remove)        __rvm_remove_ruby      ; result=$?  ;;
    ruby|gem|rake) __rvm_do               ; result=$?  ;;
    reload)        source "$rvm_path/scripts/rvm"      ;;
    install|uninstall) __rvm_manage_rubies ; result=$? ;;
    tests|specs)   rvm_action="rake" ; __rvm_do ; result=$? ;;

    iconv|openssl|ncurses|zlib|readline)
      __rvm_${rvm_action}_install
      result=$?
    ;;

    gemsync)
      rvm_source_gem_path=$(__rvm_select ; echo $rvm_ruby_gem_home)
      __rvm_gem_sync
    ;;

    info|debug)
      __rvm_version
      __rvm_info
      if [[ "debug" = "$rvm_action" ]] ; then rvm_debug_flag=1 ; __rvm_debug ; fi
    ;;

    error)
      __rvm_log "fail" "$rvm_error_message ( see: 'rvm usage' )"
      __rvm_pushpop
      result=1;
    ;;

    *)
      if [[ ! -z "$rvm_action" ]] ; then
        __rvm_log "fail"  "unknown action '$rvm_action'"
      else
        __rvm_usage
      fi
      result=1
  esac

  if [[ "1" = "$rvm_trace_flag" ]] ; then set +x ; unset rvm_trace_flag ; fi

  return $result
}