#!/usr/bin/env bash
set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x

global MOVES := '('ABLE ABNORMA AGAIN AIREXPL ANG ANGER ASAIL ATTACK AURORA AWL BAN BAND BARE BEAT BEATED BELLY BIND BITE BLOC BLOOD BODY BOOK BREATH BUMP CAST CHAM CLAMP CLAP CLAW CLEAR CLI CLIP CLOUD CONTRO CONVY COOLHIT CRASH CRY CUT DESCRI D-FIGHT DIG DITCH DIV DOZ DRE DUL DU-PIN DYE EARTH EDU EG-BOMB EGG ELEGY ELE-HIT EMBODY EMPLI ENGL ERUPT EVENS EXPLOR EYES FALL FAST F-CAR F-DANCE FEARS F-FIGHT FIGHT FIR FIRE FIREHIT FLAME FLAP FLASH FLEW FORCE FRA FREEZE FROG G-BIRD GENKISS GIFT G-KISS G-MOUSE GRADE GROW HAMMER HARD HAT HATE H-BOMB HELL-R HEMP HINT HIT HU HUNT HYPNOSI INHA IRO IRONBAR IR-WING J-GUN KEE KICK KNIF KNIFE KNOCK LEVEL LIGH LIGHHIT LIGHT LIVE L-WALL MAD MAJUS MEL MELO MESS MILK MIMI MISS MIXING MOVE MUD NI-BED NOISY NOONLI NULL N-WAVE PAT PEACE PIN PLAN PLANE POIS POL POWDE POWE POWER PRIZE PROTECT PROUD RAGE RECOR REFLAC REFREC REGR RELIV RENEW R-FIGHT RING RKICK ROCK ROUND RUS RUSH SAND SAW SCISSOR SCRA SCRIPT SEEN SERVER SHADOW SHELL SHINE SHO SIGHT SIN SMALL SMELT SMOK SNAKE SNO SNOW SOU SO-WAVE SPAR SPEC SPID S-PIN SPRA STAM STARE STEA STONE STORM STRU STRUG STUDEN SUBS SUCID SUN-LIG SUNRIS SUPLY S-WAVE TAILS TANGL TASTE TELLI THANK TONKICK TOOTH TORL TRAIN TRIKICK TUNGE VOLT WA-GUN WATCH WAVE W-BOMB WFALL WFING WHIP WHIRL WIND WOLF WOOD WOR YUJA)
global NAMES := '('SEED GRASS FLOWE SHAD CABR SNAKE GOLD COW GUIKI PEDAL DELAN B-FLY BIDE KEYU FORK LAP PIGE PIJIA CAML LAT BIRD BABOO VIV ABOKE PIKAQ RYE SAN BREAD LIDEL LIDE PIP PIKEX ROK JUGEN PUD BUDE ZHIB GELU GRAS FLOW LAFUL ATH BALA CORN MOLUF DESP DAKED MIMI BOLUX KODA GELUD MONK SUMOY GEDI WENDI NILEM NILE NILEC KEZI YONGL HUDE WANLI GELI GUAIL MADAQ WUCI WUCI MUJEF JELLY SICIB GELU NELUO BOLI JIALE YED YEDE CLO SCARE AOCO DEDE DEDEI BAWU JIUG BADEB BADEB HOLE BALUX GES FANT QUAR YIHE SWAB SLIPP CLU DEPOS BILIY YUANO SOME NO YELA EMPT ZECUN XIAHE BOLEL DEJI MACID XIHON XITO LUCK MENJI GELU DECI XIDE DASAJ DONGN RICUL MINXI BALIY ZENDA LUZEL HELE5 0FENB KAIL JIAND CARP JINDE LAPU MUDE YIFU LINLI SANDI HUSI JINC OUMU OUMUX CAP KUIZA PUD TIAO FRMAN CLAU SPARK DRAGO BOLIU GUAIL MIYOU MIY QIAOK BEIL MUKEI RIDED MADAM BAGEP CROC ALIGE OUDAL OUD DADA HEHE YEDEA NUXI NUXIN ROUY ALIAD STICK QIANG LAAND PIQI PI PUPI DEKE DEKEJ NADI NADIO MALI PEA ELECT FLOWE MAL MALI HUSHU NILEE YUZI POPOZ DUZI HEBA XIAN SHAN YEYEA WUY LUO KEFE HULA CROW YADEH MOW ANNAN SUONI KYLI HULU HUDEL YEHE GULAE YEHE BLU GELAN BOAT NIP POIT HELAK XINL BEAR LINB MAGEH MAGEJ WULI YIDE RIVE FISH AOGU DELIE MANTE KONMU DELU HELU HUAN HUMA DONGF JINCA HEDE DEFU LIBY JIAPA MEJI HELE BUHU MILK HABI THUN GARD DON YANGQ SANAQ BANQ LUJ PHIX SIEI EGG)

proc random_number {
  [[ -n "$1" ]] && global RANGE := $1
  if [[ -n "$RANGE" ]] {
    global number := $RANDOM
    let "number %= $RANGE"
  } else {
    global number := $RANDOM
  }
  echo $number
}

proc random_name {
 global NUM1 := $[random_number $(#MOVES[@])]
 global NUM2 := $[random_number $(#MOVES[@])]
 global NUM3 := $[random_number $(#NAMES[@])]

 global UPPER_APPNAME := ""$(MOVES[${NUM1}])-$(MOVES[${NUM2}])-$(NAMES[${NUM3}])""

 [[ "$BASH_VERSION" =~ 4.* ]] && global lower_appname := $(UPPER_APPNAME,,)
 [[ -z "$lower_appname" ]] && global lower_appname := $[echo $UPPER_APPNAME | tr '[:upper:]' '[:lower:]]
 echo $lower_appname
}

proc client_help_msg {
  echo "==> Configure the DOKKU_HOST environment variable or run $0 from a repository with a git remote named dokku"
  echo "--> i.e. git remote add dokku dokku@<dokku-host>:<app-name>"
  exit 20 # exit with specific status. only used in units tests for now
}

proc is_git_repo {
    git rev-parse &>/dev/null
}

proc has_dokku_remote {
    git remote show | grep dokku
}

if [[ -z $DOKKU_HOST ]] {
  if [[ -d .git ]] || git rev-parse --git-dir > /dev/null !2 > !1 {
    global DOKKU_HOST := $[git remote -v !2 >/dev/null | grep -Ei "^dokku" | head -n 1 | cut -f1 -d' ' | cut -f2 -d '@' | cut -f1 -d':' !2 >/dev/null || true]
  } else {
    client_help_msg
  }
}

export DOKKU_PORT=$(DOKKU_PORT:=22)

if [[ ! -z $DOKKU_HOST ]] {
  proc _dokku {
    global appname := ''""
    if [[ -d .git ]] || git rev-parse --git-dir > /dev/null !2 > !1 {
      set +e
      global appname := $[git remote -v !2 >/dev/null | grep -Ei "dokku@$DOKKU_HOST" | head -n 1 | cut -f2 -d'@' | cut -f1 -d' ' | cut -f2 -d':' !2 >/dev/null]
      set -e
    } else {
      echo "This is not a git repository"
    }

    matchstr $1 {
      apps:create {
        if [[ -z "$2" ]] {
          global appname := $[random_name]
          global counter := '0'
          while ssh -p "$DOKKU_PORT" "dokku@$DOKKU_HOST" apps 2>/dev/null| grep -q "$appname" {
            if [[ $counter -ge 100 ]] {
              echo "Error: could not reasonably generate a new app name. try cleaning up some apps..."
              ssh -p $DOKKU_PORT "dokku@$DOKKU_HOST" apps
              exit 1
            } else {
              global appname := $[random_name]
              global counter := $(counter+1)
            }
          }
        } else {
          global appname := $2
        }
        if git remote add dokku "dokku@$DOKKU_HOST:$appname" {
          echo "-----> Dokku remote added at $DOKKU_HOST"
          echo "-----> Application name is $appname"
        } else {
          echo "!      Dokku remote not added! Do you already have a dokku remote?"
          return
        }
        }
    apps:destroy {
      is_git_repo && has_dokku_remote && git remote remove dokku
      }
    }

    [[ -n "$@" ]] && [[ -n "$appname" ]] && global app_arg := ""--app $appname""
    # echo "ssh -o LogLevel=QUIET -p $DOKKU_PORT -t dokku@$DOKKU_HOST -- $app_arg $@"
    # shellcheck disable=SC2068,SC2086
    ssh -o LogLevel=QUIET -p $DOKKU_PORT -t dokku@$DOKKU_HOST -- $app_arg $ifsjoin(Argv)
  }

  if [[ "$0" == "dokku" ]] || [[ "$0" == *dokku_client.sh ]] || [[ "$0" == $(which dokku) ]] {
    _dokku @Argv
    exit $Status
  }
} else {
  client_help_msg
}
(CommandList
  children: [
    (Sentence child:(C {(set)} {(-eo)} {(pipefail)}) terminator:<Op_Semi ";">)
    (AndOr
      children: [(DBracket expr:(WordTest w:{($ VSub_Name "$DOKKU_TRACE")})) (C {(set)} {(-x)})]
      op_id: Op_DAmp
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:MOVES)
          op: Equal
          rhs: 
            {
              (ArrayLiteralPart
                words: [
                  {(ABLE)}
                  {(ABNORMA)}
                  {(AGAIN)}
                  {(AIREXPL)}
                  {(ANG)}
                  {(ANGER)}
                  {(ASAIL)}
                  {(ATTACK)}
                  {(AURORA)}
                  {(AWL)}
                  {(BAN)}
                  {(BAND)}
                  {(BARE)}
                  {(BEAT)}
                  {(BEATED)}
                  {(BELLY)}
                  {(BIND)}
                  {(BITE)}
                  {(BLOC)}
                  {(BLOOD)}
                  {(BODY)}
                  {(BOOK)}
                  {(BREATH)}
                  {(BUMP)}
                  {(CAST)}
                  {(CHAM)}
                  {(CLAMP)}
                  {(CLAP)}
                  {(CLAW)}
                  {(CLEAR)}
                  {(CLI)}
                  {(CLIP)}
                  {(CLOUD)}
                  {(CONTRO)}
                  {(CONVY)}
                  {(COOLHIT)}
                  {(CRASH)}
                  {(CRY)}
                  {(CUT)}
                  {(DESCRI)}
                  {(D-FIGHT)}
                  {(DIG)}
                  {(DITCH)}
                  {(DIV)}
                  {(DOZ)}
                  {(DRE)}
                  {(DUL)}
                  {(DU-PIN)}
                  {(DYE)}
                  {(EARTH)}
                  {(EDU)}
                  {(EG-BOMB)}
                  {(EGG)}
                  {(ELEGY)}
                  {(ELE-HIT)}
                  {(EMBODY)}
                  {(EMPLI)}
                  {(ENGL)}
                  {(ERUPT)}
                  {(EVENS)}
                  {(EXPLOR)}
                  {(EYES)}
                  {(FALL)}
                  {(FAST)}
                  {(F-CAR)}
                  {(F-DANCE)}
                  {(FEARS)}
                  {(F-FIGHT)}
                  {(FIGHT)}
                  {(FIR)}
                  {(FIRE)}
                  {(FIREHIT)}
                  {(FLAME)}
                  {(FLAP)}
                  {(FLASH)}
                  {(FLEW)}
                  {(FORCE)}
                  {(FRA)}
                  {(FREEZE)}
                  {(FROG)}
                  {(G-BIRD)}
                  {(GENKISS)}
                  {(GIFT)}
                  {(G-KISS)}
                  {(G-MOUSE)}
                  {(GRADE)}
                  {(GROW)}
                  {(HAMMER)}
                  {(HARD)}
                  {(HAT)}
                  {(HATE)}
                  {(H-BOMB)}
                  {(HELL-R)}
                  {(HEMP)}
                  {(HINT)}
                  {(HIT)}
                  {(HU)}
                  {(HUNT)}
                  {(HYPNOSI)}
                  {(INHA)}
                  {(IRO)}
                  {(IRONBAR)}
                  {(IR-WING)}
                  {(J-GUN)}
                  {(KEE)}
                  {(KICK)}
                  {(KNIF)}
                  {(KNIFE)}
                  {(KNOCK)}
                  {(LEVEL)}
                  {(LIGH)}
                  {(LIGHHIT)}
                  {(LIGHT)}
                  {(LIVE)}
                  {(L-WALL)}
                  {(MAD)}
                  {(MAJUS)}
                  {(MEL)}
                  {(MELO)}
                  {(MESS)}
                  {(MILK)}
                  {(MIMI)}
                  {(MISS)}
                  {(MIXING)}
                  {(MOVE)}
                  {(MUD)}
                  {(NI-BED)}
                  {(NOISY)}
                  {(NOONLI)}
                  {(NULL)}
                  {(N-WAVE)}
                  {(PAT)}
                  {(PEACE)}
                  {(PIN)}
                  {(PLAN)}
                  {(PLANE)}
                  {(POIS)}
                  {(POL)}
                  {(POWDE)}
                  {(POWE)}
                  {(POWER)}
                  {(PRIZE)}
                  {(PROTECT)}
                  {(PROUD)}
                  {(RAGE)}
                  {(RECOR)}
                  {(REFLAC)}
                  {(REFREC)}
                  {(REGR)}
                  {(RELIV)}
                  {(RENEW)}
                  {(R-FIGHT)}
                  {(RING)}
                  {(RKICK)}
                  {(ROCK)}
                  {(ROUND)}
                  {(RUS)}
                  {(RUSH)}
                  {(SAND)}
                  {(SAW)}
                  {(SCISSOR)}
                  {(SCRA)}
                  {(SCRIPT)}
                  {(SEEN)}
                  {(SERVER)}
                  {(SHADOW)}
                  {(SHELL)}
                  {(SHINE)}
                  {(SHO)}
                  {(SIGHT)}
                  {(SIN)}
                  {(SMALL)}
                  {(SMELT)}
                  {(SMOK)}
                  {(SNAKE)}
                  {(SNO)}
                  {(SNOW)}
                  {(SOU)}
                  {(SO-WAVE)}
                  {(SPAR)}
                  {(SPEC)}
                  {(SPID)}
                  {(S-PIN)}
                  {(SPRA)}
                  {(STAM)}
                  {(STARE)}
                  {(STEA)}
                  {(STONE)}
                  {(STORM)}
                  {(STRU)}
                  {(STRUG)}
                  {(STUDEN)}
                  {(SUBS)}
                  {(SUCID)}
                  {(SUN-LIG)}
                  {(SUNRIS)}
                  {(SUPLY)}
                  {(S-WAVE)}
                  {(TAILS)}
                  {(TANGL)}
                  {(TASTE)}
                  {(TELLI)}
                  {(THANK)}
                  {(TONKICK)}
                  {(TOOTH)}
                  {(TORL)}
                  {(TRAIN)}
                  {(TRIKICK)}
                  {(TUNGE)}
                  {(VOLT)}
                  {(WA-GUN)}
                  {(WATCH)}
                  {(WAVE)}
                  {(W-BOMB)}
                  {(WFALL)}
                  {(WFING)}
                  {(WHIP)}
                  {(WHIRL)}
                  {(WIND)}
                  {(WOLF)}
                  {(WOOD)}
                  {(WOR)}
                  {(YUJA)}
                ]
              )
            }
          spids: [23]
        )
      ]
      spids: [23]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:NAMES)
          op: Equal
          rhs: 
            {
              (ArrayLiteralPart
                words: [
                  {(SEED)}
                  {(GRASS)}
                  {(FLOWE)}
                  {(SHAD)}
                  {(CABR)}
                  {(SNAKE)}
                  {(GOLD)}
                  {(COW)}
                  {(GUIKI)}
                  {(PEDAL)}
                  {(DELAN)}
                  {(B-FLY)}
                  {(BIDE)}
                  {(KEYU)}
                  {(FORK)}
                  {(LAP)}
                  {(PIGE)}
                  {(PIJIA)}
                  {(CAML)}
                  {(LAT)}
                  {(BIRD)}
                  {(BABOO)}
                  {(VIV)}
                  {(ABOKE)}
                  {(PIKAQ)}
                  {(RYE)}
                  {(SAN)}
                  {(BREAD)}
                  {(LIDEL)}
                  {(LIDE)}
                  {(PIP)}
                  {(PIKEX)}
                  {(ROK)}
                  {(JUGEN)}
                  {(PUD)}
                  {(BUDE)}
                  {(ZHIB)}
                  {(GELU)}
                  {(GRAS)}
                  {(FLOW)}
                  {(LAFUL)}
                  {(ATH)}
                  {(BALA)}
                  {(CORN)}
                  {(MOLUF)}
                  {(DESP)}
                  {(DAKED)}
                  {(MIMI)}
                  {(BOLUX)}
                  {(KODA)}
                  {(GELUD)}
                  {(MONK)}
                  {(SUMOY)}
                  {(GEDI)}
                  {(WENDI)}
                  {(NILEM)}
                  {(NILE)}
                  {(NILEC)}
                  {(KEZI)}
                  {(YONGL)}
                  {(HUDE)}
                  {(WANLI)}
                  {(GELI)}
                  {(GUAIL)}
                  {(MADAQ)}
                  {(WUCI)}
                  {(WUCI)}
                  {(MUJEF)}
                  {(JELLY)}
                  {(SICIB)}
                  {(GELU)}
                  {(NELUO)}
                  {(BOLI)}
                  {(JIALE)}
                  {(YED)}
                  {(YEDE)}
                  {(CLO)}
                  {(SCARE)}
                  {(AOCO)}
                  {(DEDE)}
                  {(DEDEI)}
                  {(BAWU)}
                  {(JIUG)}
                  {(BADEB)}
                  {(BADEB)}
                  {(HOLE)}
                  {(BALUX)}
                  {(GES)}
                  {(FANT)}
                  {(QUAR)}
                  {(YIHE)}
                  {(SWAB)}
                  {(SLIPP)}
                  {(CLU)}
                  {(DEPOS)}
                  {(BILIY)}
                  {(YUANO)}
                  {(SOME)}
                  {(NO)}
                  {(YELA)}
                  {(EMPT)}
                  {(ZECUN)}
                  {(XIAHE)}
                  {(BOLEL)}
                  {(DEJI)}
                  {(MACID)}
                  {(XIHON)}
                  {(XITO)}
                  {(LUCK)}
                  {(MENJI)}
                  {(GELU)}
                  {(DECI)}
                  {(XIDE)}
                  {(DASAJ)}
                  {(DONGN)}
                  {(RICUL)}
                  {(MINXI)}
                  {(BALIY)}
                  {(ZENDA)}
                  {(LUZEL)}
                  {(HELE5)}
                  {(0FENB)}
                  {(KAIL)}
                  {(JIAND)}
                  {(CARP)}
                  {(JINDE)}
                  {(LAPU)}
                  {(MUDE)}
                  {(YIFU)}
                  {(LINLI)}
                  {(SANDI)}
                  {(HUSI)}
                  {(JINC)}
                  {(OUMU)}
                  {(OUMUX)}
                  {(CAP)}
                  {(KUIZA)}
                  {(PUD)}
                  {(TIAO)}
                  {(FRMAN)}
                  {(CLAU)}
                  {(SPARK)}
                  {(DRAGO)}
                  {(BOLIU)}
                  {(GUAIL)}
                  {(MIYOU)}
                  {(MIY)}
                  {(QIAOK)}
                  {(BEIL)}
                  {(MUKEI)}
                  {(RIDED)}
                  {(MADAM)}
                  {(BAGEP)}
                  {(CROC)}
                  {(ALIGE)}
                  {(OUDAL)}
                  {(OUD)}
                  {(DADA)}
                  {(HEHE)}
                  {(YEDEA)}
                  {(NUXI)}
                  {(NUXIN)}
                  {(ROUY)}
                  {(ALIAD)}
                  {(STICK)}
                  {(QIANG)}
                  {(LAAND)}
                  {(PIQI)}
                  {(PI)}
                  {(PUPI)}
                  {(DEKE)}
                  {(DEKEJ)}
                  {(NADI)}
                  {(NADIO)}
                  {(MALI)}
                  {(PEA)}
                  {(ELECT)}
                  {(FLOWE)}
                  {(MAL)}
                  {(MALI)}
                  {(HUSHU)}
                  {(NILEE)}
                  {(YUZI)}
                  {(POPOZ)}
                  {(DUZI)}
                  {(HEBA)}
                  {(XIAN)}
                  {(SHAN)}
                  {(YEYEA)}
                  {(WUY)}
                  {(LUO)}
                  {(KEFE)}
                  {(HULA)}
                  {(CROW)}
                  {(YADEH)}
                  {(MOW)}
                  {(ANNAN)}
                  {(SUONI)}
                  {(KYLI)}
                  {(HULU)}
                  {(HUDEL)}
                  {(YEHE)}
                  {(GULAE)}
                  {(YEHE)}
                  {(BLU)}
                  {(GELAN)}
                  {(BOAT)}
                  {(NIP)}
                  {(POIT)}
                  {(HELAK)}
                  {(XINL)}
                  {(BEAR)}
                  {(LINB)}
                  {(MAGEH)}
                  {(MAGEJ)}
                  {(WULI)}
                  {(YIDE)}
                  {(RIVE)}
                  {(FISH)}
                  {(AOGU)}
                  {(DELIE)}
                  {(MANTE)}
                  {(KONMU)}
                  {(DELU)}
                  {(HELU)}
                  {(HUAN)}
                  {(HUMA)}
                  {(DONGF)}
                  {(JINCA)}
                  {(HEDE)}
                  {(DEFU)}
                  {(LIBY)}
                  {(JIAPA)}
                  {(MEJI)}
                  {(HELE)}
                  {(BUHU)}
                  {(MILK)}
                  {(HABI)}
                  {(THUN)}
                  {(GARD)}
                  {(DON)}
                  {(YANGQ)}
                  {(SANAQ)}
                  {(BANQ)}
                  {(LUJ)}
                  {(PHIX)}
                  {(SIEI)}
                  {(EGG)}
                ]
              )
            }
          spids: [472]
        )
      ]
      spids: [472]
    )
    (FuncDef
      name: random_number
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (DBracket
                  expr: (BoolUnary op_id:BoolUnary_n child:{(DQ ($ VSub_Number "$1"))})
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:RANGE)
                      op: Equal
                      rhs: {(DQ ($ VSub_Number "$1"))}
                      spids: [991]
                    )
                  ]
                  spids: [991]
                )
              ]
              op_id: Op_DAmp
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: (BoolUnary op_id:BoolUnary_n child:{(DQ ($ VSub_Name "$RANGE"))})
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:number)
                          op: Equal
                          rhs: {($ VSub_Name "$RANDOM")}
                          spids: [1013]
                        )
                      ]
                      spids: [1013]
                    )
                    (C {(let)} {(DQ ("number %= ") ($ VSub_Name "$RANGE"))})
                  ]
                  spids: [-1 1010]
                )
              ]
              else_action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:number)
                      op: Equal
                      rhs: {($ VSub_Name "$RANDOM")}
                      spids: [1028]
                    )
                  ]
                  spids: [1028]
                )
              ]
              spids: [1025 1032]
            )
            (C {(echo)} {($ VSub_Name "$number")})
          ]
          spids: [976]
        )
      spids: [972 975]
    )
    (FuncDef
      name: random_name
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:NUM1)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(random_number)} 
                                {
                                  (BracedVarSub
                                    token: <VSub_Name MOVES>
                                    prefix_op: VSub_Pound
                                    bracket_op: (WholeArray op_id:Lit_At)
                                    spids: [1053 1059]
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [1050 1060]
                      )
                    }
                  spids: [1049]
                )
              ]
              spids: [1049]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:NUM2)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(random_number)} 
                                {
                                  (BracedVarSub
                                    token: <VSub_Name MOVES>
                                    prefix_op: VSub_Pound
                                    bracket_op: (WholeArray op_id:Lit_At)
                                    spids: [1067 1073]
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [1064 1074]
                      )
                    }
                  spids: [1063]
                )
              ]
              spids: [1063]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:NUM3)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(random_number)} 
                                {
                                  (BracedVarSub
                                    token: <VSub_Name NAMES>
                                    prefix_op: VSub_Pound
                                    bracket_op: (WholeArray op_id:Lit_At)
                                    spids: [1081 1087]
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [1078 1088]
                      )
                    }
                  spids: [1077]
                )
              ]
              spids: [1077]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:UPPER_APPNAME)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (BracedVarSub
                          token: <VSub_Name MOVES>
                          bracket_op: (ArrayIndex expr:(ArithWord w:{(${ VSub_Name NUM1)}))
                          spids: [1094 1101]
                        ) (-) 
                        (BracedVarSub
                          token: <VSub_Name MOVES>
                          bracket_op: (ArrayIndex expr:(ArithWord w:{(${ VSub_Name NUM2)}))
                          spids: [1103 1110]
                        ) (-) 
                        (BracedVarSub
                          token: <VSub_Name NAMES>
                          bracket_op: (ArrayIndex expr:(ArithWord w:{(${ VSub_Name NUM3)}))
                          spids: [1112 1119]
                        )
                      )
                    }
                  spids: [1092]
                )
              ]
              spids: [1092]
            )
            (AndOr
              children: [
                (DBracket
                  expr: 
                    (BoolBinary
                      op_id: BoolBinary_EqualTilde
                      left: {(DQ ($ VSub_Name "$BASH_VERSION"))}
                      right: {(4.) (Lit_Other "*")}
                    )
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:lower_appname)
                      op: Equal
                      rhs: 
                        {
                          (BracedVarSub
                            token: <VSub_Name UPPER_APPNAME>
                            suffix_op: (StringUnary op_id:VOp1_DComma arg_word:{})
                            spids: [1140 1143]
                          )
                        }
                      spids: [1139]
                    )
                  ]
                  spids: [1139]
                )
              ]
              op_id: Op_DAmp
            )
            (AndOr
              children: [
                (DBracket
                  expr: (BoolUnary op_id:BoolUnary_z child:{(DQ ($ VSub_Name "$lower_appname"))})
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:lower_appname)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (Pipeline
                                    children: [
                                      (C {(echo)} {(DQ ($ VSub_Name "$UPPER_APPNAME"))})
                                      (C {(tr)} {(SQ <"[:upper:]">)} {(SQ <"[:lower:]">)})
                                    ]
                                    negated: False
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [1159 1177]
                          )
                        }
                      spids: [1158]
                    )
                  ]
                  spids: [1158]
                )
              ]
              op_id: Op_DAmp
            )
            (C {(echo)} {(DQ ($ VSub_Name "$lower_appname"))})
          ]
          spids: [1046]
        )
      spids: [1042 1045]
    )
    (FuncDef
      name: client_help_msg
      body: 
        (BraceGroup
          children: [
            (C {(echo)} 
              {
                (DQ ("==> Configure the DOKKU_HOST environment variable or run ") ($ VSub_Number "$0") 
                  (" from a repository with a git remote named dokku")
                )
              }
            )
            (C {(echo)} {(DQ ("--> i.e. git remote add dokku dokku@<dokku-host>:<app-name>"))})
            (C {(exit)} {(20)})
          ]
          spids: [1193]
        )
      spids: [1189 1192]
    )
    (FuncDef
      name: is_git_repo
      body: 
        (BraceGroup
          children: [
            (Sentence child:(C {(git)} {(rev-parse)}) terminator:<Op_Amp "&">)
            (SimpleCommand
              redirects: [(Redir op_id:Redir_Great fd:-1 arg_word:{(/dev/null)} spids:[1234])]
            )
          ]
          spids: [1226]
        )
      spids: [1222 1225]
    )
    (FuncDef
      name: has_dokku_remote
      body: 
        (BraceGroup
          children: [
            (Pipeline
              children: [(C {(git)} {(remote)} {(show)}) (C {(grep)} {(dokku)})]
              negated: False
            )
          ]
          spids: [1244]
        )
      spids: [1240 1243]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: (DBracket expr:(BoolUnary op_id:BoolUnary_z child:{($ VSub_Name "$DOKKU_HOST")}))
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (AndOr
                          children: [
                            (DBracket
                              expr: (BoolUnary op_id:BoolUnary_d child:{(.git)})
                            )
                            (SimpleCommand
                              words: [{(git)} {(rev-parse)} {(--git-dir)}]
                              redirects: [
                                (Redir
                                  op_id: Redir_Great
                                  fd: -1
                                  arg_word: {(/dev/null)}
                                  spids: [1294]
                                )
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: 2
                                  arg_word: {(1)}
                                  spids: [1298]
                                )
                              ]
                            )
                          ]
                          op_id: Op_DPipe
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:DOKKU_HOST)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (AndOr
                                        children: [
                                          (Pipeline
                                            children: [
                                              (SimpleCommand
                                                words: [{(git)} {(remote)} {(-v)}]
                                                redirects: [
                                                  (Redir
                                                    op_id: Redir_Great
                                                    fd: 2
                                                    arg_word: {(/dev/null)}
                                                    spids: [1313]
                                                  )
                                                ]
                                              )
                                              (C {(grep)} {(-Ei)} {(DQ ("^dokku"))})
                                              (C {(head)} {(-n)} {(1)})
                                              (C {(cut)} {(-f1)} {(-d) (SQ <" ">)})
                                              (C {(cut)} {(-f2)} {(-d)} {(SQ <"@">)})
                                              (SimpleCommand
                                                words: [{(cut)} {(-f1)} {(-d) (SQ <":">)}]
                                                redirects: [
                                                  (Redir
                                                    op_id: Redir_Great
                                                    fd: 2
                                                    arg_word: {(/dev/null)}
                                                    spids: [1368]
                                                  )
                                                ]
                                              )
                                            ]
                                            negated: False
                                          )
                                          (C {(true)})
                                        ]
                                        op_id: Op_DPipe
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [1306 1374]
                              )
                            }
                          spids: [1305]
                        )
                      ]
                      spids: [1305]
                    )
                  ]
                  spids: [-1 1302]
                )
              ]
              else_action: [(C {(client_help_msg)})]
              spids: [1377 1383]
            )
          ]
          spids: [-1 1273]
        )
      ]
      spids: [-1 1385]
    )
    (C {(export)} 
      {(Lit_VarLike "DOKKU_PORT=") 
        (BracedVarSub
          token: <VSub_Name DOKKU_PORT>
          suffix_op: (StringUnary op_id:VTest_ColonEquals arg_word:{(22)})
          spids: [1391 1395]
        )
      }
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (DBracket
                  expr: 
                    (LogicalNot
                      child: (BoolUnary op_id:BoolUnary_z child:{($ VSub_Name "$DOKKU_HOST")})
                    )
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (FuncDef
              name: _dokku
              body: 
                (BraceGroup
                  children: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:appname)
                          op: Equal
                          rhs: {(DQ )}
                          spids: [1421]
                        )
                      ]
                      spids: [1421]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (AndOr
                                  children: [
                                    (DBracket
                                      expr: (BoolUnary op_id:BoolUnary_d child:{(.git)})
                                    )
                                    (SimpleCommand
                                      words: [{(git)} {(rev-parse)} {(--git-dir)}]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_Great
                                          fd: -1
                                          arg_word: {(/dev/null)}
                                          spids: [1444]
                                        )
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 2
                                          arg_word: {(1)}
                                          spids: [1448]
                                        )
                                      ]
                                    )
                                  ]
                                  op_id: Op_DPipe
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(set)} {(Lit_Other "+") (e)})
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:appname)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (Pipeline
                                                children: [
                                                  (SimpleCommand
                                                    words: [{(git)} {(remote)} {(-v)}]
                                                    redirects: [
                                                      (Redir
                                                        op_id: Redir_Great
                                                        fd: 2
                                                        arg_word: {(/dev/null)}
                                                        spids: [1469]
                                                      )
                                                    ]
                                                  )
                                                  (C {(grep)} {(-Ei)} 
                                                    {(DQ ("dokku@") ($ VSub_Name "$DOKKU_HOST"))}
                                                  )
                                                  (C {(head)} {(-n)} {(1)})
                                                  (C {(cut)} {(-f2)} {(-d) (SQ <"@">)})
                                                  (C {(cut)} {(-f1)} {(-d) (SQ <" ">)})
                                                  (SimpleCommand
                                                    words: [{(cut)} {(-f2)} {(-d) (SQ <":">)}]
                                                    redirects: [
                                                      (Redir
                                                        op_id: Redir_Great
                                                        fd: 2
                                                        arg_word: {(/dev/null)}
                                                        spids: [1524]
                                                      )
                                                    ]
                                                  )
                                                ]
                                                negated: False
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub "$(">
                                        spids: [1462 1526]
                                      )
                                    }
                                  spids: [1461]
                                )
                              ]
                              spids: [1461]
                            )
                            (C {(set)} {(-e)})
                          ]
                          spids: [-1 1452]
                        )
                      ]
                      else_action: [(C {(echo)} {(DQ ("This is not a git repository"))})]
                      spids: [1534 1544]
                    )
                    (Case
                      to_match: {(DQ ($ VSub_Number "$1"))}
                      arms: [
                        (case_arm
                          pat_list: [{(apps) (Lit_Other ":") (create)}]
                          action: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (DBracket
                                          expr: 
                                            (BoolUnary
                                              op_id: BoolUnary_z
                                              child: {(DQ ($ VSub_Number "$2"))}
                                            )
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:appname)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [(C {(random_name)})]
                                                  )
                                                left_token: <Left_CommandSub "$(">
                                                spids: [1580 1582]
                                              )
                                            }
                                          spids: [1579]
                                        )
                                      ]
                                      spids: [1579]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:counter)
                                          op: Equal
                                          rhs: {(0)}
                                          spids: [1585]
                                        )
                                      ]
                                      spids: [1585]
                                    )
                                    (While
                                      cond: [
                                        (Sentence
                                          child: 
                                            (Pipeline
                                              children: [
                                                (SimpleCommand
                                                  words: [
                                                    {(ssh)}
                                                    {(-p)}
                                                    {(DQ ($ VSub_Name "$DOKKU_PORT"))}
                                                    {(DQ ("dokku@") ($ VSub_Name "$DOKKU_HOST"))}
                                                    {(apps)}
                                                  ]
                                                  redirects: [
                                                    (Redir
                                                      op_id: Redir_Great
                                                      fd: 2
                                                      arg_word: {(/dev/null)}
                                                      spids: [1606]
                                                    )
                                                  ]
                                                )
                                                (C {(grep)} {(-q)} {(DQ ($ VSub_Name "$appname"))})
                                              ]
                                              negated: False
                                            )
                                          terminator: <Op_Semi ";">
                                        )
                                      ]
                                      body: 
                                        (DoGroup
                                          children: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (DBracket
                                                          expr: 
                                                            (BoolBinary
                                                              op_id: BoolBinary_ge
                                                              left: {($ VSub_Name "$counter")}
                                                              right: {(100)}
                                                            )
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(echo)} 
                                                      {
                                                        (DQ 
                                                          (
"Error: could not reasonably generate a new app name. try cleaning up some apps..."
                                                          )
                                                        )
                                                      }
                                                    )
                                                    (C {(ssh)} {(-p)} {(DQ ($ VSub_Name "$DOKKU_PORT"))} 
                                                      {(DQ ("dokku@") ($ VSub_Name "$DOKKU_HOST"))} {(apps)}
                                                    )
                                                    (C {(exit)} {(1)})
                                                  ]
                                                  spids: [-1 1635]
                                                )
                                              ]
                                              else_action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:appname)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (CommandSubPart
                                                            command_list: 
                                                              (CommandList
                                                                children: [(C {(random_name)})]
                                                              )
                                                            left_token: <Left_CommandSub "$(">
                                                            spids: [1670 1672]
                                                          )
                                                        }
                                                      spids: [1669]
                                                    )
                                                  ]
                                                  spids: [1669]
                                                )
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:counter)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (ArithSubPart
                                                            anode: 
                                                              (ArithBinary
                                                                op_id: Arith_Plus
                                                                left: (ArithVarRef name:counter)
                                                                right: (ArithWord w:{(Lit_Digits 1)})
                                                              )
                                                            spids: [1676 1681]
                                                          )
                                                        }
                                                      spids: [1675]
                                                    )
                                                  ]
                                                  spids: [1675]
                                                )
                                              ]
                                              spids: [1666 1684]
                                            )
                                          ]
                                          spids: [1619 1687]
                                        )
                                    )
                                  ]
                                  spids: [-1 1576]
                                )
                              ]
                              else_action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:appname)
                                      op: Equal
                                      rhs: {(DQ ($ VSub_Number "$2"))}
                                      spids: [1693]
                                    )
                                  ]
                                  spids: [1693]
                                )
                              ]
                              spids: [1690 1699]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(git)} {(remote)} {(add)} {(dokku)} 
                                          {
                                            (DQ ("dokku@") ($ VSub_Name "$DOKKU_HOST") (":") 
                                              ($ VSub_Name "$appname")
                                            )
                                          }
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (C {(echo)} 
                                      {
                                        (DQ ("-----> Dokku remote added at ") 
                                          ($ VSub_Name "$DOKKU_HOST")
                                        )
                                      }
                                    )
                                    (C {(echo)} 
                                      {(DQ ("-----> Application name is ") ($ VSub_Name "$appname"))}
                                    )
                                  ]
                                  spids: [-1 1720]
                                )
                              ]
                              else_action: [
                                (C {(echo)} 
                                  {
                                    (DQ 
                                      (
"!      Dokku remote not added! Do you already have a dokku remote?"
                                      )
                                    )
                                  }
                                )
                                (ControlFlow
                                  token: <ControlFlow_Return return>
                                )
                              ]
                              spids: [1739 1752]
                            )
                          ]
                          spids: [1557 1560 1755 -1]
                        )
                        (case_arm
                          pat_list: [{(apps) (Lit_Other ":") (destroy)}]
                          action: [
                            (AndOr
                              children: [
                                (C {(is_git_repo)})
                                (AndOr
                                  children: [
                                    (C {(has_dokku_remote)})
                                    (C {(git)} {(remote)} {(remove)} {(dokku)})
                                  ]
                                  op_id: Op_DAmp
                                )
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                          spids: [1758 1761 1781 -1]
                        )
                      ]
                      spids: [1548 1554 1784]
                    )
                    (AndOr
                      children: [
                        (DBracket
                          expr: (BoolUnary op_id:BoolUnary_n child:{(DQ ($ VSub_At "$@"))})
                        )
                        (AndOr
                          children: [
                            (DBracket
                              expr: (BoolUnary op_id:BoolUnary_n child:{(DQ ($ VSub_Name "$appname"))})
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:app_arg)
                                  op: Equal
                                  rhs: {(DQ ("--app ") ($ VSub_Name "$appname"))}
                                  spids: [1812]
                                )
                              ]
                              spids: [1812]
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                    (C {(ssh)} {(-o)} {(Lit_VarLike "LogLevel=") (QUIET)} {(-p)} 
                      {($ VSub_Name "$DOKKU_PORT")} {(-t)} {(dokku) (Lit_Other "@") ($ VSub_Name "$DOKKU_HOST")} {(--)} {($ VSub_Name "$app_arg")} 
                      {($ VSub_At "$@")}
                    )
                  ]
                  spids: [1418]
                )
              spids: [1414 1417]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (AndOr
                          children: [
                            (DBracket
                              expr: 
                                (BoolBinary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {(DQ ($ VSub_Number "$0"))}
                                  right: {(DQ (dokku))}
                                )
                            )
                            (AndOr
                              children: [
                                (DBracket
                                  expr: 
                                    (BoolBinary
                                      op_id: BoolBinary_GlobDEqual
                                      left: {(DQ ($ VSub_Number "$0"))}
                                      right: {(Lit_Other "*") (dokku_client.sh)}
                                    )
                                )
                                (DBracket
                                  expr: 
                                    (BoolBinary
                                      op_id: BoolBinary_GlobDEqual
                                      left: {(DQ ($ VSub_Number "$0"))}
                                      right: 
                                        {
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [(C {(which)} {(dokku)})]
                                              )
                                            left_token: <Left_CommandSub "$(">
                                            spids: [1896 1900]
                                          )
                                        }
                                    )
                                )
                              ]
                              op_id: Op_DPipe
                            )
                          ]
                          op_id: Op_DPipe
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [(C {(_dokku)} {(DQ ($ VSub_At "$@"))}) (C {(exit)} {($ VSub_QMark "$?")})]
                  spids: [-1 1905]
                )
              ]
              spids: [-1 1920]
            )
          ]
          spids: [-1 1411]
        )
      ]
      else_action: [(C {(client_help_msg)})]
      spids: [1922 1927]
    )
  ]
)