# Module: System Initialization
# Purpose: Handles system initialization, environment setup, and workspace initialization.
# Dependencies: error, interface, config/accessor


use ../config/accessor.nu *

# Get the complete provisioning command arguments as a string
export def get-provisioning-args [] : nothing -> string {
    $env.PROVISIONING_ARGS? | default ""
}

# Get the provisioning command name
export def get-provisioning-name [] : nothing -> string {
    $env.PROVISIONING_NAME? | default "provisioning"
}

# Get the provisioning infrastructure path
export def get-provisioning-infra-path [] : nothing -> string {
    $env.PROVISIONING_INFRA_PATH? | default ""
}

# Get the provisioning resources path
export def get-provisioning-resources [] : nothing -> string {
    $env.PROVISIONING_RESOURCES? | default ""
}

# Get the provisioning URL
export def get-provisioning-url [] : nothing -> string {
    $env.PROVISIONING_URL? | default "https://provisioning.systems"
}

# Get whether SOPS encryption is enabled
export def get-provisioning-use-sops [] : nothing -> string {
    $env.PROVISIONING_USE_SOPS? | default ""
}

# Get the effective workspace
export def get-effective-workspace [] : nothing -> string {
    $env.CURRENT_WORKSPACE? | default "default"
}

# Get workspace path (defaults to effective workspace if not provided)
export def get-workspace-path [workspace?: string] : nothing -> string {
    let ws = if ($workspace | is-empty) {
        (get-effective-workspace)
    } else {
        $workspace
    }
    let ws_base = ($env.PROVISIONING_WORKSPACES? | default "")
    if ($ws_base | is-not-empty) {
        $ws_base | path join $ws
    } else {
        ""
    }
}

# Detect infrastructure from PWD
export def detect-infra-from-pwd [] : nothing -> string {
    ""
}

# Get work format (Nickel is the default post-migration)
export def get-work-format [] : nothing -> string {
    $env.PROVISIONING_WORK_FORMAT? | default "ncl"
}

export def show_titles [] {
  # Check if titles are disabled
  if ($env.PROVISIONING_NO_TITLES? | default false) { return }
  if ($env.PROVISIONING_OUT? | is-not-empty) { return }
  if ($env.PROVISIONING_TITLES_SHOWN? | default false) { return }

  # Mark as shown to prevent duplicates
  $env.PROVISIONING_TITLES_SHOWN = true

  # Find ascii.txt from PROVISIONING_RESOURCES or PROVISIONING directory
  let ascii_file = (
    if ($env.PROVISIONING_RESOURCES? | is-not-empty) {
      ($env.PROVISIONING_RESOURCES | path join "ascii.txt")
    } else if ($env.PROVISIONING? | is-not-empty) {
      ($env.PROVISIONING | path join "resources" | path join "ascii.txt")
    } else {
      ""
    }
  )

  # Display if file exists
  if ($ascii_file | is-not-empty) and ($ascii_file | path exists) {
    print $"(ansi blue_bold)(open -r $ascii_file)(ansi reset)"
  }
}
export def use_titles [ ] {
  if ($env.PROVISIONING_NO_TITLES? | default false) { return false }
  if ($env.PROVISIONING_NO_TERMINAL? | default false) { return false }
  let args = ($env.PROVISIONING_ARGS? | default "")
  if ($args | is-not-empty) and ($args | str contains "-h" ) { return false }
  if ($args | is-not-empty) and ($args | str contains "--notitles" ) { return false }
  if ($args | is-not-empty) and ($args | str contains "query") and ($args | str contains "-o" ) { return false }
  true
}
export def provisioning_init [
  helpinfo: bool
  module: string
  args: list<string>  # Other options, use help to get info
] {
  if (use_titles) { show_titles }
  if $helpinfo != null and $helpinfo {
    let cmd_line: list<string> = if ($args| length) == 0 {
        $args | str join " "
    } else {
        ($env.PROVISIONING_ARGS? | default "")
    }
    let cmd_args: list<string> = ($cmd_line | str replace "--helpinfo" "" |
       str replace "-h"  "" | str replace $module "" | str trim | split  row " "
    )
    if ($cmd_args | length) > 0 {
        # Refactored from try-catch to do/complete for explicit error handling
        let str_mod_0_result = (do { $cmd_args | get 0 } | complete)
        let str_mod_0 = if $str_mod_0_result.exit_code == 0 { ($str_mod_0_result.stdout | str trim) } else { "" }

        let str_mod_1_result = (do { $cmd_args | get 1 } | complete)
        let str_mod_1 = if $str_mod_1_result.exit_code == 0 { ($str_mod_1_result.stdout | str trim) } else { "" }

        if $str_mod_1 != "" {
            let final_args = ($cmd_args | drop nth 0 1)
            ^$"((get-provisioning-name))" "-mod" $"'($str_mod_0) ($str_mod_1)'" ...$final_args help
        } else if $str_mod_0 != "" {
            let final_args = ($cmd_args | drop nth 0)
            ^$"((get-provisioning-name))" "-mod" ($str_mod_0) ...$final_args help
        } else {
            ^$"((get-provisioning-name))" "-mod" $"($module | str replace ' ' '|')" ...$cmd_args help
        }
    } else {
      ^$"((get-provisioning-name))" help
    }
    exit 0
  }
}