#!/usr/bin/env nu

# KCL Core Packaging System
# Creates distributable packages for core provisioning/kcl module

use ../core/nulib/lib_provisioning/config/accessor.nu *

# Main packaging command
def main [subcommand?: string] {
    if ($subcommand | is-empty) {
        print_help
        return
    }

    match $subcommand {
        "build" => print_build_help
        "install" => print_install_help
        "version" => print_version_help
        "clean" => print_clean_help
        "help" => print_help
        _ => {
            print $"Unknown command: ($subcommand)"
            print_help
        }
    }
}

# Build core provisioning package
export def "main build" [
    --version = "0.0.1",       # Package version
    --output = "dist",         # Output directory
    --format = "tar.gz",       # Package format: tar.gz, zip
    --include-docs = false,    # Include documentation
    --clean = true             # Clean before build
]: nothing -> record {
    print $"Building core provisioning KCL package v($version)"

    # Clean previous builds if requested
    if $clean {
        clean-build-artifacts $output
    }

    # Validate source structure
    let validation = validate-source-structure
    if not $validation.valid {
        error make { msg: $"Source validation failed: ($validation.errors)" }
    }

    # Create package structure
    let package_info = create-package-structure $output $version

    # Copy KCL files
    copy-kcl-sources $package_info.package_dir

    # Generate package metadata
    generate-package-metadata $package_info.package_dir $version

    # Create archive
    let archive_path = create-package-archive $package_info.package_dir $format $output $version

    print $"✅ Package built successfully: ($archive_path)"
    {
        version: $version
        format: $format
        archive: $archive_path
        size: (ls $archive_path | get 0.size)
        package_dir: $package_info.package_dir
        checksum: (generate-checksum $archive_path)
    }
}

# Install package to target location
export def "main install" [
    package_path: string,              # Path to package archive
    target = "~/.kcl/modules",         # Installation target
    --force = false,                   # Force overwrite
    --verify = true                    # Verify installation
]: nothing -> record {
    print $"Installing KCL package: ($package_path) to ($target)"

    # Validate package
    if not ($package_path | path exists) {
        error make { msg: $"Package not found: ($package_path)" }
    }

    # Extract package info
    let package_info = extract-package-info $package_path

    # Check if already installed
    let install_path = ($target | path join "provisioning" $package_info.version)
    if ($install_path | path exists) and (not $force) {
        error make { msg: $"Package already installed at ($install_path). Use --force to overwrite." }
    }

    # Create installation directory
    mkdir ($target | path join "provisioning")

    # Extract package
    extract-package $package_path $install_path

    # Verify installation
    if $verify {
        let verification = verify-installation $install_path
        if not $verification.valid {
            error make { msg: $"Installation verification failed: ($verification.errors)" }
        }
    }

    print $"✅ Package installed successfully to: ($install_path)"
    {
        package: $package_path
        version: $package_info.version
        install_path: $install_path
        verified: $verify
    }
}

# Show package version info
export def "main version" [
    package_path?: string  # Optional package path, defaults to current source
]: nothing -> record {
    if ($package_path | is-empty) {
        # Show current source version
        let kcl_path = "../kcl"
        if not ($kcl_path | path exists) {
            error make { msg: "KCL source directory not found" }
        }

        let version_file = ($kcl_path | path join "version.k")
        if ($version_file | path exists) {
            let content = (open $version_file)
            extract-version-from-content $content
        } else {
            { version: "0.0.1", source: "default" }
        }
    } else {
        # Extract version from package
        extract-package-info $package_path
    }
}

# Clean build artifacts
export def "main clean" [
    output_dir = "dist"  # Output directory to clean
]: nothing -> record {
    print $"Cleaning build artifacts from: ($output_dir)"

    if ($output_dir | path exists) {
        let artifacts = (ls $output_dir | length)
        rm -rf $output_dir
        print $"✅ Removed ($artifacts) artifacts"
        { cleaned: $artifacts, directory: $output_dir }
    } else {
        print "No artifacts to clean"
        { cleaned: 0, directory: $output_dir }
    }
}

# Validate source structure
def validate-source-structure []: nothing -> record {
    let kcl_path = "../kcl"
    let required_files = [
        "main.k"
        "settings.k"
        "defaults.k"
        "server.k"
        "cluster.k"
        "workflows.k"
        "version.k"
    ]

    let missing = ($required_files | where {
        not (($kcl_path | path join $in) | path exists)
    })

    {
        valid: ($missing | is-empty),
        missing_files: $missing,
        errors: (if ($missing | is-empty) { [] } else { [$"Missing required files: ($missing | str join ', ')"] })
    }
}

# Create package directory structure
def create-package-structure [output: string, version: string]: nothing -> record {
    let package_name = $"provisioning-kcl-($version)"
    let package_dir = ($output | path join $package_name)

    # Create directories
    mkdir $output
    mkdir $package_dir
    mkdir ($package_dir | path join "kcl")
    mkdir ($package_dir | path join "docs")
    mkdir ($package_dir | path join "examples")

    {
        package_name: $package_name
        package_dir: $package_dir
        output_dir: $output
    }
}

# Copy KCL source files
def copy-kcl-sources [package_dir: string] {
    let source_kcl = "../kcl"
    let target_kcl = ($package_dir | path join "kcl")

    # Copy all .k files
    let kcl_files = (glob ($source_kcl | path join "*.k"))
    for $file in $kcl_files {
        let filename = ($file | path basename)
        cp $file ($target_kcl | path join $filename)
    }

    # Copy kcl.mod if exists
    let kcl_mod = ($source_kcl | path join "kcl.mod")
    if ($kcl_mod | path exists) {
        cp $kcl_mod ($target_kcl | path join "kcl.mod")
    }

    print $"Copied (($kcl_files | length)) KCL files"
}

# Generate package metadata
def generate-package-metadata [package_dir: string, version: string] {
    let metadata = {
        name: "provisioning"
        version: $version
        description: "Core provisioning KCL schemas and configurations"
        author: "Provisioning Team"
        license: "MIT"
        created: (date now | format date '%Y-%m-%d %H:%M:%S')
        kcl_version: "0.11.2"
        dependencies: {}
        files: {
            schemas: (glob ($package_dir | path join "kcl" "*.k") | each { path basename })
            main: "main.k"
        }
    }

    $metadata | to json | save ($package_dir | path join "package.json")
    $metadata | to yaml | save ($package_dir | path join "package.yaml")

    # Create README
    let readme_content = $"# Provisioning KCL Package

Version: ($version)
Created: ($metadata.created)

## Description
($metadata.description)

## Installation
```bash
kcl-packager install provisioning-kcl-($version).tar.gz
```

## Usage
```kcl
import provisioning

# Use provisioning schemas
settings: provisioning.Settings = {
    # Your configuration
}
```

## Files
- main.k: Main entry point
- settings.k: Core settings schema
- defaults.k: Default configurations
- server.k: Server management schemas
- cluster.k: Cluster configuration schemas
- workflows.k: Workflow definitions
"

    $readme_content | save ($package_dir | path join "README.md")
}

# Create package archive
def create-package-archive [package_dir: string, format: string, output: string, version: string]: nothing -> string {
    let package_name = ($package_dir | path basename)
    let archive_name = match $format {
        "tar.gz" => $"($package_name).tar.gz"
        "zip" => $"($package_name).zip"
        _ => $"($package_name).tar.gz"
    }

    let archive_path = ($output | path join $archive_name)

    # Create archive
    match $format {
        "tar.gz" => {
            cd $output
            ^tar czf $archive_name $package_name
        }
        "zip" => {
            cd $output
            ^zip -r $archive_name $package_name
        }
        _ => {
            cd $output
            ^tar czf $archive_name $package_name
        }
    }

    $archive_path
}

# Generate file checksum
def generate-checksum [file_path: string]: nothing -> string {
    if (which sha256sum | is-empty) {
        if (which shasum | is-empty) {
            "checksum-unavailable"
        } else {
            ^shasum -a 256 $file_path | split row ' ' | get 0
        }
    } else {
        ^sha256sum $file_path | split row ' ' | get 0
    }
}

# Extract package information
def extract-package-info [package_path: string]: nothing -> record {
    # For now, extract from filename
    let filename = ($package_path | path basename)
    let parts = ($filename | str replace '.tar.gz' '' | str replace '.zip' '' | split row '-')

    if ($parts | length) >= 3 {
        {
            name: ($parts | take 2 | str join '-'),
            version: ($parts | get 2),
            format: (if ($filename | str contains '.tar.gz') { "tar.gz" } else { "zip" })
        }
    } else {
        {
            name: "unknown",
            version: "unknown",
            format: "unknown"
        }
    }
}

# Extract package to target location
def extract-package [package_path: string, target_path: string] {
    let format = if ($package_path | str contains '.tar.gz') { "tar.gz" } else { "zip" }

    mkdir $target_path

    match $format {
        "tar.gz" => {
            ^tar xzf $package_path -C $target_path --strip-components=1
        }
        "zip" => {
            ^unzip -q $package_path -d ($target_path | path dirname)
            # Move extracted contents up one level
            let extracted_dir = (ls ($target_path | path dirname) | where type == dir | get name | first)
            mv ($extracted_dir | path join "*") $target_path
            rm -rf $extracted_dir
        }
    }
}

# Verify installation
def verify-installation [install_path: string]: nothing -> record {
    let required_files = ["kcl/main.k", "package.json"]
    let missing = ($required_files | where {
        not (($install_path | path join $in) | path exists)
    })

    {
        valid: ($missing | is-empty),
        missing_files: $missing,
        errors: (if ($missing | is-empty) { [] } else { [$"Missing files after installation: ($missing | str join ', ')"] })
    }
}

# Extract version from KCL content
def extract-version-from-content [content: string]: nothing -> record {
    let lines = ($content | lines)
    let version_line = ($lines | where ($it | str contains "version") | first | default "")

    if ($version_line | is-empty) {
        { version: "0.0.1", source: "default" }
    } else {
        let version = ($version_line | str replace 'version = "' '' | str replace '"' '' | str trim)
        { version: $version, source: "file" }
    }
}

# Clean build artifacts
def clean-build-artifacts [output_dir: string] {
    if ($output_dir | path exists) {
        print $"Cleaning previous build artifacts from: ($output_dir)"
        rm -rf $output_dir
    }
    mkdir $output_dir
}

# Help functions
def print_help [] {
    print "KCL Core Packaging System - Build and distribute core provisioning KCL packages"
    print ""
    print "Usage: kcl-packager <command> [options]"
    print ""
    print "Commands:"
    print "  build [options]              - Build package from source"
    print "  install <package> [target]   - Install package to target location"
    print "  version [package]            - Show version information"
    print "  clean [output]               - Clean build artifacts"
    print "  help                         - Show this help"
    print ""
    print "Examples:"
    print "  kcl-packager build --version 1.0.0"
    print "  kcl-packager install dist/provisioning-kcl-1.0.0.tar.gz"
    print "  kcl-packager version"
}

def print_build_help [] {
    print "Build core provisioning KCL package"
    print ""
    print "Usage: kcl-packager build [options]"
    print ""
    print "Options:"
    print "  --version <version>     Package version (default: 0.0.1)"
    print "  --output <dir>          Output directory (default: dist)"
    print "  --format <format>       Package format: tar.gz, zip (default: tar.gz)"
    print "  --include-docs          Include documentation"
    print "  --clean                 Clean before build (default: true)"
    print ""
    print "Examples:"
    print "  kcl-packager build --version 1.0.0 --format zip"
    print "  kcl-packager build --output packages --include-docs"
}

def print_install_help [] {
    print "Install KCL package to target location"
    print ""
    print "Usage: kcl-packager install <package> [target] [options]"
    print ""
    print "Arguments:"
    print "  package                 Path to package archive"
    print "  target                  Installation target (default: ~/.kcl/modules)"
    print ""
    print "Options:"
    print "  --force                 Force overwrite existing installation"
    print "  --verify                Verify installation (default: true)"
    print ""
    print "Examples:"
    print "  kcl-packager install dist/provisioning-kcl-1.0.0.tar.gz"
    print "  kcl-packager install package.tar.gz /usr/local/kcl/modules --force"
}

def print_version_help [] {
    print "Show package version information"
    print ""
    print "Usage: kcl-packager version [package]"
    print ""
    print "Arguments:"
    print "  package                 Optional package path (defaults to current source)"
    print ""
    print "Examples:"
    print "  kcl-packager version                              # Show source version"
    print "  kcl-packager version dist/provisioning-kcl-1.0.0.tar.gz  # Show package version"
}

def print_clean_help [] {
    print "Clean build artifacts"
    print ""
    print "Usage: kcl-packager clean [output]"
    print ""
    print "Arguments:"
    print "  output                  Output directory to clean (default: dist)"
    print ""
    print "Examples:"
    print "  kcl-packager clean"
    print "  kcl-packager clean packages"
}