#!/bin/bash
# Exit immediately if anything goes wrong, instead of making things worse.
set -e

source $REPO_ROOT/bootstrap/shared/shared_functions.sh

################################################################################
# Function to remove VirtualBox DHCP servers
# By default, checks for any DHCP server on networks without VM's & removes them
# (expecting if a remove fails the function should bail)
# If a network is provided, removes that network's DHCP server
# (or passes the vboxmanage error and return code up to the caller)
# 
proc remove_DHCPservers {
  var network_name = $(1-)
  if [[ -z "$network_name" ]] {
    # make a list of VM UUID's
    var vms = $[VBoxManage list vms|sed 's/^.*{\([0-9a-f-]*\)}/\1/]
    # make a list of networks (e.g. "vboxnet0 vboxnet1")
    var vm_networks = $[for vm in [$vms] { \
      VBoxManage showvminfo --details --machinereadable $vm | \
      grep -i '^hostonlyadapter[2-9]=' | \
      sed -e 's/^.*=//' -e 's/"//g'; \
    } | sort -u]
    # will produce a regular expression string of networks which are in use by VMs
    # (e.g. ^vboxnet0$|^vboxnet1$)
    var existing_nets_reg_ex = $[sed -e 's/^/^/' -e 's/$/$/' -e 's/ /$|^/g' <<< $vm_networks]

    VBoxManage list dhcpservers | grep -E "^NetworkName:\s+HostInterfaceNetworking" | awk '{print $2}' |
    while read -r network_name {
      [[ -n $existing_nets_reg_ex ]] && ! egrep -q $existing_nets_reg_ex <<< $network_name && continue
      remove_DHCPservers $network_name
    }
  } else {
    VBoxManage dhcpserver remove --netname $network_name && var return = '0' || var return = $Status
    return $return
  }
}

###################################################################
# Function to create all VMs using Vagrant
proc create_vagrant_vms {
  cd $REPO_ROOT/bootstrap/vagrant_scripts && vagrant up
}

# only execute functions if being run and not sourced
if [[ "${BASH_SOURCE[0]}" == "${0}" ]] {
  remove_DHCPservers
  create_vagrant_vms
}
(CommandList
  children: [
    (C {(set)} {(-e)})
    (C {(.)} {($ VSub_Name "$REPO_ROOT") (/bootstrap/shared/shared_functions.sh)})
    (FuncDef
      name: remove_DHCPservers
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:network_name)
                  op: Equal
                  rhs: 
                    {
                      (BracedVarSub
                        token: <VSub_Number 1>
                        suffix_op: (StringUnary op_id:VTest_Hyphen arg_word:{})
                        spids: [48 51]
                      )
                    }
                  spids: [47]
                )
              ]
              spids: [45]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: (BoolUnary op_id:BoolUnary_z child:{(DQ ($ VSub_Name "$network_name"))})
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_Local
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:vms)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (Pipeline
                                        children: [
                                          (C {(VBoxManage)} {(list)} {(vms)})
                                          (C {(sed)} {(SQ <"s/^.*{\\([0-9a-f-]*\\)}/\\1/">)})
                                        ]
                                        negated: False
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [77 89]
                              )
                            }
                          spids: [76]
                        )
                      ]
                      spids: [74]
                    )
                    (Assignment
                      keyword: Assign_Local
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:vm_networks)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (Pipeline
                                        children: [
                                          (ForEach
                                            iter_name: vm
                                            iter_words: [{($ VSub_Name "$vms")}]
                                            do_arg_iter: False
                                            body: 
                                              (DoGroup
                                                children: [
                                                  (Sentence
                                                    child: 
                                                      (Pipeline
                                                        children: [
                                                          (C {(VBoxManage)} {(showvminfo)} {(--details)} 
                                                            {(--machinereadable)} {($ VSub_Name "$vm")}
                                                          )
                                                          (C {(grep)} {(-i)} 
                                                            {(SQ <"^hostonlyadapter[2-9]=">)}
                                                          )
                                                          (C {(sed)} {(-e)} {(SQ <"s/^.*=//">)} {(-e)} 
                                                            {(SQ <"s/\"//g">)}
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    terminator: <Op_Semi ";">
                                                  )
                                                ]
                                                spids: [109 156]
                                              )
                                            spids: [105 107]
                                          )
                                          (C {(sort)} {(-u)})
                                        ]
                                        negated: False
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [99 163]
                              )
                            }
                          spids: [98]
                        )
                      ]
                      spids: [96]
                    )
                    (Assignment
                      keyword: Assign_Local
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:existing_nets_reg_ex)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (SimpleCommand
                                        words: [
                                          {(sed)}
                                          {(-e)}
                                          {(SQ <"s/^/^/">)}
                                          {(-e)}
                                          {(SQ <"s/$/$/">)}
                                          {(-e)}
                                          {(SQ <"s/ /$|^/g">)}
                                        ]
                                        redirects: [
                                          (Redir
                                            op_id: Redir_TLess
                                            fd: -1
                                            arg_word: {(DQ ($ VSub_Name "$vm_networks"))}
                                            spids: [198]
                                          )
                                        ]
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [177 203]
                              )
                            }
                          spids: [176]
                        )
                      ]
                      spids: [174]
                    )
                    (Pipeline
                      children: [
                        (C {(VBoxManage)} {(list)} {(dhcpservers)})
                        (C {(grep)} {(-E)} 
                          {
                            (DQ ("^NetworkName:") (EscapedLiteralPart token:<Lit_EscapedChar "\\s">) 
                              ("+HostInterfaceNetworking")
                            )
                          }
                        )
                        (C {(awk)} {(SQ <"{print $2}">)})
                        (While
                          cond: [
                            (Sentence
                              child: (C {(read)} {(-r)} {(network_name)})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          body: 
                            (DoGroup
                              children: [
                                (AndOr
                                  children: [
                                    (DBracket
                                      expr: 
                                        (BoolUnary
                                          op_id: BoolUnary_n
                                          child: {($ VSub_Name "$existing_nets_reg_ex")}
                                        )
                                    )
                                    (AndOr
                                      children: [
                                        (Pipeline
                                          children: [
                                            (SimpleCommand
                                              words: [
                                                {(egrep)}
                                                {(-q)}
                                                {(DQ ($ VSub_Name "$existing_nets_reg_ex"))}
                                              ]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_TLess
                                                  fd: -1
                                                  arg_word: {($ VSub_Name "$network_name")}
                                                  spids: [268]
                                                )
                                              ]
                                            )
                                          ]
                                          negated: True
                                        )
                                        (ControlFlow
                                          token: <ControlFlow_Continue continue>
                                        )
                                      ]
                                      op_id: Op_DAmp
                                    )
                                  ]
                                  op_id: Op_DAmp
                                )
                                (C {(remove_DHCPservers)} {($ VSub_Name "$network_name")})
                              ]
                              spids: [245 282]
                            )
                        )
                      ]
                      negated: False
                    )
                  ]
                  spids: [-1 67]
                )
              ]
              else_action: [
                (AndOr
                  children: [
                    (C {(VBoxManage)} {(dhcpserver)} {(remove)} {(--netname)} 
                      {(DQ ($ VSub_Name "$network_name"))}
                    )
                    (AndOr
                      children: [
                        (Assignment
                          keyword: Assign_Local
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:return)
                              op: Equal
                              rhs: {(0)}
                              spids: [304]
                            )
                          ]
                          spids: [302]
                        )
                        (Assignment
                          keyword: Assign_Local
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:return)
                              op: Equal
                              rhs: {($ VSub_QMark "$?")}
                              spids: [311]
                            )
                          ]
                          spids: [309]
                        )
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  op_id: Op_DAmp
                )
                (ControlFlow
                  token: <ControlFlow_Return return>
                  arg_word: {($ VSub_Name "$return")}
                )
              ]
              spids: [285 320]
            )
          ]
          spids: [42]
        )
      spids: [38 41]
    )
    (FuncDef
      name: create_vagrant_vms
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(cd)} {($ VSub_Name "$REPO_ROOT") (/bootstrap/vagrant_scripts)})
                (C {(vagrant)} {(up)})
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [335]
        )
      spids: [331 334]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (DBracket
                  expr: 
                    (BoolBinary
                      op_id: BoolBinary_GlobDEqual
                      left: 
                        {
                          (DQ 
                            (BracedVarSub
                              token: <VSub_Name BASH_SOURCE>
                              bracket_op: (ArrayIndex expr:(ArithWord w:{(Lit_Digits 0)}))
                              spids: [360 365]
                            )
                          )
                        }
                      right: {(DQ (${ VSub_Number 0))}
                    )
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [(C {(remove_DHCPservers)}) (C {(create_vagrant_vms)})]
          spids: [-1 379]
        )
      ]
      spids: [-1 387]
    )
  ]
)