mod.nu

# Root Module Aggregator with Lazy Loading and Dependency Resolution
#
# This module serves as the primary entry point for the entire module system,
# implementing a sophisticated dependency injection framework with topological
# sorting for correct initialization order.

export const MODULE_REGISTRY = {
    version: "1.0.0"
    modules: {
        core: {
            path: "./core/mod.nu"
            exports: ["functional", "types", "iterators"]
            dependencies: []
            lazy: false  # Core modules loaded eagerly
        }
        fs: {
            path: "./fs/mod.nu"
            exports: ["traversal", "atomic", "watchers"]
            dependencies: ["core"]
            lazy: true
        }
        data: {
            path: "./data/mod.nu"
            exports: ["transforms", "validators", "parsers"]
            dependencies: ["core"]
            lazy: true
        }
        net: {
            path: "./net/mod.nu"
            exports: ["http", "websocket", "dns"]
            dependencies: ["core", "data"]
            lazy: true
        }
        sys: {
            path: "./sys/mod.nu"
            exports: ["process", "signals", "resources"]
            dependencies: ["core"]
            lazy: true
        }
        git: {
            path: "./git/mod.nu"
            exports: ["status", "workflow", "hooks"]
            dependencies: ["core", "fs"]
            lazy: true
        }
        dev: {
            path: "./dev/mod.nu"
            exports: ["repl", "debug", "profile"]
            dependencies: ["core", "sys"]
            lazy: true
        }
    }
}

# Initialize module system with dependency resolution
export def --env init [] {
    print "Initializing nushell module system..."
    
    # Set up module environment
    $env.NU_MODULES = {
        loaded: {}
        cache: {}
        config: (load-module-config)
        initialized: (date now)
    }
    
    # Load core modules eagerly
    for module in ($MODULE_REGISTRY.modules | transpose key value) {
        if not $module.value.lazy {
            load-module $module.key
        }
    }
    
    print "Module system initialized successfully"
}

# Topological sort for dependency resolution
def topological-sort [modules: record]: nothing -> list<string> {
    mut sorted = []
    mut visited = {}
    mut temp_mark = {}
    
    def visit [node: string, modules: record, visited: record, temp_mark: record]: nothing -> list<string> {
        if $node in $temp_mark and ($temp_mark | get $node) {
            error make { msg: $"Circular dependency detected at module: ($node)" }
        }
        
        if $node in $visited and ($visited | get $node) {
            return []
        }
        
        $temp_mark = ($temp_mark | upsert $node true)
        
        let deps = ($modules | get $node | get dependencies)
        mut result = []
        
        for dep in $deps {
            $result = ($result | append (visit $dep $modules $visited $temp_mark))
        }
        
        $temp_mark = ($temp_mark | upsert $node false)
        $visited = ($visited | upsert $node true)
        
        $result | append $node
    }
    
    for module in ($modules | columns) {
        if not ($module in $visited and ($visited | get $module)) {
            $sorted = ($sorted | append (visit $module $modules $visited $temp_mark))
        }
    }
    
    $sorted | uniq
}

# Dynamic module loader with caching
def load-module [name: string]: nothing -> any {
    # Check if already loaded
    if $name in $env.NU_MODULES.loaded {
        return ($env.NU_MODULES.loaded | get $name)
    }
    
    # Get module metadata
    let module_info = ($MODULE_REGISTRY.modules | get $name)
    
    # Load dependencies first
    for dep in $module_info.dependencies {
        load-module $dep
    }
    
    # Load the module
    let module_path = (
        $env.FILE_PWD 
        | path join $module_info.path
        | path expand
    )
    
    if not ($module_path | path exists) {
        error make { 
            msg: $"Module not found: ($name)"
            label: { text: $"Expected at: ($module_path)" }
        }
    }
    
    # Import and cache
    use $module_path *
    
    $env.NU_MODULES.loaded = (
        $env.NU_MODULES.loaded 
        | upsert $name {
            path: $module_path
            loaded: (date now)
            exports: $module_info.exports
        }
    )
    
    print $"Loaded module: ($name)"
}

# Load configuration from various sources
def load-module-config []: nothing -> record {
    let config_paths = [
        ($env.HOME | path join ".config/nushell-modules/config.nu")
        ($env.FILE_PWD | path join "config/modules.nu")
        "./modules.config.nu"
    ]
    
    let config_path = (
        $config_paths 
        | where ($it | path exists) 
        | first -n
    )
    
    if $config_path != null {
        source $config_path
        $env.MODULE_CONFIG
    } else {
        # Default configuration
        {
            lazy_loading: true
            cache_enabled: true
            cache_ttl: 1hr
            auto_reload: false
            debug: false
        }
    }
}

# Re-export commonly used functions from core modules
export use ./core/functional.nu [
    compose
    pipe
    curry
    partial
    memoize
    Y
    fmap
    lazy-seq
]

export use ./fs/traversal.nu [
    bfs-traverse
    dfs-traverse
    find-duplicates
    tree
    atomic-write
    sync-dirs
]

# Lazy module proxy generators
export def fs [...args]: nothing -> any {
    load-module "fs"
    # Dispatch to fs module commands
    if ($args | length) == 0 {
        help modules | where name =~ "^fs"
    } else {
        let cmd = ($args | first)
        let rest = ($args | skip 1)
        nu -c $"use ($env.NU_MODULES.loaded.fs.path) *; ($cmd) ...($rest)"
    }
}

export def data [...args]: nothing -> any {
    load-module "data"
    # Similar dispatch pattern
}

export def net [...args]: nothing -> any {
    load-module "net"
    # Similar dispatch pattern
}

export def sys [...args]: nothing -> any {
    load-module "sys"
    # Similar dispatch pattern
}

export def git [...args]: nothing -> any {
    load-module "git"
    # Similar dispatch pattern
}

export def dev [...args]: nothing -> any {
    load-module "dev"
    # Similar dispatch pattern
}

# Module management commands
export def "modules list" [
    --loaded  # Show only loaded modules
    --available  # Show all available modules
]: nothing -> table {
    if $loaded {
        $env.NU_MODULES.loaded 
        | transpose key value
        | each { |m|
            {
                name: $m.key
                path: $m.value.path
                loaded: $m.value.loaded
                exports: ($m.value.exports | str join ", ")
            }
        }
    } else {
        $MODULE_REGISTRY.modules
        | transpose key value
        | each { |m|
            {
                name: $m.key
                path: $m.value.path
                dependencies: ($m.value.dependencies | str join ", ")
                lazy: $m.value.lazy
                loaded: ($m.key in $env.NU_MODULES.loaded)
            }
        }
    }
}

export def "modules reload" [
    module?: string  # Specific module to reload (all if not specified)
]: nothing -> nothing {
    if $module != null {
        # Unload specific module
        $env.NU_MODULES.loaded = (
            $env.NU_MODULES.loaded | reject $module
        )
        load-module $module
    } else {
        # Reload all modules
        let loaded = ($env.NU_MODULES.loaded | columns)
        $env.NU_MODULES.loaded = {}
        
        for mod in $loaded {
            load-module $mod
        }
    }
    
    print "Modules reloaded successfully"
}

export def "modules test" [
    --module: string  # Test specific module (all if not specified)
    --verbose  # Verbose output
]: nothing -> table {
    let modules_to_test = if $module != null {
        [$module]
    } else {
        $MODULE_REGISTRY.modules | columns
    }
    
    let results = ($modules_to_test | each { |mod|
        print $"Testing module: ($mod)..."
        
        let module_path = (
            $env.FILE_PWD 
            | path join ($MODULE_REGISTRY.modules | get $mod | get path)
        )
        
        let test_result = try {
            nu -c $"use ($module_path) test; test"
            | from nuon
        } catch {
            { passed: 0, failed: 1, skipped: 0, error: $in }
        }
        
        {
            module: $mod
            passed: $test_result.passed
            failed: $test_result.failed
            skipped: $test_result.skipped
            status: (if $test_result.failed == 0 { "✅" } else { "❌" })
        }
    })
    
    # Summary
    let total = {
        modules: ($results | length)
        passed: ($results | get passed | math sum)
        failed: ($results | get failed | math sum)
        skipped: ($results | get skipped | math sum)
    }
    
    print $"\nTest Summary:"
    print $"  Modules tested: ($total.modules)"
    print $"  Tests passed: ($total.passed)"
    print $"  Tests failed: ($total.failed)"
    print $"  Tests skipped: ($total.skipped)"
    
    $results
}

export def "modules bench" [
    module: string
    function: string
    --iterations: int = 100
]: nothing -> record {
    load-module $module
    
    let module_path = (
        $env.FILE_PWD 
        | path join ($MODULE_REGISTRY.modules | get $module | get path)
    )
    
    print $"Benchmarking ($module)::($function)..."
    
    # Warmup
    for _ in 0..<10 {
        nu -c $"use ($module_path) ($function); ($function)"
    }
    
    # Measure
    let times = (0..<$iterations | each { |_|
        let start = (date now)
        nu -c $"use ($module_path) ($function); ($function)"
        let end = (date now)
        ($end - $start) | into int
    })
    
    {
        module: $module
        function: $function
        iterations: $iterations
        mean: ($times | math avg)
        median: ($times | math median)
        stddev: ($times | math stddev)
        min: ($times | math min)
        max: ($times | math max)
    }
}

# Module documentation generator
export def "modules docs" [
    --output: path = "docs/modules/"  # Output directory
    --format: string = "markdown"  # Output format
]: nothing -> nothing {
    mkdir $output
    
    for module in ($MODULE_REGISTRY.modules | transpose key value) {
        let module_name = $module.key
        let module_info = $module.value
        
        let doc_path = ($output | path join $"($module_name).md")
        
        let doc_content = $"# Module: ($module_name)

## Overview
Path: `($module_info.path)`
Dependencies: ($module_info.dependencies | str join ", ")
Lazy Loading: ($module_info.lazy)

## Exports
($module_info.exports | each { |exp| $"- ($exp)" } | str join "\n")

## Functions
"
        
        $doc_content | save -f $doc_path
        print $"Generated documentation for ($module_name)"
    }
    
    print $"Documentation generated in ($output)"
}

# Main entry point
export def main [
    --init  # Initialize module system
    --list  # List modules
    --test  # Run tests
    --bench  # Run benchmarks
    --docs  # Generate documentation
]: nothing -> any {
    if $init {
        init
    } else if $list {
        modules list
    } else if $test {
        modules test
    } else if $bench {
        print "Specify module and function: modules bench <module> <function>"
    } else if $docs {
        modules docs
    } else {
        print "Nushell Module System
        
Commands:
  modules list       - List all modules
  modules reload     - Reload modules
  modules test       - Run module tests
  modules bench      - Benchmark module functions
  modules docs       - Generate documentation
  
Modules:
  fs    - Filesystem operations
  data  - Data transformations
  net   - Network operations
  sys   - System interface
  git   - Git integrations
  dev   - Development tools
"
    }
}