use std
# REMOVED: use ../lib_provisioning * - causes circular import (already loaded by main provisioning script)
use ../lib_provisioning/platform *
use ../lib_provisioning/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
}

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
}
