use tools/nickel/process.nu [ncl-eval-soft]
use platform/user/config.nu [get-platform-config-dir write-provisioning-root]

def get-config-dir [] {
    get-platform-config-dir
}

export def load-deployment-mode [] {
    let config_dir = (get-config-dir)
    let config_file = $"($config_dir)/deployment-mode.ncl"

    if not ($config_file | path exists) {
        print $"ERROR: Configuration file not found at ($config_file)"
        return {}
    }

    let import_path = ($env.PROVISIONING? | default "")
    let import_paths = if ($import_path | is-not-empty) { [$import_path] } else { [] }
    let content = (ncl-eval-soft $config_file $import_paths null)

    if $content != null { $content } else {
        print "ERROR: Failed to export Nickel configuration"
        {}
    }
}

export def get-enabled-services [] {
    let deployment = (load-deployment-mode)

    if not ("services" in $deployment) {
        print "ERROR: No services found in deployment configuration"
        return []
    }

    let services = $deployment.services
    let all_services = ($services | columns)

    let enabled = ($all_services | where {|key|
        let svc = ($services | get $key)
        ($svc.enabled? | default false)
    })

    $enabled
    | each {|name|
        let cfg = $services | get $name
        {name: $name, config: $cfg, priority: ($cfg.priority? | default 999)}
    }
    | sort-by priority
}

export def get-deployment-service-config [service: string] {
    let deployment = (load-deployment-mode)
    $deployment.services | get $service
}

export def get-default-platform-target [workspace: string] {
    {
        platform: {
            name: $"($workspace)-local"
            type: "local"
            mode: "development"
            services: {
                orchestrator: {enabled: true, endpoint: "http://localhost:9090", required: true, health_check: {endpoint: "/health", timeout: 5000}}
                control: {enabled: false, endpoint: "http://localhost:9080", required: false, health_check: {endpoint: "/health", timeout: 5000}}
                kms: {enabled: true, endpoint: "http://localhost:8090", required: true, health_check: {endpoint: "/health", timeout: 5000}}
            }
        }
    }
}

export def validate-platform-target [target: record] {
    "platform" in $target
}

export def detect-platform-mode [endpoint: string] {
    if ($endpoint =~ "localhost") { "local" } else { "remote" }
}

export def should-start-locally [config: record] {
    (detect-platform-mode $config.endpoint) == "local"
}

export def get-platform-endpoint [service: string] {
    let cfg = (get-deployment-service-config $service)
    let explicit = ($cfg | get -o endpoint | default "")
    if ($explicit | is-not-empty) {
        $explicit
    } else {
        let srv = ($cfg | get -o server)
        if $srv == null { "" } else {
            let host = ($srv | get -o host | default "127.0.0.1")
            let port = ($srv | get -o port | default 0)
            if $port == 0 { "" } else { $"http://($host):($port)" }
        }
    }
}

export def is-platform-service-enabled [service: string] {
    (get-deployment-service-config $service).enabled
}

export def get-platform-service-config [service: string] {
    get-deployment-service-config $service
}

export def list-enabled-platform-services [] {
    get-enabled-services | each {|s| {name: $s.name}}
}

export def list-required-platform-services [] {
    get-enabled-services
    | where {|s| ($s.config.required? | default false)}
    | each {|s| {name: $s.name}}
}