cli_client.py

#!/usr/bin/env python3
"""
BasiCoCo - CLI Client
A standalone terminal interface for the BASIC emulator that connects to the Flask-SocketIO server.
"""

import glob
import socketio
import readline
import os
import re
import threading

from emulator.config import DEFAULT_PORT

class TRS80CLI:
    def __init__(self, host='localhost', port=DEFAULT_PORT):
        self.host = host
        self.port = port
        # handle_sigint=False: engine.io's own SIGINT handler disconnects every
        # client, so Ctrl+C (BREAK) would drop the connection instead of
        # reaching our KeyboardInterrupt handling
        self.sio = socketio.Client(handle_sigint=False)
        self.connected = False
        self.waiting_for_input = False
        self.input_prompt = ""
        self.input_variable = ""
        self.input_metadata = {}
        self.response_received = threading.Event()
        self.running_program = False
        self.setup_socketio_handlers()
        self.setup_readline()
        
    def setup_readline(self):
        """Configure readline for command history and editing."""
        # Enable history file
        histfile = os.path.join(os.path.expanduser("~"), ".trs80_history")
        try:
            readline.read_history_file(histfile)
            readline.set_history_length(1000)
        except FileNotFoundError:
            pass
        
        # Save history on exit
        import atexit
        atexit.register(readline.write_history_file, histfile)
        
        # Basic tab completion for BASIC keywords and CLI commands
        basic_keywords = [
            'PRINT', 'LET', 'IF', 'THEN', 'ELSE', 'FOR', 'TO', 'NEXT', 'STEP',
            'GOTO', 'GOSUB', 'RETURN', 'END', 'STOP', 'RUN', 'LIST', 'NEW',
            'SAVE', 'LOAD', 'FILES', 'KILL', 'DELETE', 'CD', 'INPUT', 'DATA', 'READ', 'RESTORE', 'DIM',
            'PSET', 'PRESET', 'PMODE', 'PCLS', 'SCREEN', 'COLOR', 'PAINT',
            'LINE', 'CIRCLE', 'DRAW', 'GET', 'PUT', 'CLS', 'SOUND',
            'RND', 'INT', 'ABS', 'SGN', 'SQR', 'SIN', 'COS', 'TAN', 'ATN',
            'LOG', 'EXP', 'LEN', 'MID$', 'LEFT$', 'RIGHT$', 'STR$', 'VAL',
            'CHR$', 'ASC', 'INKEY$', 'POS', 'PEEK', 'POKE',
            'EXIT', 'QUIT', 'BYE'  # CLI convenience commands
        ]
        
        def get_program_names():
            """Get available .bas filenames (without extension) from programs/."""
            names = []
            for d in [os.getcwd(), os.path.join(os.getcwd(), 'programs')]:
                if os.path.isdir(d):
                    for path in glob.glob(os.path.join(d, '*.bas')):
                        name = os.path.basename(path).removesuffix('.bas')
                        if name not in names:
                            names.append(name)
            return sorted(names)

        def complete(text, state):
            buf = readline.get_line_buffer()
            # Check for LOAD/SAVE/KILL filename context (quote optional)
            file_match = re.match(r'(?:\d+\s+)?(LOAD|SAVE|KILL)\s+"?([^"]*)', buf, re.IGNORECASE)
            if file_match:
                partial = file_match.group(2).upper()
                has_quote = '"' in buf
                names = [n for n in get_program_names() if n.upper().startswith(partial)]
                # Wrap completions in quotes
                matches = []
                for n in names:
                    prefix = '' if has_quote else '"'
                    matches.append(prefix + n + '"')
                if state < len(matches):
                    return matches[state]
                return None
            matches = [cmd for cmd in basic_keywords if cmd.startswith(text.upper())]
            if state < len(matches):
                return matches[state]
            return None

        readline.set_completer(complete)
        readline.set_completer_delims(' \t\n')
        readline.parse_and_bind('tab: complete')
    
    def setup_socketio_handlers(self):
        """Set up Socket.IO event handlers."""
        
        @self.sio.event
        def connect():
            self.connected = True
            print("Connected to BasiCoCo")
            print("Type BASIC commands or programs. Press Ctrl+C to exit.")
            print("=" * 60)
        
        @self.sio.event
        def disconnect():
            self.connected = False
            print("\nDisconnected from server")
        
        @self.sio.event
        def output(data):
            """Handle output from the BASIC emulator."""
            for item in data:
                if item['type'] == 'text':
                    if item.get('inline'):
                        # Handle inline text with carriage return
                        text = item['text']
                        if '\r' in text:
                            # Print without newline and flush
                            print(text.replace('\r', ''), end='', flush=True)
                            # Move cursor to beginning of line
                            print('\r', end='', flush=True)
                        else:
                            print(text, end='', flush=True)
                    else:
                        print(item['text'], flush=True)
                elif item['type'] == 'error':
                    print(f"ERROR: {item['message']}")
                elif item['type'] == 'input_request':
                    self.waiting_for_input = True
                    self.input_prompt = item.get('prompt', '?')
                    self.input_variable = item.get('variable', '')
                    # Store any additional metadata (like filename for KILL confirmation)
                    self.input_metadata = {k: v for k, v in item.items() if k not in ['type', 'prompt', 'variable']}
                elif item['type'] == 'sound':
                    # For CLI, just show that sound command was executed
                    print(f"[Sound: {item.get('frequency', 'unknown')} Hz]")
                elif item['type'] == 'clear_screen':
                    # CLS: ANSI clear + cursor home (no subprocess)
                    print('\033[2J\033[H', end='', flush=True)
                elif item['type'] == 'pause':
                    # Handle non-blocking pause - schedule continuation after delay
                    duration = item.get('duration', 1.0)
                    threading.Timer(duration, self.continue_after_pause).start()
            
            # Signal that we've received and processed the response
            # Look for the universal command completion signal
            has_error = any(item.get('type') == 'error' for item in data)
            has_completion_signal = any(item.get('type') == 'command_complete' for item in data)
            has_pause = any(item.get('type') == 'pause' for item in data)
            has_input_request = any(item.get('type') == 'input_request' for item in data)
            
            # Signal completion for: errors, explicit completion, or input requests
            # Don't signal completion if we just received a pause - wait for actual completion
            if (has_error or has_completion_signal or has_input_request) and not has_pause:
                if self.running_program:
                    self.running_program = False
                # Ensure all output is flushed before signaling completion
                import sys
                sys.stdout.flush()
                # Small delay to ensure terminal output is complete
                import time
                time.sleep(0.01)
                self.response_received.set()
            # Don't signal for intermediate responses during program execution - let them stream through
    
    def connect_to_server(self):
        """Connect to the Flask-SocketIO server."""
        try:
            self.sio.connect(f'http://{self.host}:{self.port}')
            return True
        except Exception as e:
            print(f"Failed to connect to server at {self.host}:{self.port}: {e}")
            return False
    
    def _wait_for_response(self):
        """Block until the server signals completion, or the connection drops.

        No fixed timeout: any command can run a program (RUN, GOTO 100,
        CHAIN ...), and output streams in while it runs. Ctrl+C sends BREAK.
        """
        while not self.response_received.wait(timeout=0.5):
            if not self.connected:
                print("Lost connection to the server")
                break
        self.running_program = False

    def send_command(self, command: str):
        """Send a command to the BASIC emulator and wait for it to finish."""
        if self.connected:
            # Any command may run a program, so Ctrl+C means BREAK while waiting
            self.running_program = True
            self.response_received.clear()
            self.sio.emit('execute_command', {'command': command})
            self._wait_for_response()
    
    def send_input_response(self, value: str):
        """Send input response to the BASIC emulator."""
        if self.connected and self.waiting_for_input:
            # Include any metadata in the response
            response = {
                'variable': self.input_variable,
                'value': value
            }
            response.update(self.input_metadata)
            
            self.response_received.clear()  # Reset the event
            self.sio.emit('input_response', response)
            self.waiting_for_input = False
            self.input_prompt = ""
            self.input_variable = ""
            self.input_metadata = {}
            # The program resumes after the answer: Ctrl+C means BREAK again
            self.running_program = True
            self._wait_for_response()
    
    def send_keypress(self, key: str):
        """Send keypress to the BASIC emulator for INKEY$ support."""
        if self.connected:
            self.sio.emit('keypress', {'key': key})
    
    def send_break_signal(self):
        """Send break signal to interrupt running BASIC program."""
        if self.connected:
            print("BREAK")
            self.sio.emit('break_execution')
            self.response_received.set()  # Unblock any waiting operations
    
    def continue_after_pause(self):
        """Continue program execution after a pause completes."""
        if self.connected:
            self.sio.emit('continue_execution')
    
    def run(self):
        """Main CLI loop."""
        if not self.connect_to_server():
            return
        
        try:
            while True:
                try:
                    if self.waiting_for_input:
                        # Handle INPUT requests
                        prompt = f"{self.input_prompt} "
                        user_input = input(prompt)
                        self.send_input_response(user_input)
                    else:
                        # Normal command input
                        command = input("> ")
                        if command.strip():
                            # Handle local EXIT command
                            if command.strip().upper() in ['EXIT', 'QUIT', 'BYE']:
                                print("Goodbye!")
                                break
                            self.send_command(command)
                        
                except EOFError:
                    # Ctrl+D pressed
                    break
                except KeyboardInterrupt:
                    # Ctrl+C pressed
                    if self.running_program or self.waiting_for_input:
                        # Send break signal to interrupt running BASIC program
                        print("\n^C")
                        self.send_break_signal()
                        # Reset states
                        self.running_program = False
                        self.waiting_for_input = False
                        self.input_prompt = ""
                        self.input_variable = ""
                        # Continue CLI (don't break)
                    else:
                        # No program running, exit CLI
                        print("\nInterrupted")
                        break
                    
        except Exception as e:
            print(f"Error in main loop: {e}")
        finally:
            if self.connected:
                self.sio.disconnect()

def main():
    """Entry point for the CLI client."""
    import argparse
    
    parser = argparse.ArgumentParser(description='BasiCoCo CLI Client')
    parser.add_argument('--host', default='localhost', 
                       help='Server host (default: localhost)')
    parser.add_argument('--port', type=int, default=DEFAULT_PORT,
                       help=f'Server port (default: {DEFAULT_PORT})')
    
    args = parser.parse_args()
    
    # Display banner
    print("BASICOCO V1.0")
    print("EDUCATIONAL COLOR COMPUTER BASIC")
    print("INSPIRED BY TANDY/RADIO SHACK")
    print()
    
    cli = TRS80CLI(args.host, args.port)
    cli.run()

if __name__ == '__main__':
    main()