use utils *

export def clip_copy [
  msg: string
  show: bool
]: nothing -> nothing {
  if ( (version).installed_plugins | str contains "clipboard" ) {
    $msg | clipboard copy
    print $"(_ansi default_dimmed)copied into clipboard now (_ansi reset)"
  } else {
    if (not $show) { _print $msg }
  }
}

export def notify_msg [
    title: string
    body: string
    icon: string
    time_body: string
    timeout: duration
    task?: closure
]: nothing -> nothing {
  if ( (version).installed_plugins | str contains "desktop_notifications" ) {
    if $task != null {
      ( notify -s $title -t $time_body --timeout $timeout -i $icon)
    } else {
      ( notify -s $title -t $body --timeout $timeout -i $icon)
    }
  } else {
    if $task != null {
      _print (
        $"(_ansi blue)($title)(_ansi reset)\n(ansi blue_bold)($time_body)(_ansi reset)"
      )
    } else {
      _print (
        $"(_ansi blue)($title)(_ansi reset)\n(ansi blue_bold)($body)(_ansi reset)"
      )
    }
  }
}

export def show_qr  [
  url: string
]: nothing -> nothing {
  if ( (version).installed_plugins | str contains "qr_maker" ) {
    print $"(_ansi blue_reverse)( $url | to qr )(_ansi reset)"
  } else {
    let qr_path = ($env.PROVISIONING_RESOURCES | path join "qrs" | path join ($url | path basename))
    if ($qr_path | path exists) {
      _print (open -r $qr_path)
    } else {
      _print $"(_ansi blue_reverse)( $url)(_ansi reset)"
      _print $"(_ansi purple)($url)(_ansi reset)"
    }
  }
}

export def port_scan [
  ip: string
  port: int
  sec_timeout: int
]: nothing -> bool {
  let wait_duration = ($"($sec_timeout)sec"| into duration)
  if ( (version).installed_plugins | str contains "port_scan" ) {
    (port scan $ip $port -t $wait_duration).is_open
  } else {
    (^nc -zv -w $sec_timeout ($ip | str trim) $port err> (if $nu.os-info.name == "windows" { "NUL" } else { "/dev/null" }) | complete).exit_code == 0
  }
}

export def render_template [
  template_path: string
  vars: record
  --ai_prompt: string
]: nothing -> string {
  # Regular template rendering
  if ( (version).installed_plugins | str contains "tera" ) {
    $vars | tera-render $template_path
  } else {
    error make { msg: "nu_plugin_tera not available - template rendering not supported" }
  }
}

export def render_template_ai [
  ai_prompt: string
  template_type: string = "template"
]: nothing -> string {
  use ai/lib.nu *
  ai_generate_template $ai_prompt $template_type
}

export def process_kcl_file [
  kcl_file: string
  format: string
  settings?: record
]: nothing -> string {
  # Try nu_plugin_kcl first if available
    if ( (version).installed_plugins | str contains "kcl" ) {
        if $settings != null {
            let settings_json = ($settings | to json)
            #kcl-run $kcl_file -Y $settings_json
            let result = (^kcl run $kcl_file --setting $settings_json --format $format | complete)
            if $result.exit_code == 0 { $result.stdout } else { error make { msg: $result.stderr } }
        } else {
            kcl-run $kcl_file -f $format
            #kcl-run $kcl_file -Y $settings_json
        }
    } else {
        # Use external KCL CLI
        if $env.PROVISIONING_USE_KCL {
            if $settings != null {
                let settings_json = ($settings | to json)
                let result = (^kcl run $kcl_file --setting $settings_json --format $format | complete)
                if $result.exit_code == 0 { $result.stdout } else { error make { msg: $result.stderr } }
            } else {
                let result = (^kcl run $kcl_file --format $format | complete)
                if $result.exit_code == 0 { $result.stdout } else { error make { msg: $result.stderr } }
            }

        } else {
            error make { msg: "Neither nu_plugin_kcl nor external KCL CLI available" }
        }
    }
}

export def validate_kcl_schema [
  kcl_file: string
  data: record
]: nothing -> bool {
  # Try nu_plugin_kcl first if available
  if ( (version).installed_plugins | str contains "nu_plugin_kcl" ) {
  kcl validate $kcl_file --data ($data | to json) catch {
      # Fallback to external KCL CLI
      if $env.PROVISIONING_USE_KCL {
        let data_json = ($data | to json)
        let data_json = ($data | to json)
        let result = (^kcl validate $kcl_file --data ($data | to json) | complete)
        $result.exit_code == 0
      } else {
        false
      }
    }
  } else {
    # Use external KCL CLI
    if $env.PROVISIONING_USE_KCL {
      let data_json = ($data | to json)
      let result = (^kcl validate $kcl_file --data $data_json | complete)
      $result.exit_code == 0
    } else {
      false
    }
  }
}
