zinit_client/

repl.rs

//! Interactive REPL for Zinit Rhai scripting
//!
//! Provides a readline-style interface with:
//! - Tab completion for zinit_* functions
//! - Command history
//! - Syntax highlighting
//! - Help hints

use crate::client::ZinitHandle;
use crate::rhai::ZinitEngine;
use colored::Colorize;
use rustyline::completion::{Completer, Pair};
use rustyline::error::ReadlineError;
use rustyline::highlight::Highlighter;
use rustyline::hint::{Hinter, HistoryHinter};
use rustyline::history::DefaultHistory;
use rustyline::validate::Validator;
use rustyline::{Config, Context, Editor, Helper};
use std::borrow::Cow;

/// All available zinit functions with their signatures and descriptions
const ZINIT_FUNCTIONS: &[(&str, &str, &str)] = &[
    // Zinit control
    ("zinit_ping()", "map", "Check if zinit is responding"),
    ("zinit_shutdown()", "void", "Shutdown zinit server"),
    // Service management
    (
        "new_service(name)",
        "ServiceBuilder",
        "Create a new service builder",
    ),
    (
        "register(builder)",
        "void",
        "Register service without starting",
    ),
    (
        "start(builder, secs)",
        "void",
        "Register, start, and wait for service",
    ),
    ("zinit_start(name)", "void", "Start a service"),
    ("zinit_stop(name)", "void", "Stop a service"),
    ("zinit_restart(name)", "void", "Restart a service"),
    (
        "zinit_delete(name)",
        "void",
        "Stop, kill if needed, and remove service",
    ),
    ("zinit_kill(name, signal)", "void", "Send signal to service"),
    // Query functions
    ("zinit_list()", "array", "List all service names"),
    ("zinit_status(name)", "map", "Get service status"),
    ("zinit_stats(name)", "map", "Get CPU/memory stats"),
    (
        "zinit_is_running(name)",
        "bool",
        "Check if service is running",
    ),
    // Batch operations
    ("zinit_start_all()", "void", "Start all services"),
    ("zinit_stop_all()", "void", "Stop all services"),
    // Logging functions
    ("zinit_logs()", "array", "Get all logs from ring buffer"),
    (
        "zinit_logs_filter(service)",
        "array",
        "Get logs for a service",
    ),
    // Utilities
    ("print(msg)", "void", "Print message"),
    ("sleep(secs)", "void", "Sleep for seconds"),
    ("sleep_ms(ms)", "void", "Sleep for milliseconds"),
    ("get_env(key)", "string|unit", "Get environment variable"),
    ("set_env(key, value)", "void", "Set environment variable"),
    ("file_exists(path)", "bool", "Check if path exists"),
    ("is_dir(path)", "bool", "Check if path is directory"),
    ("is_file(path)", "bool", "Check if path is file"),
    ("check_tcp(addr)", "bool", "Check if TCP port is open"),
    ("check_http(url)", "bool", "Check if HTTP endpoint is up"),
    ("kill_port(port)", "int", "Kill process on TCP port"),
];

/// Service builder methods
const BUILDER_METHODS: &[(&str, &str)] = &[
    (".name(name)", "Service name (required)"),
    (".exec(cmd)", "Command to run (required)"),
    (".test(cmd)", "Health check command"),
    (".oneshot(bool)", "Run once, don't restart"),
    (".shutdown_timeout(secs)", "Seconds before SIGKILL"),
    (".after(service)", "Start after this service"),
    (".signal_stop(signal)", "Signal to send on stop"),
    (".log(mode)", "\"ring\", \"stdout\", or \"none\""),
    (".env(key, value)", "Set environment variable"),
    (".dir(path)", "Working directory"),
    (".test_cmd(cmd)", "Command-based health check"),
    (".test_tcp(addr)", "TCP port health check"),
    (".test_http(url)", "HTTP endpoint health check"),
    (".tcp_kill()", "Kill processes on port before starting"),
    (".register()", "Register the service"),
    (".wait(secs)", "Wait for service to be running"),
];

/// REPL commands
const REPL_COMMANDS: &[(&str, &str)] = &[
    ("/help", "Show this help"),
    ("/functions", "List all zinit functions"),
    ("/builder", "Show service builder methods"),
    ("/load <file>", "Load and execute a .rhai script"),
    ("/tui", "Enter full-screen interactive TUI mode"),
    ("/clear", "Clear screen"),
    ("/quit", "Exit REPL (or Ctrl+D)"),
];

/// Rhai keywords for syntax highlighting
const RHAI_KEYWORDS: &[&str] = &[
    "let", "const", "if", "else", "while", "loop", "for", "in", "break", "continue", "return",
    "throw", "try", "catch", "fn", "private", "import", "export", "as", "true", "false", "null",
];

/// Helper struct for rustyline
#[derive(Helper)]
struct ReplHelper {
    hinter: HistoryHinter,
}

impl Completer for ReplHelper {
    type Candidate = Pair;

    fn complete(
        &self,
        line: &str,
        pos: usize,
        _ctx: &Context<'_>,
    ) -> rustyline::Result<(usize, Vec<Pair>)> {
        let mut completions = Vec::new();

        // Find the word being typed
        let line_to_cursor = &line[..pos];
        let word_start = line_to_cursor
            .rfind(|c: char| !c.is_alphanumeric() && c != '_')
            .map(|i| i + 1)
            .unwrap_or(0);
        let word = &line_to_cursor[word_start..];

        if word.is_empty() {
            return Ok((pos, completions));
        }

        // Check for REPL commands
        if word.starts_with('/') {
            for (cmd, desc) in REPL_COMMANDS {
                // Get just the command part (without arguments like <file>)
                let cmd_name = cmd.split_whitespace().next().unwrap_or(cmd);
                if cmd_name.starts_with(word) {
                    completions.push(Pair {
                        display: format!("{} - {}", cmd, desc),
                        replacement: cmd_name.to_string(),
                    });
                }
            }
            return Ok((word_start, completions));
        }

        // Check for builder methods (after a dot)
        if word.starts_with('.') || line_to_cursor.ends_with('.') {
            let method_word = if word.starts_with('.') { word } else { "." };
            for (method, desc) in BUILDER_METHODS {
                if method.starts_with(method_word) {
                    let replacement = method.split('(').next().unwrap_or(method);
                    completions.push(Pair {
                        display: format!("{} - {}", method, desc),
                        replacement: replacement.to_string(),
                    });
                }
            }
            let start = if word.starts_with('.') {
                word_start
            } else {
                pos
            };
            return Ok((start, completions));
        }

        // Complete zinit functions
        for (func, ret, desc) in ZINIT_FUNCTIONS {
            let func_name = func.split('(').next().unwrap_or(func);
            if func_name.starts_with(word) {
                completions.push(Pair {
                    display: format!("{} -> {} - {}", func, ret, desc),
                    replacement: func_name.to_string(),
                });
            }
        }

        // Complete Rhai keywords
        for kw in RHAI_KEYWORDS {
            if kw.starts_with(word) && !completions.iter().any(|p| p.replacement == *kw) {
                completions.push(Pair {
                    display: format!("{} (keyword)", kw),
                    replacement: kw.to_string(),
                });
            }
        }

        Ok((word_start, completions))
    }
}

impl Hinter for ReplHelper {
    type Hint = String;

    fn hint(&self, line: &str, pos: usize, ctx: &Context<'_>) -> Option<String> {
        // First try history hints
        if let Some(hint) = self.hinter.hint(line, pos, ctx) {
            return Some(hint);
        }

        // Then try function signature hints
        let line_to_cursor = &line[..pos];

        // Find if we're typing a zinit function
        for (func, ret, desc) in ZINIT_FUNCTIONS {
            let func_name = func.split('(').next().unwrap_or(func);
            if line_to_cursor.ends_with(func_name) {
                let signature = &func[func_name.len()..];
                return Some(
                    format!("{} -> {} | {}", signature, ret, desc)
                        .dimmed()
                        .to_string(),
                );
            }
        }

        None
    }
}

impl Highlighter for ReplHelper {
    fn highlight<'l>(&self, line: &'l str, _pos: usize) -> Cow<'l, str> {
        let mut result = String::with_capacity(line.len() * 2);
        let mut chars = line.chars().peekable();
        let mut current_word = String::new();

        while let Some(c) = chars.next() {
            if c.is_alphanumeric() || c == '_' {
                current_word.push(c);
            } else {
                if !current_word.is_empty() {
                    result.push_str(&highlight_word(&current_word));
                    current_word.clear();
                }
                // Highlight strings
                if c == '"' {
                    result.push_str(&format!("{}", "\"".green()));
                    let mut string_content = String::new();
                    while let Some(&next) = chars.peek() {
                        chars.next();
                        if next == '"' {
                            result.push_str(&format!("{}", string_content.green()));
                            result.push_str(&format!("{}", "\"".green()));
                            break;
                        } else if next == '\\' {
                            string_content.push(next);
                            if let Some(escaped) = chars.next() {
                                string_content.push(escaped);
                            }
                        } else {
                            string_content.push(next);
                        }
                    }
                }
                // Highlight comments
                else if c == '/' && chars.peek() == Some(&'/') {
                    result.push_str(&format!(
                        "{}",
                        format!("//{}", chars.collect::<String>()).dimmed()
                    ));
                    break;
                }
                // Highlight operators
                else if "=+-*/<>!&|".contains(c) {
                    result.push_str(&format!("{}", c.to_string().yellow()));
                }
                // Parentheses and brackets
                else if "()[]{}".contains(c) {
                    result.push_str(&format!("{}", c.to_string().cyan()));
                } else {
                    result.push(c);
                }
            }
        }

        if !current_word.is_empty() {
            result.push_str(&highlight_word(&current_word));
        }

        Cow::Owned(result)
    }

    fn highlight_prompt<'b, 's: 'b, 'p: 'b>(
        &'s self,
        prompt: &'p str,
        _default: bool,
    ) -> Cow<'b, str> {
        Cow::Owned(format!("{}", prompt.cyan().bold()))
    }

    fn highlight_hint<'h>(&self, hint: &'h str) -> Cow<'h, str> {
        Cow::Owned(format!("{}", hint.dimmed()))
    }

    fn highlight_char(
        &self,
        _line: &str,
        _pos: usize,
        _forced: rustyline::highlight::CmdKind,
    ) -> bool {
        true
    }
}

fn highlight_word(word: &str) -> String {
    // Rhai keywords
    if RHAI_KEYWORDS.contains(&word) {
        return format!("{}", word.magenta().bold());
    }

    // Zinit functions
    if word.starts_with("zinit_") {
        return format!("{}", word.blue().bold());
    }

    // Built-in functions
    if [
        "print",
        "sleep",
        "sleep_ms",
        "get_env",
        "set_env",
        "file_exists",
        "is_dir",
        "is_file",
        "check_tcp",
        "check_http",
        "kill_port",
    ]
    .contains(&word)
    {
        return format!("{}", word.blue());
    }

    // Numbers
    if word.chars().all(|c| c.is_numeric() || c == '.') {
        return format!("{}", word.yellow());
    }

    // Booleans
    if word == "true" || word == "false" {
        return format!("{}", word.yellow().bold());
    }

    word.to_string()
}

impl Validator for ReplHelper {}

/// Print the welcome banner
fn print_banner() {
    println!(
        "{}",
        "╔═══════════════════════════════════════════════════════════╗".cyan()
    );
    println!(
        "{}",
        "║           Zinit Interactive Shell                         ║".cyan()
    );
    println!(
        "{}",
        "╠═══════════════════════════════════════════════════════════╣".cyan()
    );
    println!(
        "{}  {}",
        "║".cyan(),
        format!(
            "{:<56} {}",
            "Tab: completion | Up/Down: history | Ctrl+D: exit", "║"
        )
        .cyan()
    );
    println!(
        "{}  {}",
        "║".cyan(),
        format!(
            "{:<56} {}",
            "Type /help for commands, /functions for API", "║"
        )
        .cyan()
    );
    println!(
        "{}",
        "╚═══════════════════════════════════════════════════════════╝".cyan()
    );
    println!();
}

/// Print help
fn print_help() {
    println!("{}", "REPL Commands:".yellow().bold());
    for (cmd, desc) in REPL_COMMANDS {
        println!("  {:15} {}", cmd.cyan(), desc);
    }
    println!();
    println!("{}", "Tips:".yellow().bold());
    println!("  - Press {} to autocomplete function names", "Tab".cyan());
    println!("  - Use {} arrows for command history", "Up/Down".cyan());
    println!(
        "  - Multi-line input: end lines with {} or {}",
        "\\".cyan(),
        "{".cyan()
    );
    println!("  - Scripts execute when you press Enter on complete statement",);
}

/// Print all functions
fn print_functions() {
    println!("{}", "Zinit Functions:".yellow().bold());
    println!();

    println!("  {}", "Control:".green().bold());
    for (func, ret, desc) in ZINIT_FUNCTIONS.iter().take(2) {
        println!(
            "    {:40} {} {:15} {}",
            func.blue(),
            "->".dimmed(),
            ret,
            desc.dimmed()
        );
    }

    println!();
    println!("  {}", "Service Management:".green().bold());
    for (func, ret, desc) in ZINIT_FUNCTIONS.iter().skip(2).take(7) {
        println!(
            "    {:40} {} {:15} {}",
            func.blue(),
            "->".dimmed(),
            ret,
            desc.dimmed()
        );
    }

    println!();
    println!("  {}", "Query:".green().bold());
    for (func, ret, desc) in ZINIT_FUNCTIONS.iter().skip(9).take(4) {
        println!(
            "    {:40} {} {:15} {}",
            func.blue(),
            "->".dimmed(),
            ret,
            desc.dimmed()
        );
    }

    println!();
    println!("  {}", "Batch:".green().bold());
    for (func, ret, desc) in ZINIT_FUNCTIONS.iter().skip(13).take(2) {
        println!(
            "    {:40} {} {:15} {}",
            func.blue(),
            "->".dimmed(),
            ret,
            desc.dimmed()
        );
    }

    println!();
    println!("  {}", "Logging:".green().bold());
    for (func, ret, desc) in ZINIT_FUNCTIONS.iter().skip(15).take(2) {
        println!(
            "    {:40} {} {:15} {}",
            func.blue(),
            "->".dimmed(),
            ret,
            desc.dimmed()
        );
    }

    println!();
    println!("  {}", "Utilities:".green().bold());
    for (func, ret, desc) in ZINIT_FUNCTIONS.iter().skip(17) {
        println!(
            "    {:40} {} {:15} {}",
            func.blue(),
            "->".dimmed(),
            ret,
            desc.dimmed()
        );
    }
}

/// Print builder methods
fn print_builder() {
    println!("{}", "Service Builder Pattern:".yellow().bold());
    println!();
    println!("  let svc = {}()", "zinit_service_new".blue());
    for (method, desc) in BUILDER_METHODS {
        println!("      {:30} // {}", method.cyan(), desc.dimmed());
    }
    println!();
    println!("  Example:");
    println!("    let svc = {}()", "zinit_service_new".blue());
    println!("        {}", ".name(\"myservice\")".cyan());
    println!("        {}", ".exec(\"python -m http.server 8080\")".cyan());
    println!("        {}", ".test_tcp(\"127.0.0.1:8080\")".cyan());
    println!("        {}", ".register();".cyan());
    println!("    {}", "svc.wait(30);".cyan());
}

/// Load and execute a script file
fn load_script(file_path: &str, engine: &ZinitEngine) -> anyhow::Result<()> {
    // Expand ~ to home directory
    let expanded_path = if file_path.starts_with("~/") {
        dirs::home_dir()
            .map(|h| h.join(&file_path[2..]))
            .unwrap_or_else(|| std::path::PathBuf::from(file_path))
    } else {
        std::path::PathBuf::from(file_path)
    };

    if !expanded_path.exists() {
        anyhow::bail!("File not found: {}", expanded_path.display());
    }

    println!("{} {}", "Loading:".green(), expanded_path.display());

    match engine.run_file(&expanded_path) {
        Ok(result) => {
            if !result.is_unit() {
                println!("{} {:?}", "=>".green(), result);
            }
            Ok(())
        }
        Err(e) => {
            anyhow::bail!("{}", e)
        }
    }
}

/// Run the interactive REPL
pub fn run_repl(handle: ZinitHandle) -> anyhow::Result<()> {
    print_banner();

    // Check if server is running
    match handle.ping() {
        Ok(resp) => {
            println!(
                "{} {} v{}",
                "Connected to zinit server:".green(),
                resp.message,
                resp.version
            );
        }
        Err(e) => {
            println!(
                "{}: {}",
                "Warning: Could not connect to zinit server".yellow(),
                e
            );
            println!("Make sure the server is running with: zinit server start");
        }
    }
    println!();

    // Create the Rhai engine with the handle
    let engine = ZinitEngine::with_handle(handle.clone());

    let config = Config::builder()
        .history_ignore_space(true)
        .completion_type(rustyline::CompletionType::List)
        .edit_mode(rustyline::EditMode::Emacs)
        .build();

    let helper = ReplHelper {
        hinter: HistoryHinter::new(),
    };

    let mut rl: Editor<ReplHelper, DefaultHistory> = Editor::with_config(config)?;
    rl.set_helper(Some(helper));

    // Load history
    let history_path = dirs::home_dir()
        .map(|h| h.join(".zinit_history"))
        .unwrap_or_else(|| std::path::PathBuf::from(".zinit_history"));
    let _ = rl.load_history(&history_path);

    let mut multiline_buffer = String::new();

    loop {
        let prompt = if multiline_buffer.is_empty() {
            "zinit> "
        } else {
            "   ... "
        };

        match rl.readline(prompt) {
            Ok(line) => {
                let line = line.trim();

                // Handle REPL commands
                if multiline_buffer.is_empty() {
                    match line {
                        "/help" => {
                            print_help();
                            continue;
                        }
                        "/functions" => {
                            print_functions();
                            continue;
                        }
                        "/builder" => {
                            print_builder();
                            continue;
                        }
                        "/clear" => {
                            print!("\x1B[2J\x1B[1;1H");
                            print_banner();
                            continue;
                        }
                        "/tui" => {
                            // Enter TUI mode
                            match crate::tui::run_tui(handle.clone()) {
                                Ok(_) => {
                                    // After TUI exits, reprint banner
                                    print_banner();
                                }
                                Err(e) => {
                                    println!("{}: {}", "TUI Error".red().bold(), e);
                                }
                            }
                            continue;
                        }
                        "/quit" | "/exit" | "/q" => {
                            println!("{}", "Goodbye!".cyan());
                            break;
                        }
                        "" => continue,
                        _ if line.starts_with("/load ") => {
                            let file_path = line.strip_prefix("/load ").unwrap().trim();
                            match load_script(file_path, &engine) {
                                Ok(_) => {}
                                Err(e) => println!("{}: {}", "Error".red().bold(), e),
                            }
                            println!();
                            continue;
                        }
                        _ if line.starts_with('/') => {
                            println!(
                                "{}: Unknown command '{}'. Type /help for commands.",
                                "Error".red().bold(),
                                line
                            );
                            continue;
                        }
                        _ => {}
                    }
                }

                // Add to multiline buffer
                multiline_buffer.push_str(line);
                multiline_buffer.push('\n');

                // Check if we should continue multiline input
                let trimmed = line.trim_end();
                if trimmed.ends_with('\\') {
                    // Remove the backslash and continue
                    multiline_buffer = multiline_buffer
                        .trim_end()
                        .strip_suffix('\\')
                        .unwrap_or(&multiline_buffer)
                        .to_string();
                    multiline_buffer.push('\n');
                    continue;
                }

                // Check for unclosed braces/brackets
                let open_braces = multiline_buffer.matches('{').count();
                let close_braces = multiline_buffer.matches('}').count();
                let open_brackets = multiline_buffer.matches('[').count();
                let close_brackets = multiline_buffer.matches(']').count();
                let open_parens = multiline_buffer.matches('(').count();
                let close_parens = multiline_buffer.matches(')').count();

                if open_braces > close_braces
                    || open_brackets > close_brackets
                    || open_parens > close_parens
                {
                    continue;
                }

                // Execute the script
                let script = std::mem::take(&mut multiline_buffer);
                let script = script.trim();

                if script.is_empty() {
                    continue;
                }

                // Add to history
                let _ = rl.add_history_entry(script);

                // Execute with Rhai engine
                match engine.run(script) {
                    Ok(result) => {
                        if !result.is_unit() {
                            println!("{} {:?}", "=>".green(), result);
                        }
                    }
                    Err(e) => {
                        println!("{}: {}", "Error".red().bold(), e);
                    }
                }
                println!();
            }
            Err(ReadlineError::Interrupted) => {
                // Ctrl+C - clear current input
                if !multiline_buffer.is_empty() {
                    multiline_buffer.clear();
                    println!("{}", "^C (input cleared)".dimmed());
                } else {
                    println!("{}", "^C (use /quit or Ctrl+D to exit)".dimmed());
                }
            }
            Err(ReadlineError::Eof) => {
                // Ctrl+D
                println!("{}", "Goodbye!".cyan());
                break;
            }
            Err(err) => {
                println!("{}: {:?}", "Error".red(), err);
                break;
            }
        }
    }

    // Save history
    let _ = rl.save_history(&history_path);

    Ok(())
}