use std
# REMOVED: use ../lib_provisioning * - causes circular import (already loaded by main provisioning script)
use platform/mod.nu *
use platform/config/accessor.nu *

# Taskserv workflow definitions

def get-orchestrator-url [--orchestrator: string = ""] {
    if ($orchestrator | is-not-empty) {
        return $orchestrator
    }
    if ($env.PROVISIONING_ORCHESTRATOR_URL? | is-not-empty) {
        return $env.PROVISIONING_ORCHESTRATOR_URL
    }
    config-get "platform.orchestrator.url" "http://localhost:9011"
}

# Detect if orchestrator URL is local (for plugin usage)
def use-local-plugin [orchestrator_url: string] {
    # Check if it's a local endpoint
    (detect-platform-mode $orchestrator_url) == "local"
}
export def taskserv_workflow [
    taskserv: string        # Taskserv name
    operation: string       # Operation: create, delete, generate, check-updates
    infra?: string         # Infrastructure target
    settings?: string      # Settings file path
    --check (-c)           # Check mode only
    --wait (-w)            # Wait for completion
    --orchestrator: string = ""  # Orchestrator URL (optional, uses platform config if not provided)
] {
    let orch_url = (get-orchestrator-url --orchestrator=$orchestrator)
    let workflow_data = {
        taskserv: $taskserv,
        operation: $operation,
        infra: ($infra | default ""),
        settings: ($settings | default ""),
        check_mode: $check,
        wait: $wait
    }

    # Submit to orchestrator
    let response = (http post $"($orch_url)/workflows/taskserv/create" --content-type "application/json" ($workflow_data | to json))

    if not ($response | get success) {
        return { status: "error", message: ($response | get error) }
    }

    let task_id = ($response | get data)
    _print $"Taskserv ($operation) workflow submitted: ($task_id)"

    if $wait {
        wait_for_workflow_completion $orch_url $task_id
    } else {
        { status: "submitted", task_id: $task_id }
    }
}

# Specific taskserv operations
export def "taskserv create" [
    taskserv: string        # Taskserv name
    infra?: string         # Infrastructure target
    settings?: string      # Settings file path
    --check (-c)           # Check mode only
    --wait (-w)            # Wait for completion
    --orchestrator: string = ""  # Orchestrator URL (optional, uses platform config if not provided)
] {
    taskserv_workflow $taskserv "create" $infra $settings --check=$check --wait=$wait --orchestrator $orchestrator
}

export def "taskserv delete" [
    taskserv: string        # Taskserv name
    infra?: string         # Infrastructure target
    settings?: string      # Settings file path
    --check (-c)           # Check mode only
    --wait (-w)            # Wait for completion
    --orchestrator: string = ""  # Orchestrator URL (optional, uses platform config if not provided)
] {
    taskserv_workflow $taskserv "delete" $infra $settings --check=$check --wait=$wait --orchestrator $orchestrator
}

export def "taskserv generate" [
    taskserv: string        # Taskserv name
    infra?: string         # Infrastructure target
    settings?: string      # Settings file path
    --check (-c)           # Check mode only
    --wait (-w)            # Wait for completion
    --orchestrator: string = ""  # Orchestrator URL (optional, uses platform config if not provided)
] {
    taskserv_workflow $taskserv "generate" $infra $settings --check=$check --wait=$wait --orchestrator $orchestrator
}

def main [
    ...args: string
    --infra (-i): string    = ""
    --settings (-s): string = ""
    --check (-c)
    --wait (-w)
    --orchestrator: string  = ""
    --out: string           = ""
    --debug (-x)
] : nothing -> nothing {
    if $debug { $env.PROVISIONING_DEBUG = true }
    let first = ($args | get 0? | default "")
    let rest = if $first in ["taskserv", "task", "t"] { $args | skip 1 } else { $args }
    let subcmd = ($rest | get 0? | default "")
    let name   = ($rest | get 1? | default "")

    match $subcmd {
        "status" | "s" => {
            use orchestration/taskservs/status.nu *
            main status --infra=$infra --settings=$settings
        }
        "list" | "l" => {
            use cli/components.nu ["main component list"]
            let rows = if ($infra | is-not-empty) {
                main component list --mode "taskserv" --infra $infra
            } else {
                main component list --mode "taskserv"
            }
            if ($rows | is-empty) {
                print "No taskserv-mode components declared in the active workspace."
                return
            }
            if $out == "json" { $rows | to json; return }
            if $out == "yaml" { $rows | to yaml; return }
            $rows | reject pod_selector
        }
        "create" | "c" => {
            taskserv_workflow $name "create" $infra $settings --check=$check --wait=$wait --orchestrator $orchestrator
        }
        "delete" | "d" => {
            taskserv_workflow $name "delete" $infra $settings --check=$check --wait=$wait --orchestrator $orchestrator
        }
        "generate" | "g" => {
            taskserv_workflow $name "generate" $infra $settings --check=$check --wait=$wait --orchestrator $orchestrator
        }
        "check-updates" => {
            taskserv_workflow $name "check-updates" $infra $settings --check=$check --wait=$wait --orchestrator $orchestrator
        }
        _ => {
            print "Task Service Management"
            print "========================"
            print ""
            print "Usage: prvng taskserv <subcommand> [options]"
            print ""
            print "Subcommands:"
            print "  status [--infra <i>] [--settings <s>]         DAG formula progress   (alias: s)"
            print "  list   [--infra <i>] [--settings <s>]         List all taskservs     (alias: l)"
            print "  create <name> [--infra <i>] [--check] [--wait] Create taskserv       (alias: c)"
            print "  delete <name> [--infra <i>]                   Delete taskserv        (alias: d)"
            print "  generate <name> [--infra <i>]                 Generate taskserv      (alias: g)"
            print "  check-updates <name>                          Check for updates"
            print ""
            print "Examples:"
            print "  prvng taskserv status"
            print "  prvng taskserv list --infra sgoyol"
            print "  prvng taskserv create postgresql --wait"
            print "  prvng t s                                      # status short form"
            print "  prvng t l                                      # list short form"
        }
    }
}

export def "taskserv check-updates" [
    taskserv?: string       # Taskserv name (optional for all)
    infra?: string         # Infrastructure target
    settings?: string      # Settings file path
    --check (-c)           # Check mode only
    --wait (-w)            # Wait for completion
    --orchestrator: string = ""  # Orchestrator URL (optional, uses platform config if not provided)
] {
    let taskserv_name = ($taskserv | default "")
    taskserv_workflow $taskserv_name "check-updates" $infra $settings --check=$check --wait=$wait --orchestrator $orchestrator
}

def wait_for_workflow_completion [orchestrator: string, task_id: string] {
    _print "Waiting for workflow completion..."

    mut result = { status: "pending" }

    while true {
        let status_response = (http get $"($orchestrator)/tasks/($task_id)")

        if not ($status_response | get success) {
            return { status: "error", message: "Failed to get task status" }
        }

        let task = ($status_response | get data)
        let task_status = ($task | get status)

        match $task_status {
            "Completed" => {
                _print $"✅ Workflow completed successfully"
                if ($task | get output | is-not-empty) {
                    _print "Output:"
                    _print ($task | get output)
                }
                $result = { status: "completed", task: $task }
                break
            },
            "Failed" => {
                _print $"❌ Workflow failed"
                if ($task | get error | is-not-empty) {
                    _print "Error:"
                    _print ($task | get error)
                }
                $result = { status: "failed", task: $task }
                break
            },
            "Running" => {
                _print $"🔄 Workflow is running..."
            },
            _ => {
                _print $"⏳ Workflow status: ($task_status)"
            }
        }

        sleep 2sec
    }

    return $result
}