use std
#use utils.nu taskserv_get_file
#use utils/templates.nu on_template_path

def make_cmd_env_temp [
  defs: record
  taskserv_env_path: string
  wk_vars: string
]: nothing -> string {
  let cmd_env_temp = $"($taskserv_env_path | path join "cmd_env")_(mktemp --tmpdir-path $taskserv_env_path --suffix ".sh" | path basename)"
  ($"export PROVISIONING_VARS=($wk_vars)\nexport PROVISIONING_DEBUG=($env.PROVISIONING_DEBUG)\n" +
    $"export NU_LOG_LEVEL=($env.NU_LOG_LEVEL)\n" +
    $"export PROVISIONING_RESOURCES=($env.PROVISIONING_RESOURCES)\n" +
    $"export PROVISIONING_SETTINGS_SRC=($defs.settings.src)\nexport PROVISIONING_SETTINGS_SRC_PATH=($defs.settings.src_path)\n" +
    $"export PROVISIONING_KLOUD=($defs.settings.infra)\nexport PROVISIONING_KLOUD_PATH=($defs.settings.infra_path)\n" +
    $"export PROVISIONING_USE_SOPS=($env.PROVISIONING_USE_SOPS)\nexport PROVISIONING_WK_ENV_PATH=($taskserv_env_path)\n" +
    $"export SOPS_AGE_KEY_FILE=($env.SOPS_AGE_KEY_FILE)\nexport PROVISIONING_KAGE=($env.PROVISIONING_KAGE)\n" +
    $"export SOPS_AGE_RECIPIENTS=($env.SOPS_AGE_RECIPIENTS)\n"
  ) | save --force $cmd_env_temp
  if $env.PROVISIONING_DEBUG { _print $"cmd_env_temp: ($cmd_env_temp)" }
  $cmd_env_temp
}
def run_cmd [
  cmd_name: string
  title: string
  where: string
  defs: record
  taskserv_env_path: string
  wk_vars: string
]: nothing -> nothing {
  _print (
    $"($title) for (_ansi yellow_bold)($defs.taskserv.name)(_ansi reset) (_ansi default_dimmed)on(_ansi reset) " +
    $"($defs.server.hostname) ($defs.pos.server) ..."
  )
  let runner = (grep "^#!" ($taskserv_env_path | path join $cmd_name) | str trim)
  let run_ops = if $env.PROVISIONING_DEBUG { if ($runner | str contains "bash" ) { "-x" } else { "" } } else { "" }
  let cmd_run_file = make_cmd_env_temp $defs $taskserv_env_path $wk_vars
  if ($cmd_run_file | path exists) and ($wk_vars | path exists) {
    if ($runner | str ends-with "bash" ) {
        $"($run_ops) ($taskserv_env_path | path join $cmd_name) ($wk_vars) ($defs.pos.server) ($defs.pos.taskserv) (^pwd)" | save --append $cmd_run_file
    } else if ($runner | str ends-with "nu" ) {
        $"($env.NU) ($env.NU_ARGS) ($taskserv_env_path | path join $cmd_name)"  | save --append $cmd_run_file
    } else {
        $"($taskserv_env_path | path join $cmd_name) ($wk_vars)" | save --append $cmd_run_file
    }
    let run_res = (^bash $cmd_run_file | complete)
    if $run_res.exit_code != 0 {
      (throw-error $"🛑 Error server ($defs.server.hostname) taskserv ($defs.taskserv.name)
        ($taskserv_env_path)/($cmd_name) with ($wk_vars) ($defs.pos.server) ($defs.pos.taskserv) (^pwd)"
        $"($run_res.stdout)\n($run_res.stderr)\n"
        $where --span (metadata $run_res).span)
      exit 1
    }
    if $env.PROVISIONING_DEBUG {
      if ($run_res.stdout | is-not-empty) { _print $"($run_res.stdout)" }
      if ($run_res.stderr | is-not-empty) { _print $"($run_res.stderr)" }
    } else {
      rm -f $cmd_run_file
      rm -f ($taskserv_env_path | path join "prepare")
    }
  }
}
export def run_taskserv_library [
    defs: record
    taskserv_path: string
    taskserv_env_path: string
    wk_vars: string
]: nothing -> bool {

  if not ($taskserv_path | path exists) { return false }
  let prov_resources_path = ($defs.settings.data.prov_resources_path | default "" | str replace  "~" $env.HOME)
  let taskserv_server_name = $defs.server.hostname
  rm -rf ...(glob ($taskserv_env_path | path join "*.k")) ($taskserv_env_path |path join "kcl")
  mkdir ($taskserv_env_path | path join "kcl")

  let err_out = ($taskserv_env_path | path join (mktemp --tmpdir-path $taskserv_env_path --suffix ".err" | path basename))
  let kcl_temp = ($taskserv_env_path | path join "kcl"| path join (mktemp --tmpdir-path $taskserv_env_path --suffix ".k" | path basename))

  let wk_format = if $env.PROVISIONING_WK_FORMAT == "json" { "json" } else { "yaml" }
  let wk_data = {  # providers: $defs.settings.providers,
    defs: $defs.settings.data,
    pos: $defs.pos,
    server: $defs.server
  }
  if $wk_format == "json" {
    $wk_data | to json | save --force $wk_vars
  } else {
    $wk_data | to yaml | save --force $wk_vars
  }
  if $env.PROVISIONING_USE_KCL {
    cd ($defs.settings.infra_path | path join $defs.settings.infra)
    if ($kcl_temp | path exists) { rm -f $kcl_temp }
    let res = (^kcl import -m $wk_format $wk_vars -o $kcl_temp | complete)
    if $res.exit_code != 0 {
      _print $"❗KCL import (_ansi red_bold)($wk_vars)(_ansi reset) Errors found "
      _print $res.stdout
      rm -f $kcl_temp
      cd $env.PWD
      return false
    }
    # Very important! Remove external block for import and re-format it
    # ^sed -i "s/^{//;s/^}//" $kcl_temp
    open $kcl_temp -r | lines | find -v --regex "^{" | find -v --regex "^}" | save -f $kcl_temp
    let res = (^kcl fmt $kcl_temp | complete)
    let kcl_taskserv_path = if ($taskserv_path | path join "kcl"| path join $"($defs.taskserv.name).k" | path exists) {
      ($taskserv_path | path join "kcl"| path join $"($defs.taskserv.name).k")
    } else  if ($taskserv_path | path dirname | path join "kcl"| path join $"($defs.taskserv.name).k" | path exists)  {
      ($taskserv_path | path dirname | path join "kcl"| path join $"($defs.taskserv.name).k")
    } else  if ($taskserv_path | path dirname | path join "default" | path join "kcl"| path join $"($defs.taskserv.name).k" | path exists)  {
      ($taskserv_path | path dirname | path join "default" | path join "kcl"| path join $"($defs.taskserv.name).k")
    } else { "" }
    if $kcl_taskserv_path != "" and ($kcl_taskserv_path | path exists) {
      if $env.PROVISIONING_DEBUG {
        _print $"adding task name: ($defs.taskserv.name) ->  ($kcl_taskserv_path)"
      }
      cat $kcl_taskserv_path | save --append $kcl_temp
    }
    let kcl_taskserv_profile_path = if ($taskserv_path | path join "kcl"| path join $"($defs.taskserv.profile).k" | path exists) {
      ($taskserv_path | path join "kcl"| path join $"($defs.taskserv.profile).k")
    } else  if ($taskserv_path | path dirname | path join "kcl"| path join $"($defs.taskserv.profile).k" | path exists)  {
      ($taskserv_path | path dirname | path join "kcl"| path join $"($defs.taskserv.profile).k")
    } else  if ($taskserv_path | path dirname | path join "default" | path join "kcl"| path join $"($defs.taskserv.profile).k" | path exists)  {
      ($taskserv_path | path dirname | path join "default" | path join "kcl"| path join $"($defs.taskserv.profile).k")
    } else { "" }
    if $kcl_taskserv_profile_path != "" and ($kcl_taskserv_profile_path | path exists) {
      if $env.PROVISIONING_DEBUG {
        _print $"adding task profile: ($defs.taskserv.profile) ->  ($kcl_taskserv_profile_path)"
      }
      cat $kcl_taskserv_profile_path | save --append $kcl_temp
    }
    if $env.PROVISIONING_KEYS_PATH != "" {
      #use sops on_sops
      let keys_path = ($defs.settings.src_path | path join $env.PROVISIONING_KEYS_PATH)
      if not ($keys_path | path exists) {
        if $env.PROVISIONING_DEBUG {
          _print $"❗Error KEYS_PATH (_ansi red_bold)($keys_path)(_ansi reset) found "
        } else {
          _print $"❗Error (_ansi red_bold)KEYS_PATH(_ansi reset) not found "
        }
        return false
      }
      (on_sops d $keys_path) | save --append $kcl_temp
      let kcl_defined_taskserv_path = if ($defs.settings.src_path | path join "taskservs" | path join $defs.server.hostname | path join $"($defs.taskserv.profile).k" | path exists ) {
        ($defs.settings.src_path | path join "taskservs" | path join $defs.server.hostname | path join $"($defs.taskserv.profile).k")
      } else if ($defs.settings.src_path | path join "taskservs" | path join $defs.server.hostname |  path join $"($defs.taskserv.profile).k" | path exists ) {
        ($defs.settings.src_path | path join "taskservs" | path join $defs.server.hostname | path join $"($defs.taskserv.profile).k")
      } else if ($defs.settings.src_path | path join "taskservs" | path join $"($defs.taskserv.profile).k" | path exists ) {
        ($defs.settings.src_path | path join "taskservs" | path join $"($defs.taskserv.profile).k")
      } else if ($defs.settings.src_path | path join "taskservs" | path join $defs.server.hostname | path join $"($defs.taskserv.name).k" | path exists ) {
        ($defs.settings.src_path | path join "taskservs" | path join $defs.server.hostname | path join $"($defs.taskserv.name).k")
      } else if ($defs.settings.src_path | path join "taskservs" | path join $defs.server.hostname | path join $defs.taskserv.profile |  path join $"($defs.taskserv.name).k" | path exists ) {
        ($defs.settings.src_path | path join "taskservs" | path join $defs.server.hostname | path join $defs.taskserv.profile |  path join $"($defs.taskserv.name).k")
      } else if ($defs.settings.src_path | path join "taskservs"| path join $"($defs.taskserv.name).k" | path exists ) {
        ($defs.settings.src_path | path join "taskservs"| path join $"($defs.taskserv.name).k")
      } else { "" }
      if $kcl_defined_taskserv_path != "" and ($kcl_defined_taskserv_path | path exists) {
        if $env.PROVISIONING_DEBUG {
          _print $"adding defs taskserv: ($kcl_defined_taskserv_path)"
        }
        cat $kcl_defined_taskserv_path | save --append $kcl_temp
      }
      let res = (^kcl $kcl_temp -o $wk_vars | complete)
      if $res.exit_code != 0 {
        _print $"❗KCL errors (_ansi red_bold)($kcl_temp)(_ansi reset) found "
        _print $res.stdout
        _print $res.stderr
        rm -f $wk_vars
        cd $env.PWD
        return false
      }
      rm -f $kcl_temp $err_out
    } else if ( $defs.settings.src_path | path join "taskservs"| path join $"($defs.taskserv.name).yaml" | path exists) {
      cat ($defs.settings.src_path | path join "taskservs"| path join $"($defs.taskserv.name).yaml") | tee { save -a $wk_vars } | ignore
    }
    cd $env.PWD
  }
  (^sed -i $"s/NOW/($env.NOW)/g" $wk_vars)
  if $defs.taskserv_install_mode == "library" {
    let taskserv_data = (open $wk_vars)
    let quiet = if $env.PROVISIONING_DEBUG { false } else { true }
    if $taskserv_data.taskserv? != null and $taskserv_data.taskserv.copy_paths? != null {
      #use utils/files.nu *
      for it in $taskserv_data.taskserv.copy_paths {
        let it_list = ($it | split row "|" | default [])
        let cp_source = ($it_list | get -o 0 | default "")
        let cp_target = ($it_list | get -o 1 | default "")
        if ($cp_source | path exists) {
          copy_prov_files $cp_source "." ($taskserv_env_path | path join $cp_target) false $quiet
        } else if ($prov_resources_path | path join $cp_source | path exists) {
          copy_prov_files $prov_resources_path $cp_source ($taskserv_env_path | path join $cp_target) false $quiet
        } else if ($"($prov_resources_path)/($cp_source)" | path exists) {
          copy_prov_file ($prov_resources_path | path join $cp_source) ($taskserv_env_path | path join $cp_target) $quiet
        }
      }
    }
  }
  rm -f ($taskserv_env_path | path join "kcl") ...(glob $"($taskserv_env_path)/*.k")
  on_template_path $taskserv_env_path $wk_vars true true
  if ($taskserv_env_path | path join $"env-($defs.taskserv.name)" | path exists) {
    ^sed -i 's,\t,,g;s,^ ,,g;/^$/d' ($taskserv_env_path | path join $"env-($defs.taskserv.name)")
  }
  if ($taskserv_env_path | path join "prepare" | path exists) {
    run_cmd "prepare" "prepare" "run_taskserv_library" $defs $taskserv_env_path $wk_vars
    if ($taskserv_env_path | path join "resources" | path exists) {
      on_template_path ($taskserv_env_path | path join "resources") $wk_vars false true
    }
  }
  if not $env.PROVISIONING_DEBUG {
    rm -f ...(glob $"($taskserv_env_path)/*.j2") $err_out $kcl_temp
  }
  true
}
export def run_taskserv [
    defs: record
    taskserv_path: string
    env_path: string
]: nothing -> bool {
  if  not ($taskserv_path | path exists) { return false }
  let prov_resources_path = ($defs.settings.data.prov_resources_path | default "" | str replace  "~" $env.HOME)
  let taskserv_server_name = $defs.server.hostname

  let str_created_taskservs_dirpath = ($defs.settings.data.created_taskservs_dirpath | default "/tmp" |
    str replace "~" $env.HOME | str replace "NOW" $env.NOW | str replace "./" $"($defs.settings.src_path)/")
  let created_taskservs_dirpath = if ($str_created_taskservs_dirpath | str starts-with "/" ) { $str_created_taskservs_dirpath } else { $defs.settings.src_path | path join $str_created_taskservs_dirpath }
  if not ( $created_taskservs_dirpath | path exists) { ^mkdir -p $created_taskservs_dirpath }

  let str_taskserv_env_path = if  $defs.taskserv_install_mode == "server" { $"($env_path)_($defs.taskserv_install_mode)" } else { $env_path }
  let taskserv_env_path = if ($str_taskserv_env_path | str starts-with "/" ) { $str_taskserv_env_path } else { $defs.settings.src_path | path join $str_taskserv_env_path }
  if not ( $taskserv_env_path | path exists) { ^mkdir -p $taskserv_env_path }

  (^cp -pr ...(glob ($taskserv_path | path join "*")) $taskserv_env_path)
  rm -rf ...(glob ($taskserv_env_path | path join "*.k"))  ($taskserv_env_path | path join "kcl")

  let wk_vars = ($created_taskservs_dirpath | path join $"($defs.server.hostname).yaml")
  let require_j2 = (^ls ...(glob ($taskserv_env_path | path join "*.j2")) err> (if $nu.os-info.name == "windows" { "NUL" } else { "/dev/null" }))

  let res = if  $defs.taskserv_install_mode == "library" or $require_j2 != "" {
    (run_taskserv_library $defs $taskserv_path $taskserv_env_path $wk_vars)
  }
  if not $res {
    if not $env.PROVISIONING_DEBUG { rm -f $wk_vars }
    return $res
  }
  let err_out = ($env_path | path join (mktemp --tmpdir-path $env_path --suffix ".err") | path basename)
  let tar_ops = if $env.PROVISIONING_DEBUG { "v" } else { "" }
  let bash_ops = if $env.PROVISIONING_DEBUG { "bash -x" } else { "" }

  let res_tar = (^tar -C $taskserv_env_path $"-c($tar_ops)zmf" (["/tmp" $"($defs.taskserv.name).tar.gz"] | path join) . | complete)
  if $res_tar.exit_code != 0 {
    _print (
      $"🛑 Error (_ansi red_bold)tar taskserv(_ansi reset) server (_ansi green_bold)($defs.server.hostname)(_ansi reset)" +
      $"  taskserv (_ansi yellow_bold)($defs.taskserv.name)(_ansi reset) ($taskserv_env_path) -> (['/tmp' $'($defs.taskserv.name).tar.gz'] | path join)"
    )
    return false
  }
  if $defs.check {
    if not $env.PROVISIONING_DEBUG {
      rm -f $wk_vars
      if $err_out != "" { rm -f $err_out }
      rm -rf ...(glob $"($taskserv_env_path)/*.k") ($taskserv_env_path | path join join "kcl")
    }
    return true
  }
  let is_local  = (^ip addr | grep "inet " | grep "$defs.ip")
  if $is_local != "" and not $env.PROVISIONING_DEBUG_CHECK {
    if $defs.taskserv_install_mode ==  "getfile" {
      if (taskserv_get_file $defs.settings $defs.taskserv $defs.server $defs.ip true true) { return false }
      return true
    }
    rm -rf (["/tmp" $defs.taskserv.name ] | path join)
    mkdir (["/tmp" $defs.taskserv.name ] | path join)
    cd (["/tmp" $defs.taskserv.name ] | path join)
    tar x($tar_ops)zmf (["/tmp" $"($defs.taskserv.name).tar.gz"] | path join)
    let res_run = (^sudo $bash_ops $"./install-($defs.taskserv.name).sh" err> $err_out  | complete)
    if $res_run.exit_code != 0 {
      (throw-error $"🛑 Error server ($defs.server.hostname) taskserv ($defs.taskserv.name)
          ./install-($defs.taskserv.name).sh ($defs.server_pos) ($defs.taskserv_pos) (^pwd)"
          $"($res_run.stdout)\n(cat $err_out)"
          "run_taskserv_library" --span (metadata $res_run).span)
      exit 1
    }
    fi
    rm -fr (["/tmp" $"($defs.taskserv.name).tar.gz"] | path join) (["/tmp" $"($defs.taskserv.name)"] | path join)
  } else {
    if $defs.taskserv_install_mode == "getfile" {
      if (taskserv_get_file $defs.settings $defs.taskserv $defs.server $defs.ip true false) { return false }
      return true
    }
    if not $env.PROVISIONING_DEBUG_CHECK {
      #use ssh.nu *
      let scp_list: list<string> = ([] | append $"/tmp/($defs.taskserv.name).tar.gz")
      if not (scp_to $defs.settings $defs.server $scp_list "/tmp" $defs.ip) {
        _print (
          $"🛑 Error (_ansi red_bold)ssh_to(_ansi reset) server (_ansi green_bold)($defs.server.hostname)(_ansi reset) [($defs.ip)] " +
          $"  taskserv (_ansi yellow_bold)($defs.taskserv.name)(_ansi reset) /tmp/($defs.taskserv.name).tar.gz"
        )
        return false
      }
      #    $"rm -rf /tmp/($defs.taskserv.name); mkdir -p /tmp/($defs.taskserv.name) ;" +
      let run_ops = if $env.PROVISIONING_DEBUG { "bash -x" } else { "" }
      let cmd = (
          $"rm -rf /tmp/($defs.taskserv.name); mkdir -p /tmp/($defs.taskserv.name) ;" +
          $" cd /tmp/($defs.taskserv.name) ; sudo tar x($tar_ops)zmf /tmp/($defs.taskserv.name).tar.gz &&" +
          $" sudo ($run_ops) ./install-($defs.taskserv.name).sh "  # ($env.PROVISIONING_MATCH_CMD) "
      )
      if not (ssh_cmd $defs.settings $defs.server false $cmd $defs.ip) {
        _print (
          $"🛑 Error (_ansi red_bold)ssh_cmd(_ansi reset) server (_ansi green_bold)($defs.server.hostname)(_ansi reset) [($defs.ip)] " +
          $"  taskserv (_ansi yellow_bold)($defs.taskserv.name)(_ansi reset) install_($defs.taskserv.name).sh"
        )
        return false
      }
      if not $env.PROVISIONING_DEBUG {
        let rm_cmd = $"sudo rm -f /tmp/($defs.taskserv.name).tar.gz; sudo rm -rf /tmp/($defs.taskserv.name)"
        let _res = (ssh_cmd $defs.settings $defs.server false $rm_cmd $defs.ip)
        rm -f $"/tmp/($defs.taskserv.name).tar.gz"
      }
    }
  }
  if ($taskserv_path | path join "postrun" | path exists ) {
    cp ($taskserv_path | path join "postrun") ($taskserv_env_path | path join "postrun")
    run_cmd "postrun" "PostRune" "run_taskserv_library" $defs $taskserv_env_path $wk_vars
  }
  if not $env.PROVISIONING_DEBUG {
    rm -f $wk_vars
    if $err_out != "" { rm -f $err_out }
    rm -rf ...(glob $"($taskserv_env_path)/*.k") ($taskserv_env_path | path join join "kcl")
  }
  true
}