prvng_core/nulib/lib_provisioning/extensions/cache.nu

# Hetzner Cloud caching operations
use env.nu *

# Initialize cache directory
export def hetzner_start_cache_info [settings: record, server: string]: nothing -> null {
    if not ($settings | has provider) or not ($settings.provider | has paths) {
        return null
    }

    let cache_dir = $"($settings.provider.paths.cache)"

    if not ($cache_dir | path exists) {
        mkdir $cache_dir
    }

    null
}

# Create cache entry for server
export def hetzner_create_cache [settings: record, server: string, error_exit: bool = true]: nothing -> null {
    try {
        hetzner_start_cache_info $settings $server

        let cache_dir = $"($settings.provider.paths.cache)"
        let cache_file = $"($cache_dir)/($server).json"

        let cache_data = {
            server: $server
            timestamp: (now)
            cached_at: (date now | date to-record)
        }

        $cache_data | to json | save --force $cache_file
    } catch {|err|
        if $error_exit {
            error make {msg: $"Failed to create cache: ($err.msg)"}
        }
    }

    null
}

# Read cache entry
export def hetzner_read_cache [settings: record, server: string, error_exit: bool = true]: nothing -> record {
    try {
        let cache_dir = $"($settings.provider.paths.cache)"
        let cache_file = $"($cache_dir)/($server).json"

        if not ($cache_file | path exists) {
            if $error_exit {
                error make {msg: $"Cache file not found: ($cache_file)"}
            }
            return {}
        }

        open $cache_file | from json
    } catch {|err|
        if $error_exit {
            error make {msg: $"Failed to read cache: ($err.msg)"}
        }
        {}
    }
}

# Clean cache entry
export def hetzner_clean_cache [settings: record, server: string, error_exit: bool = true]: nothing -> null {
    try {
        let cache_dir = $"($settings.provider.paths.cache)"
        let cache_file = $"($cache_dir)/($server).json"

        if ($cache_file | path exists) {
            rm $cache_file
        }
    } catch {|err|
        if $error_exit {
            error make {msg: $"Failed to clean cache: ($err.msg)"}
        }
    }

    null
}

# Get IP from cache
export def hetzner_ip_from_cache [settings: record, server: string, error_exit: bool = true]: nothing -> string {
    try {
        let cache = (hetzner_read_cache $settings $server false)

        if ($cache | has ip) {
            $cache.ip
        } else {
            ""
        }
    } catch {
        ""
    }
}

# Update cache with server data
export def hetzner_update_cache [settings: record, server: record, error_exit: bool = true]: nothing -> null {
    try {
        hetzner_start_cache_info $settings $server.hostname

        let cache_dir = $"($settings.provider.paths.cache)"
        let cache_file = $"($cache_dir)/($server.hostname).json"

        let cache_data = {
            server: $server.hostname
            server_id: ($server.id | default "")
            ipv4: ($server.public_net.ipv4.ip | default "")
            ipv6: ($server.public_net.ipv6.ip | default "")
            status: ($server.status | default "")
            location: ($server.location.name | default "")
            server_type: ($server.server_type.name | default "")
            timestamp: (now)
            cached_at: (date now | date to-record)
        }

        $cache_data | to json | save --force $cache_file
    } catch {|err|
        if $error_exit {
            error make {msg: $"Failed to update cache: ($err.msg)"}
        }
    }

    null
}

# Clean all cache
export def hetzner_clean_all_cache [settings: record, error_exit: bool = true]: nothing -> null {
    try {
        let cache_dir = $"($settings.provider.paths.cache)"

        if ($cache_dir | path exists) {
            rm -r $cache_dir
        }

        mkdir $cache_dir
    } catch {|err|
        if $error_exit {
            error make {msg: $"Failed to clean all cache: ($err.msg)"}
        }
    }

    null
}

# Get cache age in seconds
export def hetzner_cache_age [cache_data: record]: nothing -> int {
    if not ($cache_data | has timestamp) {
        return -1
    }

    let cached_ts = ($cache_data.timestamp | into int)
    let now_ts = (now | into int)
    $now_ts - $cached_ts
}

# Check if cache is still valid
export def hetzner_cache_valid [cache_data: record, ttl_seconds: int = 3600]: nothing -> bool {
    let age = (hetzner_cache_age $cache_data)
    if $age < 0 {return false}
    $age < $ttl_seconds
}