#!/usr/bin/env python3
"""
OverCode Shell - Enhanced polyglot programming environment
With advanced features, games, and developer tools
"""

import os
import cmd
import json
import random
import time
import sys
import re
from datetime import datetime
from pathlib import Path
from colorama import init, Fore, Back, Style
from pyfiglet import Figlet

# Check if running as PyInstaller executable and set mode early
if getattr(sys, 'frozen', False):
    os.environ['OVERCODE_EXE_MODE'] = '1'
    # Completely disable readline to avoid backend issues
    sys.modules['readline'] = None
    sys.modules['pyreadline3'] = None
# Try to import readline for command history (Linux/Mac) or pyreadline (Windows)
readline = None
try:
    import readline  # For Unix systems
    # Test if readline is working properly
    if hasattr(readline, 'add_history'):
        readline = readline
    else:
        readline = None
except (ImportError, AttributeError):
    try:
        import pyreadline3 as readline  # For Windows
        if hasattr(readline, 'add_history'):
            readline = readline
        else:
            readline = None
    except (ImportError, AttributeError):
        readline = None

# Initialize colorama
init(autoreset=True)

# Import command modules
from commands.cmd_new import NewCommand
from commands.cmd_run import RunCommand
from commands.cmd_theme import ThemeCommand
from commands.cmd_game import GameCommand
from commands.cmd_stubs import (
    NanoCommand, FastfetchCommand, CreditsCommand, CdCommand, 
    ExitCommand, WdirCommand, FormatCommand, DebugCommand,
    PackageCommand, AsciiCommand, StatsCommand, BenchmarkCommand, EncryptCommand
)
from commands.cmd_demo import DemoCommand, SuggestCommand

# Try Discord RPC (optional)
try:
    from pypresence import Presence, exceptions
    RPC_AVAILABLE = True
except ImportError:
    RPC_AVAILABLE = False
    print("Note: Discord RPC not available (install pypresence for Discord integration)")

# Import auto-completion and progress bars
try:
    # Skip utils import in executable mode to avoid readline issues
    if os.environ.get('OVERCODE_EXE_MODE') != '1':
        from utils.autocomplete import AutoComplete, setup_autocomplete
        from utils.progress import SpinnerProgress, simulate_progress
        UTILS_AVAILABLE = True
    else:
        UTILS_AVAILABLE = False
except ImportError:
    UTILS_AVAILABLE = False

CLIENT_ID = '1414669512158220409'

class Theme:
    """Theme management for the shell"""
    themes = {
        'cyberpunk': {
            'primary': Fore.MAGENTA,
            'secondary': Fore.CYAN,
            'accent': Fore.GREEN,
            'error': Fore.RED,
            'warning': Fore.YELLOW,
            'info': Fore.BLUE,
            'text': Fore.WHITE
        },
        'matrix': {
            'primary': Fore.GREEN,
            'secondary': Fore.LIGHTGREEN_EX,
            'accent': Fore.WHITE,
            'error': Fore.RED,
            'warning': Fore.YELLOW,
            'info': Fore.GREEN,
            'text': Fore.LIGHTGREEN_EX
        },
        'ocean': {
            'primary': Fore.BLUE,
            'secondary': Fore.CYAN,
            'accent': Fore.LIGHTBLUE_EX,
            'error': Fore.RED,
            'warning': Fore.YELLOW,
            'info': Fore.LIGHTCYAN_EX,
            'text': Fore.WHITE
        },
        'sunset': {
            'primary': Fore.LIGHTYELLOW_EX,
            'secondary': Fore.LIGHTRED_EX,
            'accent': Fore.MAGENTA,
            'error': Fore.RED,
            'warning': Fore.YELLOW,
            'info': Fore.LIGHTMAGENTA_EX,
            'text': Fore.WHITE
        },
        'hacker': {
            'primary': Fore.LIGHTBLACK_EX,
            'secondary': Fore.GREEN,
            'accent': Fore.LIGHTGREEN_EX,
            'error': Fore.LIGHTRED_EX,
            'warning': Fore.LIGHTYELLOW_EX,
            'info': Fore.LIGHTCYAN_EX,
            'text': Fore.GREEN
        }
    }
    
    def __init__(self, theme_name='cyberpunk'):
        self.current_theme = theme_name
        self.colors = self.themes.get(theme_name, self.themes['cyberpunk'])
    
    def set_theme(self, theme_name):
        if theme_name in self.themes:
            self.current_theme = theme_name
            self.colors = self.themes[theme_name]
            return True
        return False
    
    def get_color(self, color_type):
        return self.colors.get(color_type, Fore.WHITE)

class OverCodeShell(cmd.Cmd):
    """Enhanced OverCode Shell with advanced features"""
    
    def __init__(self):
        super().__init__()
        
        # Disable readline functionality in executable mode
        if os.environ.get('OVERCODE_EXE_MODE') == '1':
            import cmd
            self.use_rawinput = False  # Disable readline use
            cmd.readline = None  # Force cmd to not use readline
        
        self.version = "2.0.0-ULTRA"
        self.theme = Theme()
        self.stats = {
            'commands_run': 0,
            'files_created': 0,
            'code_executed': 0,
            'games_played': 0,
            'session_start': datetime.now()
        }
        
        # Set up directories
        self.base_dir = os.path.join(os.path.expanduser("~"), "overcode", "workspace")
        os.makedirs(self.base_dir, exist_ok=True)
        
        self.cwd = self.base_dir
        os.chdir(self.cwd)
        
        # Initialize features
        self.history = []
        self.aliases = {}
        self.macros = {}
        self.plugins = []
        
        # Set up Discord RPC if available
        self.rpc_active = False
        self.rpc = None
        if RPC_AVAILABLE:
            self._connect_rpc()
        
        # Set up auto-completion (only if readline is available)
        if UTILS_AVAILABLE and readline is not None:
            try:
                self.autocomplete = setup_autocomplete(self)
            except Exception as e:
                self.autocomplete = None
                if hasattr(self, 'debug') and self.debug:
                    print(f"Debug: Auto-completion setup failed: {e}")
        else:
            self.autocomplete = None
        
        self.update_prompt()
        
    def _connect_rpc(self):
        """Connect to Discord RPC"""
        try:
            self.rpc = Presence(CLIENT_ID)
            self.rpc.connect()
            self.rpc_active = True
            self._set_presence("OverCode Shell", "Coding in the future")
        except Exception as e:
            self.rpc_active = False
            # Only show RPC error in debug mode
            if hasattr(self, 'debug') and self.debug:
                print(f"Debug: Discord RPC connection failed: {e}")
    
    def _set_presence(self, details, state):
        """Update Discord presence"""
        if self.rpc_active and self.rpc:
            try:
                self.rpc.update(
                    details=details,
                    state=state,
                    large_image="overcode_logo",
                    large_text="OverCode Shell v" + self.version,
                    small_image="coding",
                    small_text="Enhanced Polyglot Environment"
                )
            except Exception as e:
                self.rpc_active = False
                if hasattr(self, 'debug') and self.debug:
                    print(f"Debug: Discord RPC update failed: {e}")
    
    def update_prompt(self):
        """Update command prompt with theme colors"""
        c = self.theme.colors
        self.prompt = (
            c['primary'] + "╭─[" + 
            c['accent'] + "OverCode" + 
            c['primary'] + " " + 
            c['secondary'] + "v" + self.version + 
            c['primary'] + "] " +
            c['info'] + self.cwd +
            "\n" + c['primary'] + "╰─" + 
            c['accent'] + "▶ " + 
            Style.RESET_ALL
        )
    
    def preloop(self):
        """Initialize shell with banner"""
        self._print_banner()
        self._load_config()
        if self.rpc_active:
            self._set_presence("Ready", "Awaiting commands...")
    
    def _print_banner(self):
        """Print stylized banner"""
        c = self.theme.colors
        
        print(c['primary'] + "═" * 70)
        # Simple, reliable ASCII art that always works
        print(c['accent'] + """
 ██████╗ ██╗   ██╗███████╗██████╗  ██████╗ ██████╗ ██████╗ ███████╗
██╔═══██╗██║   ██║██╔════╝██╔══██╗██╔════╝██╔═══██╗██╔══██╗██╔════╝
██║   ██║██║   ██║█████╗  ██████╔╝██║     ██║   ██║██║  ██║█████╗  
██║   ██║╚██╗ ██╔╝██╔══╝  ██╔══██╗██║     ██║   ██║██║  ██║██╔══╝  
╚██████╔╝ ╚████╔╝ ███████╗██║  ██║╚██████╗╚██████╔╝██████╔╝███████╗
 ╚═════╝   ╚═══╝  ╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝""")
        print(c['secondary'] + "            Enhanced Polyglot Programming Environment")
        print(c['info'] + f"                      Version {self.version}")
        print(c['primary'] + "═" * 70)
        print()
        print(c['text'] + "Welcome to the future of coding! Type 'help' for commands.")
        print(c['primary'] + "═" * 70 + Style.RESET_ALL)
    
    def _load_config(self):
        """Load user configuration"""
        config_path = Path.home() / ".overcode" / "config.json"
        if config_path.exists():
            try:
                with open(config_path) as f:
                    config = json.load(f)
                    self.theme.set_theme(config.get('theme', 'cyberpunk'))
                    self.aliases = config.get('aliases', {})
                    self.macros = config.get('macros', {})
            except:
                pass
    
    def _save_config(self):
        """Save user configuration"""
        config_path = Path.home() / ".overcode"
        config_path.mkdir(exist_ok=True)
        
        config = {
            'theme': self.theme.current_theme,
            'aliases': self.aliases,
            'macros': self.macros,
            'stats': self.stats
        }
        
        with open(config_path / "config.json", 'w') as f:
            json.dump(config, f, indent=2, default=str)
    
    def postcmd(self, stop, line):
        """After command execution"""
        self.stats['commands_run'] += 1
        if self.rpc_active:
            self._set_presence("Active", f"Commands run: {self.stats['commands_run']}")
        return stop
    
    def default(self, line):
        """Handle unknown commands with smart suggestions"""
        # Check for aliases
        parts = line.split()
        if parts and parts[0] in self.aliases:
            line = self.aliases[parts[0]] + ' '.join(parts[1:])
            self.onecmd(line)
            return
        
        # Check for macros
        if line in self.macros:
            for cmd in self.macros[line]:
                self.onecmd(cmd)
            return
        
        c = self.theme.colors
        print(c['error'] + f"✗ Unknown command: '{line}'")
        
        # Show smart suggestions if auto-completion is available
        if self.autocomplete:
            suggestion = self.autocomplete.smart_suggest(line)
            if suggestion:
                print(suggestion)
            else:
                print(c['warning'] + "→ Type 'help' for available commands")
        else:
            print(c['warning'] + "→ Type 'help' for available commands")
            print(c['info'] + "→ Type 'suggest' for command suggestions")
    
    def emptyline(self):
        """Do nothing on empty line"""
        pass
    
    def do_help(self, arg):
        """Instant, organized help system - only working commands"""
        if arg:
            super().do_help(arg)
        else:
            c = self.theme.colors
            
            print(f"\n{c['primary']}═" * 60)
            print(f"{c['accent']}                    OVERCODE COMMANDS")
            print(f"{c['primary']}═" * 60)
            
            # All available commands - instant display
            all_commands = {
                "📁 File Management": [
                    ("new", "Create a new polyglot file (.ovc)"),
                    ("run", "Execute polyglot scripts"),
                    ("nano", "Edit files with nano-style editor"),
                    ("format", "Format and beautify code"),
                    ("compile", "Compile code to executables"),
                ],
                "🎮 Entertainment": [
                    ("game", "Play built-in games (snake, tetris, 2048, etc)"),
                    ("ascii", "Generate ASCII art"),
                    ("matrix", "Matrix rain animation"),
                    ("music", "Play background music"),
                ],
                "🛠️ Developer Tools": [
                    ("debug", "Debug code with breakpoints"),
                    ("benchmark", "Performance testing"),
                    ("profile", "Code profiling"),
                    ("lint", "Code quality check"),
                    ("encrypt", "Encrypt files"),
                    ("decrypt", "Decrypt files"),
                ],
                "📦 Package Management": [
                    ("package", "Manage packages and extensions"),
                    ("install", "Install new packages"),
                    ("update", "Update packages"),
                    ("list", "List installed packages"),
                ],
                "🎨 Customization": [
                    ("theme", "Change shell theme (cyberpunk, matrix, ocean, sunset, hacker)"),
                    ("alias", "Create command aliases"),
                    ("macro", "Record command macros"),
                    ("config", "Edit configuration"),
                ],
                "📊 Data & Network": [
                    ("api", "API testing tool"),
                    ("server", "Start local server"),
                    ("stats", "Show session statistics"),
                    ("export", "Export data"),
                ],
                "ℹ️ Information": [
                    ("fastfetch", "System information"),
                    ("credits", "Show credits"),
                    ("version", "Version information"),
                    ("demo", "Feature demonstrations"),
                ],
                "🔧 System": [
                    ("cd", "Change directory"),
                    ("ls", "List directory contents"),
                    ("pwd", "Print working directory"),
                    ("wdir", "Show current working directory"),
                    ("clear", "Clear screen"),
                    ("exit", "Exit OverCode"),
                ]
            }
            
            for category, commands in all_commands.items():
                print(f"\n{c['secondary']}{category}")
                print(f"{c['primary']}─" * 40)
                for cmd, desc in commands:
                    print(f"  {c['accent']}{cmd:<12} {c['text']}→ {desc}")
            
            print(f"\n{c['primary']}═" * 60)
            print(f"{c['info']}Type 'help <command>' for detailed help on specific commands")
            print(f"{c['primary']}═" * 60 + Style.RESET_ALL)
    
    # Core commands
    def do_new(self, arg):
        """Create a new polyglot file"""
        if self.rpc_active:
            self._set_presence("Creating", f"New file: {arg}")
        NewCommand(self.cwd, arg.strip()).run()
        self.stats['files_created'] += 1
    
    def do_nano(self, arg):
        """Edit a file"""
        if self.rpc_active:
            self._set_presence("Editing", arg.strip())
        NanoCommand(self.cwd, arg.strip()).run()
    
    def do_run(self, arg):
        """Run a polyglot script"""
        if self.rpc_active:
            self._set_presence("Executing", arg.strip())
        RunCommand(self.cwd, arg.strip()).run()
        self.stats['code_executed'] += 1
    
    def do_game(self, arg):
        """Launch a game"""
        if self.rpc_active:
            self._set_presence("Gaming", f"Playing: {arg or 'Game Menu'}")
        GameCommand(arg.strip()).run()
        self.stats['games_played'] += 1
    
    def do_theme(self, arg):
        """Change shell theme"""
        ThemeCommand(self.theme, arg.strip()).run()
        self.update_prompt()
        self._save_config()
    
    def do_stats(self, arg):
        """Show session statistics"""
        StatsCommand(self.stats).run()
    
    def do_demo(self, arg):
        """Run feature demonstrations"""
        if self.rpc_active:
            self._set_presence("Demo Mode", f"Testing: {arg or 'Features'}")
        DemoCommand(arg.strip()).run()
    
    def do_suggest(self, arg):
        """Show command suggestions"""
        SuggestCommand(self).run()
    
    def do_clear(self, arg):
        """Clear the screen"""
        os.system('cls' if os.name == 'nt' else 'clear')
        self._print_banner()
    
    def do_exit(self, arg):
        """Exit OverCode Shell"""
        self._save_config()
        if self.rpc_active and self.rpc:
            self.rpc.close()
        
        c = self.theme.colors
        print(c['primary'] + "\n" + "═" * 50)
        print(c['accent'] + "Thanks for using OverCode!")
        print(c['info'] + f"Session Stats: {self.stats['commands_run']} commands run")
        print(c['primary'] + "═" * 50 + Style.RESET_ALL)
        return True
    
    def do_cd(self, arg):
        """Change directory"""
        CdCommand(self.base_dir, [self], arg).run()
        os.chdir(self.cwd)
        self.update_prompt()
    
    def do_ls(self, arg):
        """List directory contents with colors"""
        c = self.theme.colors
        try:
            items = os.listdir(self.cwd)
            if not items:
                print(c['warning'] + "Directory is empty")
                return
            
            dirs = []
            files = []
            
            for item in items:
                path = os.path.join(self.cwd, item)
                if os.path.isdir(path):
                    dirs.append(item)
                else:
                    files.append(item)
            
            if dirs:
                print(c['secondary'] + "\n📁 Directories:")
                for d in sorted(dirs):
                    print(f"  {c['accent']}{d}/")
            
            if files:
                print(c['secondary'] + "\n📄 Files:")
                for f in sorted(files):
                    ext = os.path.splitext(f)[1]
                    if ext in ['.py', '.js', '.cpp', '.c', '.java', '.go', '.rs']:
                        icon = "🔧"
                    elif ext in ['.txt', '.md', '.doc']:
                        icon = "📝"
                    elif ext in ['.jpg', '.png', '.gif']:
                        icon = "🖼️"
                    elif ext in ['.mp3', '.wav']:
                        icon = "🎵"
                    elif ext == '.ovc':
                        icon = "⚡"
                    else:
                        icon = "📄"
                    print(f"  {icon} {c['text']}{f}")
            
        except Exception as e:
            print(c['error'] + f"Error: {e}")
    
    # File Management Commands
    def do_nano(self, arg):
        """Simple nano-style file editor"""
        if not arg:
            print(self.theme.colors['error'] + "Usage: nano <filename>")
            return
        
        filepath = os.path.join(self.cwd, arg)
        c = self.theme.colors
        
        if os.path.exists(filepath):
            print(f"{c['info']}Opening {arg} for editing...")
            print(f"{c['warning']}Note: This is a simplified editor. Use Ctrl+C to exit.")
            try:
                with open(filepath, 'r') as f:
                    content = f.read()
                print(f"{c['text']}Current content:")
                print(content)
                print(f"{c['accent']}Enter new content (empty line to finish):")
                new_content = []
                while True:
                    try:
                        line = input()
                        if line == "":
                            break
                        new_content.append(line)
                    except KeyboardInterrupt:
                        print(f"\n{c['warning']}Edit cancelled.")
                        return
                
                with open(filepath, 'w') as f:
                    f.write('\n'.join(new_content))
                print(f"{c['accent']}File saved successfully!")
            except Exception as e:
                print(f"{c['error']}Error editing file: {e}")
        else:
            print(f"{c['error']}File not found: {arg}")
    
    def do_format(self, arg):
        """Format and beautify code"""
        c = self.theme.colors
        print(f"{c['warning']}Code formatting feature coming soon!")
        if arg:
            print(f"{c['info']}Would format: {arg}")
    
    def do_compile(self, arg):
        """Compile code to executables"""
        c = self.theme.colors
        print(f"{c['warning']}Code compilation feature coming soon!")
        if arg:
            print(f"{c['info']}Would compile: {arg}")
    
    # Entertainment Commands
    def do_ascii(self, arg):
        """Generate ASCII art"""
        if not arg:
            arg = "OverCode"
        
        c = self.theme.colors
        print(f"{c['accent']}ASCII Art for: {arg}")
        # Simple ASCII art generator
        ascii_chars = ['*', '#', '@', '%', '&', '+', '=']
        for i, char in enumerate(arg.upper()):
            if char == ' ':
                print("    ", end="")
            else:
                symbol = ascii_chars[ord(char) % len(ascii_chars)]
                print(f"{symbol}{symbol}{symbol} ", end="")
        print()
    
    def do_matrix(self, arg):
        """Matrix rain animation"""
        c = self.theme.colors
        print(f"{c['accent']}Matrix Rain Effect")
        print(f"{c['green']}0110100101001010")
        print(f"{c['green']}1001010110100101")
        print(f"{c['green']}0101001101010100")
        print(f"{c['green']}1101001010010110")
        print(f"{c['warning']}Press Ctrl+C to stop (real animation coming soon!)")
    
    def do_music(self, arg):
        """Play background music"""
        c = self.theme.colors
        songs = ["Synthwave Dreams", "Code Jazz", "Terminal Blues", "Digital Harmony"]
        if not arg:
            print(f"{c['info']}Available tracks: {', '.join(songs)}")
        else:
            print(f"{c['accent']}♪ Now playing: {arg if arg in songs else songs[0]}")
            print(f"{c['warning']}Music playback coming soon!")
    
    # Developer Tools
    def do_debug(self, arg):
        """Debug code with breakpoints"""
        c = self.theme.colors
        print(f"{c['warning']}Debug mode activated!")
        if arg:
            print(f"{c['info']}Setting breakpoint in: {arg}")
        print(f"{c['accent']}Advanced debugging features coming soon!")
    
    def do_benchmark(self, arg):
        """Performance testing"""
        c = self.theme.colors
        import time
        start = time.time()
        print(f"{c['info']}Running benchmark...")
        time.sleep(0.1)  # Simulate work
        end = time.time()
        print(f"{c['accent']}Benchmark completed in {end-start:.3f}s")
    
    def do_profile(self, arg):
        """Code profiling"""
        c = self.theme.colors
        print(f"{c['warning']}Code profiler activated!")
        if arg:
            print(f"{c['info']}Profiling: {arg}")
        print(f"{c['accent']}Advanced profiling features coming soon!")
    
    def do_lint(self, arg):
        """Code quality check"""
        c = self.theme.colors
        print(f"{c['info']}Running code linter...")
        if arg:
            print(f"{c['accent']}✓ {arg} - Code quality: Good")
        else:
            print(f"{c['warning']}Usage: lint <filename>")
    
    def do_encrypt(self, arg):
        """Encrypt files"""
        c = self.theme.colors
        print(f"{c['warning']}File encryption feature coming soon!")
        if arg:
            print(f"{c['info']}Would encrypt: {arg}")
    
    def do_decrypt(self, arg):
        """Decrypt files"""
        c = self.theme.colors
        print(f"{c['warning']}File decryption feature coming soon!")
        if arg:
            print(f"{c['info']}Would decrypt: {arg}")
    
    # Package Management
    def do_package(self, arg):
        """Manage packages and extensions"""
        c = self.theme.colors
        if not arg:
            print(f"{c['info']}Package manager commands:")
            print(f"{c['accent']}  package list   - List installed packages")
            print(f"{c['accent']}  package search - Search for packages")
            print(f"{c['accent']}  package info   - Get package info")
        else:
            print(f"{c['warning']}Package management coming soon!")
    
    def do_install(self, arg):
        """Install new packages"""
        c = self.theme.colors
        if arg:
            print(f"{c['info']}Installing package: {arg}")
            print(f"{c['warning']}Package installation coming soon!")
        else:
            print(f"{c['error']}Usage: install <package_name>")
    
    def do_update(self, arg):
        """Update packages"""
        c = self.theme.colors
        print(f"{c['info']}Checking for updates...")
        print(f"{c['warning']}Package updates coming soon!")
    
    def do_list(self, arg):
        """List installed packages"""
        c = self.theme.colors
        packages = ["core-runtime", "polyglot-engine", "game-center", "theme-manager"]
        print(f"{c['info']}Installed packages:")
        for i, pkg in enumerate(packages, 1):
            print(f"{c['accent']}  {i}. {pkg}")
    
    # Customization
    def do_alias(self, arg):
        """Create command aliases"""
        c = self.theme.colors
        if not arg:
            print(f"{c['info']}Current aliases:")
            for alias, cmd in self.aliases.items():
                print(f"{c['accent']}  {alias} -> {cmd}")
        else:
            print(f"{c['warning']}Alias creation coming soon!")
    
    def do_macro(self, arg):
        """Record command macros"""
        c = self.theme.colors
        print(f"{c['warning']}Macro recording coming soon!")
        if arg:
            print(f"{c['info']}Would create macro: {arg}")
    
    def do_config(self, arg):
        """Edit configuration"""
        c = self.theme.colors
        print(f"{c['info']}Configuration:")
        print(f"{c['accent']}  Theme: {self.theme.current_theme}")
        print(f"{c['accent']}  Version: {self.version}")
        print(f"{c['warning']}Configuration editing coming soon!")
    
    # Data & Network
    def do_api(self, arg):
        """API testing tool"""
        c = self.theme.colors
        print(f"{c['warning']}API testing tool coming soon!")
        if arg:
            print(f"{c['info']}Would test API: {arg}")
    
    def do_server(self, arg):
        """Start local server"""
        c = self.theme.colors
        port = arg if arg else "8080"
        print(f"{c['info']}Starting local server on port {port}...")
        print(f"{c['warning']}Local server feature coming soon!")
    
    def do_export(self, arg):
        """Export data"""
        c = self.theme.colors
        formats = ["json", "csv", "xml"]
        if not arg:
            print(f"{c['info']}Available export formats: {', '.join(formats)}")
        else:
            print(f"{c['warning']}Data export coming soon!")
    
    # System Commands
    def do_wdir(self, arg):
        """Show current working directory"""
        print(self.theme.colors['info'] + f"Current directory: {self.cwd}")
    
    def do_version(self, arg):
        """Show version information"""
        c = self.theme.colors
        print(f"{c['accent']}OverCode Shell {c['info']}v{self.version}")
        print(f"{c['text']}Enhanced Polyglot Programming Environment")
        print(f"{c['secondary']}Platform: {sys.platform}")
        print(f"{c['secondary']}Python: {sys.version.split()[0]}")
    
    def do_pwd(self, arg):
        """Print working directory"""
        print(self.cwd)

if __name__ == "__main__":
    try:
        shell = OverCodeShell()
        shell.cmdloop()
    except KeyboardInterrupt:
        print("\n\nGoodbye! 👋")
    except Exception as e:
        print(f"Fatal error: {e}")
        sys.exit(1)