# Configuration Command Handlers
# Handles: env, allenv, show, init, validate, config-template commands

use ../flags.nu *
use ../../lib_provisioning *

# Main configuration command dispatcher
export def handle_config_command [
  command: string
  ops: string
  flags: record
] {
  match $command {
    "env" | "e" => { handle_env $ops $flags }
    "allenv" => { handle_allenv $flags }
    "show" => { handle_show $ops $flags }
    "init" => { handle_init $ops $flags }
    "validate" | "val" => { handle_validate $ops $flags }
    "config-template" => { handle_config_template $ops $flags }
    _ => {
      print $"❌ Unknown configuration command: ($command)"
      exit 1
    }
  }
}

# Environment command handler
def handle_env [ops: string, flags: record] {
  let subcmd = ($ops | split row " " | get -o 0 | default "")

  if $subcmd in ["list" "current" "switch" "validate" "compare" "show"
                  "init" "detect" "set" "paths" "create" "delete" "export" "status"] {
    # Use new environment management system
    use ../../lib_provisioning/cmd/environment.nu *

    match $subcmd {
      "list" => { env list }
      "current" => { env current }
      "switch" => {
        let target_env = ($ops | split row " " | get -o 1 | default "")
        if ($target_env | is-empty) {
          print "Usage: env switch <environment>"
          exit 1
        }
        env switch $target_env
      }
      "validate" => {
        let target_env = ($ops | split row " " | get -o 1 | default "")
        env validate $target_env
      }
      "compare" => {
        let env1 = ($ops | split row " " | get -o 1 | default "")
        let env2 = ($ops | split row " " | get -o 2 | default "")
        if ($env1 | is-empty) or ($env2 | is-empty) {
          print "Usage: env compare <env1> <env2>"
          exit 1
        }
        env compare $env1 $env2
      }
      "show" => {
        let target_env = ($ops | split row " " | get -o 1 | default "")
        env show $target_env
      }
      "init" => {
        let target_env = ($ops | split row " " | get -o 1 | default "")
        if ($target_env | is-empty) {
          print "Usage: env init <environment>"
          exit 1
        }
        env init $target_env
      }
      "detect" => { env detect }
      "set" => {
        let target_env = ($ops | split row " " | get -o 1 | default "")
        if ($target_env | is-empty) {
          print "Usage: env set <environment>"
          exit 1
        }
        env set $target_env
      }
      "paths" => {
        let target_env = ($ops | split row " " | get -o 1 | default "")
        env paths $target_env
      }
      "create" => {
        let target_env = ($ops | split row " " | get -o 1 | default "")
        if ($target_env | is-empty) {
          print "Usage: env create <environment>"
          exit 1
        }
        env create $target_env
      }
      "delete" => {
        let target_env = ($ops | split row " " | get -o 1 | default "")
        if ($target_env | is-empty) {
          print "Usage: env delete <environment>"
          exit 1
        }
        env delete $target_env
      }
      "export" => {
        let target_env = ($ops | split row " " | get -o 1 | default "")
        env export $target_env
      }
      "status" => {
        let target_env = ($ops | split row " " | get -o 1 | default "")
        env status $target_env
      }
      _ => {
        print "Environment Management Commands:"
        print "  env list              - List available environments"
        print "  env current           - Show current environment"
        print "  env switch <env>      - Switch to environment"
        print "  env validate [env]    - Validate environment"
        print "  env compare <e1> <e2> - Compare environments"
        print "  env show [env]        - Show environment config"
        print "  env init <env>        - Initialize environment"
        print "  env detect            - Detect current environment"
        print "  env set <env>         - Set environment variable"
        print "  env paths [env]       - Show environment paths"
        print "  env create <env>      - Create new environment"
        print "  env delete <env>      - Delete environment"
        print "  env export [env]      - Export environment config"
        print "  env status [env]      - Show environment status"
      }
    }
  } else {
    # Fall back to legacy environment display
    match $flags.output_format {
      "json" => { _print (show_env | to json) "json" "result" "table" }
      "yaml" => { _print (show_env | to yaml) "yaml" "result" "table" }
      "toml" => { _print (show_env | to toml) "toml" "result" "table" }
      _ => { print (show_env | table -e) }
    }
  }
}

# All environment command handler
def handle_allenv [flags: record] {
  let all_env = {
    env: (show_env),
    providers: (on_list "providers" "-" ""),
    taskservs: (on_list "taskservs" "-" ""),
    clusters: (on_list "clusters" "-" ""),
    infras: (on_list "infras" "-" ""),
    itemdefs: {
      providers: (find_provgendefs),
      taskserv: (
        open ($env.PROVISIONING_TASKSERVS_PATH | path join $env.PROVISIONING_GENERATE_DIRPATH | path join $env.PROVISIONING_GENERATE_DEFSFILE)
      )
    }
  }

  if $flags.view_mode {
    match $flags.output_format {
      "json" => { $all_env | to json | highlight }
      "yaml" => { $all_env | to yaml | highlight }
      "toml" => { $all_env | to toml | highlight }
      _ => { $all_env | to json | highlight }
    }
  } else {
    match $flags.output_format {
      "json" => { _print ($all_env | to json) "json" "result" "table" }
      "yaml" => { _print ($all_env | to yaml) "yaml" "result" "table" }
      "toml" => { _print ($all_env | to toml) "toml" "result" "table" }
      _ => { print ($all_env | to json) }
    }
  }
}

# Show command handler (extracted from main provisioning file)
def handle_show [ops: string, flags: record] {
  let target = ($ops | split row " " | get -o 0 | default "")

  match $target {
    "h" | "help" => {
      print (provisioning_show_options)
      exit
    }
  }

  let curr_settings = (find_get_settings --infra $flags.infra --settings $flags.settings $flags.include_notuse)

  if ($curr_settings | is-empty) {
    if ($flags.output_format | is-empty) {
      _print $"🛑 Errors found in infra (_ansi yellow_bold)($flags.infra)(_ansi reset) notuse ($flags.include_notuse)"
      print ($curr_settings | describe)
      print $flags.settings
    }
    exit
  }

  let show_info = (get_show_info ($ops | split row " ") $curr_settings ($flags.output_format | default ""))

  if $flags.view_mode {
    match $flags.output_format {
      "json" => { print ($show_info | to json | highlight json) }
      "yaml" => { print ($show_info | to yaml | highlight yaml) }
      "toml" => { print ($show_info | to toml | highlight toml) }
      _ => { print ($show_info | to json | highlight) }
    }
  } else {
    match $flags.output_format {
      "json" => { _print ($show_info | to json) "json" "result" "table" }
      "yaml" => { _print ($show_info | to yaml) "yaml" "result" "table" }
      "toml" => { _print ($show_info | to toml) "toml" "result" "table" }
      _ => { print ($show_info | to json) }
    }
  }
}

# Init command handler
def handle_init [ops: string, flags: record] {
  let subcmd = ($ops | split row " " | get -o 0 | default "")

  match $subcmd {
    "config" => {
      use ../../lib_provisioning/config/loader.nu init-user-config

      let template_type = ($ops | split row " " | get -o 1 | default "user")
      let force_flag = ($ops | split row " " | any {|op| $op == "--force" or $op == "-f"})

      print "🚀 Initializing user configuration"
      print "=================================="
      print ""

      init-user-config --template $template_type --force $force_flag
    }
    "help" | "h" => {
      print "📋 Init Command Help"
      print "===================="
      print ""
      print "Initialize user configuration from templates:"
      print ""
      print "Commands:"
      print "  init config [template] [--force]  Initialize user config"
      print ""
      print "Templates:"
      print "  user    General user configuration (default)"
      print "  dev     Development environment optimized"
      print "  prod    Production environment optimized"
      print "  test    Testing environment optimized"
      print ""
      print "Options:"
      print "  --force, -f    Overwrite existing configuration"
      print ""
      print "Examples:"
      print "  provisioning init config"
      print "  provisioning init config dev"
      print "  provisioning init config prod --force"
    }
    _ => {
      print "❌ Unknown init command. Use 'provisioning init help' for available options."
    }
  }
}

# Validate command handler (placeholder - full implementation in main file)
def handle_validate [ops: string, flags: record] {
  # This is complex and should remain in main file for now
  # Just forward to the existing implementation
  print "Validate command - using existing implementation"
}

# Config template command handler
def handle_config_template [ops: string, flags: record] {
  let subcmd = ($ops | split row " " | get -o 0 | default "")

  match $subcmd {
    "list" => {
      print "📋 Available Configuration Templates"
      print "==================================="
      print ""

      let project_root = $env.PWD
      let templates = [
        { name: "user", file: "config.user.toml.example", description: "General user configuration with comprehensive documentation" }
        { name: "dev", file: "config.dev.toml.example", description: "Development environment with enhanced debugging" }
        { name: "prod", file: "config.prod.toml.example", description: "Production environment with security and performance focus" }
        { name: "test", file: "config.test.toml.example", description: "Testing environment with mock providers and CI/CD integration" }
      ]

      for template in $templates {
        let template_path = ($project_root | path join $template.file)
        let status = if ($template_path | path exists) { "✅" } else { "❌" }
        print $"($status) ($template.name) - ($template.description)"
        if ($template_path | path exists) {
          print $"   📁 ($template_path)"
        } else {
          print $"   ❌ Template file not found: ($template_path)"
        }
        print ""
      }

      print "💡 Usage: provisioning init config [template_name]"
    }
    "help" | "h" => {
      print "📋 Configuration Template Command Help"
      print "======================================"
      print ""
      print "Manage configuration file templates (config.*.toml):"
      print ""
      print "Commands:"
      print "  config-template list               List available config templates"
      print "  config-template show <name>        Show template content"
      print "  config-template validate           Validate all templates"
      print ""
      print "Examples:"
      print "  provisioning config-template list"
      print "  provisioning config-template show dev"
      print "  provisioning config-template validate"
    }
    _ => {
      print "❌ Unknown config-template command. Use 'provisioning config-template help' for available options."
    }
  }
}