use ../lib_provisioning/config/accessor.nu *
use ../lib_provisioning/utils/logging.nu *

# Create infrastructure and services with enhanced validation and logging
export def "main create" [
  target?: string      # server (s) | taskserv (t) | cluster (c)
  name?: string       # Target name in settings
  ...args                 # Args for create command
  --serverpos (-p): int   # Server position in settings
  --check (-c)            # Only check mode no servers will be created
  --wait (-w)             # Wait servers to be created
  --infra (-i): string    # Infra path
  --settings (-s): string # Settings path
  --outfile (-o): string  # Output file
  --debug (-x)            # Use Debug mode
  --xm             # Debug with PROVISIONING_METADATA
  --xc             # Debug for task and services locally PROVISIONING_DEBUG_CHECK
  --xr             # Debug for remote servers PROVISIONING_DEBUG_REMOTE
  --xld            # Log level with DEBUG PROVISIONING_LOG_LEVEL=debug
  --metadata       # Error with metadata (-xm)
  --notitles       # not titles
  --out: string    # Print Output format: json, yaml, text (default)
  --dry-run        # Show what would be done without executing
  --verbose (-v)   # Verbose output with enhanced logging
]: nothing -> nothing {

  # Enhanced validation and logging
  if ($target | is-empty) {
    log-error "Target parameter is required" "create"
    print "💡 Valid targets: server(s), taskserv(t), cluster(cl)"
    print "💡 Example: provisioning create server my-server"
    return
  }

  # Validate target value with enhanced error messages
  let valid_targets = ["server", "servers", "s", "taskserv", "taskservs", "task", "tasks", "t", "clusters", "cluster", "cl"]
  let is_valid_target = ($valid_targets | where {|t| $t == $target} | length) > 0

  if not $is_valid_target {
    log-error $"Invalid target: ($target)" "create"
    print $"💡 Valid targets: ($valid_targets | str join ', ')"
    return
  }

  # Enhanced output handling
  if ($out | is-not-empty) {
    $env.PROVISIONING_OUT = $out
    $env.PROVISIONING_NO_TERMINAL = true
    if $verbose { log-info $"Output format set to: ($out)" "create" }
  }

  if ($outfile | is-not-empty) {
    $env.PROVISIONING_OUT = $outfile
    $env.PROVISIONING_NO_TERMINAL = true
    if $verbose { log-info $"Output file set to: ($outfile)" "create" }
  }

  # Enhanced debug mode with logging
  if $debug {
    $env.PROVISIONING_DEBUG = true
    if $verbose { log-debug "Debug mode enabled" "create" }
  }
  let use_debug = if $debug or (is-debug-enabled) { "-x" } else { "" }

  # Validate settings path if provided
  if ($settings | is-not-empty) {
    if not ($settings | path exists) {
      log-error $"Settings file not found: ($settings)" "create"
      return
    }
    if $verbose { log-info $"Using settings: ($settings)" "create" }
  }

  # Validate infra path if provided
  if ($infra | is-not-empty) {
    if not ($infra | path exists) {
      log-error $"Infra path not found: ($infra)" "create"
      return
    }
    if $verbose { log-info $"Using infra: ($infra)" "create" }
  }

  # Enhanced operation logging
  if $verbose {
    log-section $"Creating ($target)" "create"
    log-info $"Target: ($target)" "create"
    log-info $"Name: ($name | default 'default')" "create"

    if $dry_run {
      log-warning "DRY RUN MODE - No actual changes will be made" "create"
    }
  }

  # Execute the appropriate creation command with enhanced error handling
  let result = (do {
    match $target {
      "server"| "servers" | "s" => {
        if $verbose { log-subsection "Creating server" "create" }
        if $dry_run {
          log-info "Would execute: server creation command" "create"
        } else {
          ^$"((get-provisioning-name))" $use_debug -mod "server" ($env.PROVISIONING_ARGS? | default "" | str replace $target '') --notitles
        }
      },
      "taskserv" | "taskservs" | "task" | "tasks" | "t" => {
        let ops = ($env.PROVISIONING_ARGS? | default "" | split row " ")
        let task = ($ops | get -o 0 | default "")
        if $verbose { log-subsection $"Creating taskserv: ($task)" "create" }
        if $dry_run {
          log-info $"Would execute: taskserv creation for task ($task)" "create"
        } else {
          ^$"((get-provisioning-name))" $use_debug -mod "taskserv" $task ($env.PROVISIONING_ARGS? | default "" | str replace $"($task) ($target)" '') --notitles
        }
      },
      "clusters"| "cluster" | "cl" => {
        if $verbose { log-subsection "Creating cluster" "create" }
        if $dry_run {
          log-info "Would execute: cluster creation command" "create"
        } else {
          ^$"((get-provisioning-name))" $use_debug -mod "cluster" ($env.PROVISIONING_ARGS? | default "" | str replace $target '') --notitles
        }
      }
    }
  } | complete)

  if $result.exit_code != 0 {
    log-error $"Failed to create ($target)" "create" $result.stderr
  } else {
    if not $dry_run and $verbose {
      log-success $"Successfully created ($target)" "create"
    } else if $dry_run and $verbose {
      log-success "Dry run completed successfully" "create"
    }
  }
}

# Enhanced helper function to validate server configuration
export def validate-server-config [
    server_config: record
]: nothing -> bool {
    let required_fields = ["hostname", "ip", "provider"]
    let missing_fields = ($required_fields | where {|field|
        ($server_config | get -o $field | is-empty)
    })

    if ($missing_fields | length) > 0 {
        log-error "Missing required server configuration fields" "validation"
        $missing_fields | each {|field|
            print $"  - ($field)"
        }
        return false
    }

    log-success "Server configuration is valid" "validation"
    true
}

# Enhanced helper function to show creation progress
export def show-creation-progress [
    current: int
    total: int
    operation: string
]: nothing -> nothing {
    let percent = (($current * 100) / $total | into int)
    log-progress $operation $percent "progress"
}