RedScript.py

import os
import sys
import re
import time
import math
import ast
import traceback
import colorsys
from dataclasses import dataclass
from typing import List, Dict, Callable, Optional, Any, Tuple

# PyQt6 imports (make sure PyQt6 is installed)
from PyQt6.QtCore import Qt, QThread, pyqtSignal, QSize, QTimer
from PyQt6.QtGui import QAction, QFont, QColor, QIcon, QKeySequence, QSyntaxHighlighter, QTextCharFormat
from PyQt6.QtWidgets import (
    QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, QPushButton,
    QLabel, QFileDialog, QListWidget, QListWidgetItem, QTabWidget, QPlainTextEdit,
    QSplitter, QInputDialog, QToolBar, QStatusBar, QDialog, QTableWidget,
    QTableWidgetItem, QMessageBox
)
from functools import partial

class InterpreterError(Exception):
    def __init__(self, message: str, line: Optional[int] = None):
        if line is not None:
            message = f"Line {line}: {message}"
        super().__init__(message)
        self.line = line

# Safe evaluator

def safe_eval_expr(expr: str, vars_map: Dict[str, Any]) -> float:
    if expr is None or str(expr).strip() == "":
        raise InterpreterError("Empty expression")
    try:
        node = ast.parse(expr, mode='eval')
    except Exception as e:
        raise InterpreterError(f"Parse error: {e}")

    def _eval(n):
        if isinstance(n, ast.Expression):
            return _eval(n.body)
        if isinstance(n, ast.Constant):
            if isinstance(n.value, (int, float)):
                return float(n.value)
            raise InterpreterError("Only numeric constants allowed")
        if isinstance(n, ast.BinOp):
            left = _eval(n.left)
            right = _eval(n.right)
            if isinstance(n.op, ast.Add):
                return left + right
            if isinstance(n.op, ast.Sub):
                return left - right
            if isinstance(n.op, ast.Mult):
                return left * right
            if isinstance(n.op, ast.Div):
                return left / right
            if isinstance(n.op, ast.Pow):
                return left ** right
            if isinstance(n.op, ast.Mod):
                return left % right
            raise InterpreterError("Unsupported binary operator")
        if isinstance(n, ast.UnaryOp):
            v = _eval(n.operand)
            if isinstance(n.op, ast.UAdd):
                return +v
            if isinstance(n.op, ast.USub):
                return -v
            raise InterpreterError("Unsupported unary operator")
        if isinstance(n, ast.Name):
            if n.id in vars_map:
                try:
                    return float(vars_map[n.id])
                except Exception:
                    raise InterpreterError(f"Variable {n.id} is not numeric")
            raise InterpreterError(f"Unknown variable: {n.id}")
        if isinstance(n, ast.Call):
            if isinstance(n.func, ast.Name):
                fname = n.func.id
                allowed = {'sin','cos','tan','sqrt','log','ceil','floor'}
                if fname in allowed and len(n.args) == 1:
                    aval = _eval(n.args[0])
                    if fname == 'ceil':
                        return float(math.ceil(aval))
                    if fname == 'floor':
                        return float(math.floor(aval))
                    return float(getattr(math, fname)(aval))
            raise InterpreterError("Function calls not allowed except limited math funcs")
        raise InterpreterError(f"Unsupported expression element: {type(n)}")

    return float(_eval(node))

# CommandSpec

@dataclass
class CommandSpec:
    name: str
    category: str
    signature: str
    description: str
    safe: bool = True

# CommandRegistry

class CommandRegistry:
    def __init__(self, bulk_n: int = 1000):
        self.commands = {}
        self.handlers = {}
        self.aliases = {}
        self.macros = {}
        self.meta = {}

        self._init_realtime_gui()
        self._register_core()
        self._register_more_commands()
        self.generate_bulk_commands(bulk_n)
        self._register_gui_commands()

    def _init_realtime_gui(self):
        if not QApplication.instance():
            QApplication([])

        self._gui_engine = {}
        self._last_ctx = None

        self._gui_timer = QTimer()
        self._gui_timer.setInterval(50)
        self._gui_timer.timeout.connect(self._process_gui_queue)
        self._gui_timer.start()

    def _process_gui_queue(self):
        ctx = self._last_ctx
        if not ctx:
            return
        queue = ctx.get('__gui_queue__', [])
        while queue:
            cmd = queue.pop(0)
            if not cmd:
                continue
            action = cmd[0]

            if action == 'CREATE_WINDOW':
                _, title, w, h = cmd
                if title in self._gui_engine:
                    continue
                win = QMainWindow()
                win.setWindowTitle(title)
                win.resize(w, h)
                central = QWidget()
                layout = QVBoxLayout()
                central.setLayout(layout)
                win.setCentralWidget(central)
                self._gui_engine[title] = {'window': win, 'layout': layout}

            elif action == 'ADD_LABEL':
                _, title, text = cmd
                if title in self._gui_engine:
                    lbl = QLabel(text)
                    self._gui_engine[title]['layout'].addWidget(lbl)

            elif action == 'ADD_BUTTON':
                _, title, label, callback_cmd = cmd
                if title in self._gui_engine:
                    btn = QPushButton(label)
                    def _on_click(cb=callback_cmd, cctx=ctx):
                        try:
                            self.call(cb, [], cctx)
                        except Exception as e:
                            cctx.setdefault('__output__', []).append(f'[GUI CALLBACK ERROR] {e}')
                    btn.clicked.connect(partial(_on_click))
                    self._gui_engine[title]['layout'].addWidget(btn)

            elif action == 'SHOW_WINDOW':
                _, title = cmd
                if title in self._gui_engine:
                    self._gui_engine[title]['window'].show()

            elif action == 'CLEAR_WINDOW':
                _, title = cmd
                if title in self._gui_engine:
                    layout = self._gui_engine[title]['layout']
                    while layout.count():
                        item = layout.takeAt(0)
                        widget = item.widget()
                        if widget:
                            widget.deleteLater()

            elif action == 'CLOSE_WINDOW':
                _, title = cmd
                if title in self._gui_engine:
                    self._gui_engine[title]['window'].close()
                    del self._gui_engine[title]

        ctx['__gui_queue__'] = []

    def _register_gui_commands(self):
        @self.register(CommandSpec('GUI_WINDOW_CREATE', 'gui', 'GUI_WINDOW_CREATE title width height', '...'))
        def _gui_window_create(args, ctx):
            self._last_ctx = ctx
            # queue CREATE_WINDOW
            title = args[0].strip('"\'')
            w, h = int(args[1]), int(args[2])
            ctx.setdefault('__gui_queue__', []).append(('CREATE_WINDOW', title, w, h))
            return title

        @self.register(CommandSpec('GUI_WINDOW_CREATE', 'gui', 'GUI_WINDOW_CREATE title width height',
                                   'Create window (real-time).'))
        def _gui_window_create(args, ctx):
            self._last_ctx = ctx
            if len(args) < 3:
                raise RuntimeError('GUI_WINDOW_CREATE requires title width height')
            title = args[0].strip('"\'')
            try:
                w = int(args[1])
                h = int(args[2])
            except Exception:
                raise RuntimeError('Width/height must be integers')
            ctx.setdefault('__gui_queue__', []).append(('CREATE_WINDOW', title, w, h))
            ctx.setdefault('__output__', []).append(f'[GUI] queued create window {title}')
            return title

        @self.register(CommandSpec('GUI_LABEL_ADD', 'gui', 'GUI_LABEL_ADD window_title text',
                                   'Add label to window (real-time).'))
        def _gui_label_add(args, ctx):
            self._last_ctx = ctx
            if len(args) < 2:
                raise RuntimeError('GUI_LABEL_ADD requires window_title text')
            title = args[0].strip('"\'')
            text = args[1].strip('"\'')
            ctx.setdefault('__gui_queue__', []).append(('ADD_LABEL', title, text))
            ctx.setdefault('__output__', []).append(f'[GUI] queued add label "{text}" -> {title}')
            return f'{title}:{text}'

        @self.register(CommandSpec('GUI_BUTTON_ADD', 'gui', 'GUI_BUTTON_ADD window_title label callback_cmd',
                                   'Add button with callback (real-time).'))
        def _gui_button_add(args, ctx):
            self._last_ctx = ctx
            if len(args) < 3:
                raise RuntimeError('GUI_BUTTON_ADD requires window_title label callback_cmd')
            title = args[0].strip('"\'')
            label = args[1].strip('"\'')
            cb = args[2]
            ctx.setdefault('__gui_queue__', []).append(('ADD_BUTTON', title, label, cb))
            ctx.setdefault('__output__', []).append(f'[GUI] queued add button {label} -> {title}')
            return f'{title}:{label}'

        @self.register(CommandSpec('GUI_SHOW', 'gui', 'GUI_SHOW window_title', 'Show window (real-time).'))
        def _gui_show(args, ctx):
            self._last_ctx = ctx
            if not args:
                raise RuntimeError('GUI_SHOW requires window_title')
            title = args[0].strip('"\'')
            ctx.setdefault('__gui_queue__', []).append(('SHOW_WINDOW', title))
            ctx.setdefault('__output__', []).append(f'[GUI] queued show {title}')
            return title

        @self.register(CommandSpec('GUI_CLEAR', 'gui', 'GUI_CLEAR window_title', 'Clear window contents.'))
        def _gui_clear(args, ctx):
            self._last_ctx = ctx
            if not args:
                raise RuntimeError('GUI_CLEAR requires window_title')
            title = args[0].strip('"\'')
            ctx.setdefault('__gui_queue__', []).append(('CLEAR_WINDOW', title))
            ctx.setdefault('__output__', []).append(f'[GUI] queued clear window {title}')
            return title

        @self.register(CommandSpec('GUI_CLOSE', 'gui', 'GUI_CLOSE window_title', 'Close window.'))
        def _gui_close(args, ctx):
            self._last_ctx = ctx
            if not args:
                raise RuntimeError('GUI_CLOSE requires window_title')
            title = args[0].strip('"\'')
            ctx.setdefault('__gui_queue__', []).append(('CLOSE_WINDOW', title))
            ctx.setdefault('__output__', []).append(f'[GUI] queued close {title}')
            return title

    # registration helper
    def register(self, spec: CommandSpec):
        key = spec.name.upper()
        self.commands[key] = spec
        # assign deterministic pastel color for UI/highlighter
        self.meta[key] = {
            'category': spec.category,
            'signature': spec.signature,
            'description': spec.description,
            'color': self._color_from_name_hex(key)
        }
        def decorator(fn: Callable):
            self.handlers[key] = fn
            return fn
        return decorator

    # macro helpers
    def define_macro(self, name: str, lines: List[str], ctx: Optional[Dict[str, Any]] = None) -> str:
        if not name:
            raise RuntimeError("[MACRO] Missing macro name!")
        cleaned = [ln.strip() for ln in lines if ln and ln.strip()]
        if not cleaned:
            raise RuntimeError(f"[MACRO] Macro '{name}' has empty body!")
        self.macros[name.upper()] = cleaned
        if ctx is not None:
            ctx.setdefault('__output__', []).append(f"[MACRO] Macro '{name}' registered ({len(cleaned)} lines)")
        return f"Macro {name.upper()} registered"

    def execute_macro(self, name: str, extra_lines: Optional[List[str]], ctx: Dict[str, Any]) -> List[Any]:
        name_u = name.upper()
        if name_u not in self.macros:
            raise RuntimeError(f"Macro {name} not defined")
        macro_lines = list(self.macros[name_u])
        if extra_lines:
            macro_lines += [ln for ln in extra_lines if ln and ln.strip()]
        results = []
        for mline in macro_lines:
            if not mline.strip() or mline.strip().startswith('#'):
                continue
            # execute each line (use core.execute? use call path)
            try:
                # If line starts with CALL(...) pattern, _execute_line will parse it.
                parts = self._tokenize(mline)
                if not parts:
                    continue
                cmd = parts[0]
                args = parts[1:]
                # If macro references another macro name, expansion will happen at interpreter loop normally.
                res = self.call(cmd, args, ctx)
                results.append(res)
            except Exception as e:
                results.append(f"[MACRO ERROR] {e}")
        return results

    # call/lookup
    def call(self, name: str, args: List[str], ctx: Dict[str, Any]):
        if name is None:
            raise ValueError("Command name required")
        key = name.upper()
        # expand aliases with loop detection
        visited = set()
        while key in self.aliases:
            if key in visited:
                raise RuntimeError(f"Alias loop detected for {key}")
            visited.add(key)
            expansion = self.aliases[key]
            parts = expansion.split()
            if not parts:
                break
            name = parts[0]
            args = parts[1:] + args
            key = name.upper()

        if key not in self.handlers:
            raise RuntimeError(f"Unknown command: {name}")

        ctx = ctx or {}
        ctx.setdefault('__output__', [])
        ctx.setdefault('vars', {})
        ctx.setdefault('__gui_queue__', [])
        ctx.setdefault('__cmd_meta__', {})
        ctx['__cmd_meta__']['last_called'] = key
        ctx['__cmd_meta__']['meta'] = self.meta.get(key, {})

        return self.handlers[key](args, ctx)

    def get_spec(self, name: str) -> Optional[CommandSpec]:
        return self.commands.get(name.upper())

    def list_all(self) -> List[CommandSpec]:
        return list(self.commands.values())

    # color utils
    def _color_from_name_hex(self, name: str) -> str:
        # deterministic pastel HSL -> hex
        h = abs(hash(name)) % 360
        s = 64 + (abs(hash(name[::-1])) % 20)
        l = 45 + (abs(hash(name + 'L')) % 12)
        hn, sn, ln = h/360.0, s/100.0, l/100.0
        r, g, b = colorsys.hls_to_rgb(hn, ln, sn)
        return f'#{int(r*255):02x}{int(g*255):02x}{int(b*255):02x}'

    def get_color_for_command(self, name: str) -> Optional[str]:
        m = self.meta.get(name.upper())
        return m.get('color') if m else None

    def set_color_for_command(self, name: str, hex_color: str):
        if name.upper() in self.meta:
            self.meta[name.upper()]['color'] = hex_color

    # bulk generation
    def generate_bulk_commands(self, n: int = 500):
        cats = ['math','str','io_safe','util','time','simulate','net']
        for i in range(1, n+1):
            name = f'AUTO_CMD_{i}'
            cat = cats[i % len(cats)]
            sig = f'{name} <args...>'
            desc = f'Auto-generated command #{i} ({cat})'
            key = name.upper()
            if key in self.commands:
                continue
            spec = CommandSpec(name, cat, sig, desc)
            self.commands[key] = spec
            self.meta[key] = {'category': cat, 'signature': sig, 'description': desc, 'color': self._color_from_name_hex(key)}

            def make_handler(nm):
                def handler(args, ctx):
                    msg = f'[AUTO] {nm}: args={args}'
                    ctx.setdefault('__output__', []).append(msg)
                    return msg
                return handler
            self.handlers[key] = make_handler(name)

    # core commands
    def _register_core(self):
        @self.register(CommandSpec('PRINT','core','PRINT <items...>','Print strings or expressions (quoted strings or numeric expr).'))
        def _print(args, ctx):
            out = []
            vars_map = ctx.setdefault('vars', {})
            i = 0
            while i < len(args):
                token = args[i]
                # skip explicit '+' tokens (support classic concatenation)
                if token == '+':
                    i += 1
                    continue
                if (token.startswith('"') and token.endswith('"')) or (token.startswith("'") and token.endswith("'")):
                    out.append(token[1:-1])
                else:
                    # try variable lookup first
                    if re.fullmatch(r'[A-Za-z_][A-Za-z0-9_]*', token) and token in vars_map:
                        val = vars_map[token]
                    else:
                        # try evaluate numeric expression (caller must provide safe_eval_expr)
                        try:
                            val = safe_eval_expr(token, vars_map)
                        except InterpreterError:
                            # fallback: treat as raw string
                            val = token
                    # format ints without .0
                    try:
                        if isinstance(val, (int, float)) and float(val).is_integer():
                            out.append(str(int(val)))
                        else:
                            out.append(str(val))
                    except Exception:
                        out.append(str(val))
                i += 1
            result = " ".join(out)
            ctx.setdefault('__output__', []).append(result)
            return result

        @self.register(CommandSpec('LET','core','LET var = expr','Assign expression to variable.'))
        def _let(args, ctx):
            if not args:
                raise RuntimeError("LET requires arguments")
            vars_map = ctx.setdefault('vars', {})
            if '=' in args:
                eq = args.index('=')
                name = args[0]
                expr = ' '.join(args[eq+1:])
            else:
                name = args[0]
                expr = ' '.join(args[1:])
            val = safe_eval_expr(expr, vars_map)
            vars_map[name] = val
            return val

        @self.register(CommandSpec('ADD','core','ADD var expr','Add value to variable.'))
        def _add(args, ctx):
            if len(args) < 2:
                raise RuntimeError("ADD needs var and expr")
            vars_map = ctx.setdefault('vars', {})
            target = args[0]
            expr = ' '.join(args[1:])
            val = safe_eval_expr(expr, vars_map)
            prev = float(vars_map.get(target, 0))
            res = prev + val
            vars_map[target] = res
            return res

        @self.register(CommandSpec('SUB','core','SUB var expr','Subtract value from variable.'))
        def _sub(args, ctx):
            if len(args) < 2:
                raise RuntimeError("SUB needs var and expr")
            vars_map = ctx.setdefault('vars', {})
            target = args[0]
            expr = ' '.join(args[1:])
            val = safe_eval_expr(expr, vars_map)
            prev = float(vars_map.get(target, 0))
            res = prev - val
            vars_map[target] = res
            return res

        @self.register(CommandSpec('MUL','core','MUL var expr','Multiply variable by expr.'))
        def _mul(args, ctx):
            if len(args) < 2:
                raise RuntimeError("MUL needs var and expr")
            vars_map = ctx.setdefault('vars', {})
            target = args[0]; expr = ' '.join(args[1:])
            val = safe_eval_expr(expr, vars_map)
            prev = float(vars_map.get(target, 0))
            res = prev * val
            vars_map[target] = res
            return res

        @self.register(CommandSpec('DIV','core','DIV var expr','Divide variable by expr.'))
        def _div(args, ctx):
            if len(args) < 2:
                raise RuntimeError("DIV needs var and expr")
            vars_map = ctx.setdefault('vars', {})
            target = args[0]; expr = ' '.join(args[1:])
            val = safe_eval_expr(expr, vars_map)
            if val == 0:
                raise RuntimeError("Division by zero")
            prev = float(vars_map.get(target, 0))
            res = prev / val
            vars_map[target] = res
            return res

        @self.register(CommandSpec('ENDIF', 'control', 'ENDIF', 'End IF block (no-op, handled by interpreter).'))
        def _endif(args, ctx):
            ctx.setdefault('__output__', []).append('[ENDIF] control token')
            return True

        @self.register(CommandSpec('ENDLOOP', 'control', 'ENDLOOP', 'End LOOP block (no-op, handled by interpreter).'))
        def _endloop(args, ctx):
            ctx.setdefault('__output__', []).append('[ENDLOOP] control token')
            return True

        @self.register(CommandSpec('SLEEP','core','SLEEP seconds','Sleep for up to 5 seconds (capped).', safe=True))
        def _sleep(args, ctx):
            try:
                secs = float(args[0]) if args else 0
            except Exception:
                secs = 0
            secs = max(0, min(5, secs))
            time.sleep(secs)
            return secs

        @self.register(CommandSpec('IF','control','IF <cond> THEN ... ENDIF','Control keyword - prefer handled by core/interpreter.'))
        def _if(args, ctx):
            # no-op, handled by interpreter
            ctx.setdefault('__output__', []).append('[IF] control token (handled by core)')
            return True

        @self.register(CommandSpec('LOOP','control','LOOP n ... ENDLOOP','Control keyword - prefer handled by core/interpreter.'))
        def _loop(args, ctx):
            ctx.setdefault('__output__', []).append('[LOOP] control token (handled by core)')
            return True

        @self.register(CommandSpec('ALIAS','meta','ALIAS name expansion','Create alias.'))
        def _alias(args, ctx):
            if len(args) < 2:
                raise RuntimeError('ALIAS needs name and expansion')
            name = args[0].upper()
            expansion = ' '.join(args[1:])
            self.aliases[name] = expansion
            return f'Alias {name} -> {expansion}'

        @self.register(CommandSpec('UNALIAS','meta','UNALIAS name','Remove alias.'))
        def _unalias(args, ctx):
            if not args:
                raise RuntimeError('UNALIAS needs name')
            name = args[0].upper()
            self.aliases.pop(name, None)
            return f'Alias {name} removed'

        @self.register(CommandSpec('MACRO','meta','MACRO name ; cmd1 ; cmd2','Define macro (semicolon-separated).'))
        def _macro(args, ctx):
            if len(args) < 2:
                raise RuntimeError('MACRO requires name and body')
            name = args[0].upper()
            body = ' '.join(args[1:]).split(';')
            self.macros[name] = [b.strip() for b in body if b.strip()]
            return f'Macro {name} set'

        @self.register(CommandSpec('UNMACRO','meta','UNMACRO name','Remove macro.'))
        def _unmacro(args, ctx):
            if not args:
                raise RuntimeError('UNMACRO needs name')
            name = args[0].upper()
            self.macros.pop(name, None)
            return f'Macro {name} removed'

        @self.register(CommandSpec('ALL_COMMANDS','meta','ALL_COMMANDS','Return structured list of all commands.'))
        def _all_cmds(args, ctx):
            out = {}
            for spec in self.list_all():
                out.setdefault(spec.category, []).append({'name': spec.name, 'signature': spec.signature, 'description': spec.description})
            ctx.setdefault('__output__', []).append('[ALL_COMMANDS]')
            return out

        @self.register(CommandSpec('HELP','meta','HELP [cmd]','Show help for command or categories.'))
        def _help(args, ctx):
            if args:
                nm = args[0].upper()
                spec = self.get_spec(nm)
                if not spec:
                    raise RuntimeError(f'No help for {nm}')
                info = f'{spec.name}: {spec.signature} - {spec.description}'
                ctx.setdefault('__output__', []).append(info)
                return info
            # otherwise list categories summary
            cats = {}
            for s in self.list_all():
                cats.setdefault(s.category, 0)
                cats[s.category] += 1
            out = ', '.join([f'{k}({v})' for k,v in cats.items()])
            ctx.setdefault('__output__', []).append(out)
            return out

    def _register_more_commands(self):
        @self.register(CommandSpec('ECHO','util','ECHO text','Alias to PRINT; prints raw text.'))
        def _echo(args, ctx):
            return self.call('PRINT', args, ctx)

        @self.register(CommandSpec('STR_LEN','str','STR_LEN s','Return length of string.'))
        def _strlen(args, ctx):
            if not args:
                raise RuntimeError('STR_LEN needs argument')
            token = args[0]
            if (token.startswith('"') and token.endswith('"')) or (token.startswith("'") and token.endswith("'")):
                s = token[1:-1]
            else:
                s = str(ctx.setdefault('vars', {}).get(token, token))
            out = str(len(s))
            ctx.setdefault('__output__', []).append(out)
            return out

        @self.register(CommandSpec('STR_UPPER','str','STR_UPPER s','Uppercase string.'))
        def _upper(args, ctx):
            if not args:
                raise RuntimeError('STR_UPPER needs arg')
            token = args[0]
            if (token.startswith('"') and token.endswith('"')) or (token.startswith("'") and token.endswith("'")):
                s = token[1:-1]
            else:
                s = str(ctx.setdefault('vars', {}).get(token, token))
            out = s.upper()
            ctx.setdefault('__output__', []).append(out)
            return out

        @self.register(CommandSpec('REPLACE','str','REPLACE s old new','Replace substring.'))
        def _replace(args, ctx):
            if len(args) < 3:
                raise RuntimeError('REPLACE needs s old new')
            token, old, new = args[0], args[1].strip('"\'') , args[2].strip('"\'')
            if (token.startswith('"') and token.endswith('"')) or (token.startswith("'") and token.endswith("'")):
                s = token[1:-1]
            else:
                s = str(ctx.setdefault('vars', {}).get(token, token))
            out = s.replace(old, new)
            ctx.setdefault('__output__', []).append(out)
            return out

        @self.register(CommandSpec('READ','io_safe','READ path','Read file in project (safe).'))
        def _read(args, ctx):
            path = args[0] if args else ''
            proj = ctx.get('project')
            if proj:
                full = os.path.join(proj.folder_path, path)
                if os.path.exists(full):
                    with open(full, 'r', encoding='utf-8') as f:
                        content = f.read()
                    ctx.setdefault('__output__', []).append(content)
                    return content
            raise RuntimeError('File not found in project')

        @self.register(CommandSpec('WRITE','io_safe','WRITE path text','Write file in project (safe).'))
        def _write(args, ctx):
            if not args:
                raise RuntimeError('WRITE requires path and text')
            path = args[0]
            text = ' '.join(args[1:]) if len(args) > 1 else ''
            proj = ctx.get('project')
            if proj:
                full = os.path.join(proj.folder_path, path)
                with open(full, 'w', encoding='utf-8') as f:
                    f.write(text)
                return f'Written {path}'
            raise RuntimeError('No project open')

        # simulated red-team educational commands (safe)
        @self.register(CommandSpec('SIM_SCAN','red','SIM_SCAN target','Simulated port scan (educational).'))
        def _sim_scan(args, ctx):
            tgt = args[0] if args else 'localhost'
            res = f'Simulated scan for {tgt}: open ports 22,80'
            ctx.setdefault('__output__', []).append(res)
            return res

        @self.register(CommandSpec('SIM_PAYLOAD','red','SIM_PAYLOAD name','Simulated payload (no real code).'))
        def _sim_payload(args, ctx):
            name = args[0] if args else 'demo'
            res = f'[SIMULATED_PAYLOAD] {name} -> <stub>'
            ctx.setdefault('__output__', []).append(res)
            return res

        @self.register(CommandSpec('CRYPTO_HASH','crypto','CRYPTO_HASH algo text','Return simulated hash digest.'))
        def _crypto_hash(args, ctx):
            algo = args[0] if args else 'md5'
            txt = ' '.join(args[1:]) if len(args)>1 else ''
            h = abs(hash((algo, txt))) % (10**9)
            res = f'{algo}:{h:09d}'
            ctx.setdefault('__output__', []).append(res)
            return res

# RedScriptCore

class RedScriptCore:
    def __init__(self, registry: Optional[CommandRegistry] = None):
        self.registry = registry or CommandRegistry()

    def execute(self, source: str, ctx: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
        ctx = ctx or {}
        ctx.setdefault('__output__', [])
        ctx.setdefault('vars', {})
        ctx.setdefault('__gui_queue__', [])

        lines = source.splitlines()
        i = 0
        while i < len(lines):
            raw = lines[i]
            i += 1
            line = raw.strip()
            if not line or line.startswith('#'):
                continue
            parts = self._tokenize(line)
            if not parts:
                continue
            cmd = parts[0].upper()

            # MACRO block detection
            if cmd == 'MACRO':
                if len(parts) < 2:
                    ctx.setdefault('__output__', []).append("[ERROR] MACRO name missing")
                    continue
                name = parts[1].strip()
                block_lines = []
                while i < len(lines):
                    l = lines[i].rstrip('\n')
                    i += 1
                    if l.strip().upper() == 'ENDMACRO':
                        break
                    block_lines.append(l)
                else:
                    ctx.setdefault('__output__', []).append(f"[ERROR] ENDMACRO not found for macro '{name}'")
                    continue
                # define macro in registry (store body)
                try:
                    self.registry.define_macro(name, block_lines, ctx)
                except Exception as e:
                    ctx.setdefault('__output__', []).append(f"[ERROR] {e}")
                continue

            # macro invocation by name (simple expansion)
            if cmd in self.registry.macros:
                try:
                    # execute stored macro lines
                    self.registry.execute_macro(cmd, None, ctx)
                except Exception as e:
                    ctx.setdefault('__output__', []).append(f"[ERROR] Macro execution failed: {e}")
                continue

            # IF support (handled at interpreter level)
            if cmd == 'IF':
                cond = ' '.join(parts[1:])
                try:
                    result, new_i = self._eval_if_block(cond, lines, i, ctx)
                except InterpreterError as e:
                    ctx.setdefault('__output__', []).append(f'[ERROR] {e}')
                    break
                if not result:
                    i = new_i
                continue

            # LOOP support
            if cmd == 'LOOP':
                try:
                    n = int(parts[1])
                except Exception:
                    n = 0
                start = i
                end = self._find_block_end(lines, start - 1, 'ENDLOOP')
                block = '\n'.join(lines[start:end])
                for _ in range(n):
                    # reuse execute for block
                    self.execute(block, ctx)
                i = end + 1
                continue

            # regular command
            try:
                self._execute_line(line, ctx)
            except InterpreterError as e:
                ctx.setdefault('__output__', []).append(f'[ERROR] {e}')
                break
            except Exception as e:
                ctx.setdefault('__output__', []).append(f'[ERROR] {e}')
                break

        return ctx

    def _execute_line(self, line: str, ctx: Dict[str, Any]):
        parts = self._tokenize(line)
        if not parts:
            return None
        cmd = parts[0]
        args = parts[1:]
        # support CALL FOO("a", 1)
        m = re.match(r"CALL\s+([A-Za-z_][A-Za-z0-9_]*)\s*\((.*)\)\s*$", line, re.IGNORECASE)
        if m:
            name = m.group(1)
            argtext = m.group(2)
            # split on commas that are not escaped
            args = [a.strip().strip('\"\'') for a in re.split(r'(?<!\\),', argtext) if a.strip()]
            return self.registry.call(name, args, ctx)
        # normal call
        return self.registry.call(cmd, args, ctx)

    def _tokenize(self, line: str) -> List[str]:
        tokens = []
        buf = ''
        in_q = False
        qch = ''
        for ch in line:
            if in_q:
                buf += ch
                if ch == qch:
                    tokens.append(buf)
                    buf = ''
                    in_q = False
                continue
            if ch in ('"', "'"):
                in_q = True
                qch = ch
                buf += ch
                continue
            if ch.isspace():
                if buf:
                    tokens.append(buf)
                    buf = ''
                continue
            buf += ch
        if buf:
            tokens.append(buf)
        return tokens

    def _find_block_end(self, lines: List[str], start_index: int, token_end: str) -> int:
        for i in range(start_index + 1, len(lines)):
            if lines[i].strip().upper().startswith(token_end):
                return i
        raise InterpreterError(f'Block end {token_end} not found')

    def _eval_if_block(self, condition: str, lines: List[str], index_after_if: int, ctx: Dict[str, Any]) -> Tuple[bool, int]:
        cond = condition
        if cond.upper().endswith('THEN'):
            cond = cond[:-4].strip()
        try:
            if cond == '':
                result = False
            else:
                result = bool(safe_eval_expr(cond, ctx.get('vars', {})))
        except InterpreterError:
            # comparator fallback (string/numeric)
            m = re.match(r"(.+?)\s*(==|!=|>=|<=|>|<)\s*(.+)", cond)
            if m:
                try:
                    a = float(safe_eval_expr(m.group(1), ctx.get('vars', {})))
                    b = float(safe_eval_expr(m.group(3), ctx.get('vars', {})))
                except InterpreterError:
                    # fallback to string compare
                    a = m.group(1).strip().strip('"\'')
                    b = m.group(3).strip().strip('"\'')
                op = m.group(2)
                if op == '==':
                    result = a == b
                elif op == '!=':
                    result = a != b
                elif op == '>=':
                    result = a >= b
                elif op == '<=':
                    result = a <= b
                elif op == '>':
                    result = a > b
                elif op == '<':
                    result = a < b
                else:
                    result = False
            else:
                result = False

        # find matching ENDIF
        for i in range(index_after_if, len(lines)):
            if lines[i].strip().upper().startswith('ENDIF'):
                return result, i + 1
        raise InterpreterError('ENDIF not found for IF')

# GUIWindowManager

class GUIWindowManager:
    def __init__(self):
        self.windows: Dict[str, Dict[str, Any]] = {}

    def create_window(self, title: str, w: int, h: int):
        win = QWidget()
        win.setWindowTitle(title)
        win.resize(w, h)
        layout = QVBoxLayout(win)
        win.setLayout(layout)
        self.windows[title] = {'widget': win, 'layout': layout}
        return title

    def add_button(self, window_title: str, label: str, callback: Optional[Callable], interpreter: Any):
        if window_title not in self.windows:
            return
        info = self.windows[window_title]
        btn = QPushButton(label)
        try:
            registry = getattr(interpreter, 'registry', None)
            if registry:
                hex_color = registry.get_color_for_command(label) or registry._color_from_name_hex(label.upper())
                btn.setStyleSheet(f'background:{hex_color}; padding:6px; border-radius:6px; color:#ffffff;')
        except Exception:
            pass

        def on_click():
            try:
                if callback:
                    callback()
                elif hasattr(interpreter, 'registry'):
                    interpreter.registry.call('PRINT', [f'"{label} clicked!"'], {'__output__': []})
            except Exception:
                pass

        btn.clicked.connect(on_click)
        info['layout'].addWidget(btn)

    def show_window(self, title: str):
        if title in self.windows:
            self.windows[title]['widget'].show()

global_gui_manager = GUIWindowManager()

# Runner

class RedScriptRunner(QThread):
    output = pyqtSignal(str)
    error = pyqtSignal(str)
    finished = pyqtSignal()

    def __init__(self, code: str, core: RedScriptCore, project=None):
        super().__init__()
        self.code = code
        self.core = core
        self._running = True
        self.project = project

    def run(self):
        try:
            ctx = {'project': self.project}
            out = self.core.execute(self.code, ctx)
            for line in out.get('__output__', []):
                if not self._running:
                    break
                self.output.emit(str(line))
            self.finished.emit()
        except Exception:
            self.error.emit(traceback.format_exc())

    def stop(self):
        self._running = False

# Highlighter

class RedScriptHighlighter(QSyntaxHighlighter):
    def __init__(self, parent):
        super().__init__(parent.document())
        self.parent = parent
        self.rules: List[Tuple[re.Pattern, QTextCharFormat]] = []
        self._init_formats()
        self._build_rules()

    def _init_formats(self):
        self.fmt_keyword = QTextCharFormat()
        self.fmt_keyword.setForeground(QColor('#57c7ff'))
        self.fmt_keyword.setFontWeight(600)

        self.fmt_builtin = QTextCharFormat()
        self.fmt_builtin.setForeground(QColor('#ffb86c'))
        self.fmt_builtin.setFontWeight(600)

        self.fmt_string = QTextCharFormat()
        self.fmt_string.setForeground(QColor('#98c379'))

        self.fmt_number = QTextCharFormat()
        self.fmt_number.setForeground(QColor('#bd93f9'))

        self.fmt_comment = QTextCharFormat()
        self.fmt_comment.setForeground(QColor('#6272a4'))
        self.fmt_comment.setFontItalic(True)

    def _build_rules(self):
        keywords = ['PRINT','LET','SET','ADD','SUB','MUL','DIV','MOD','POW','IF','ENDIF','LOOP','ENDLOOP','SLEEP','RUN','CALL','MACRO']
        for kw in keywords:
            pat = re.compile(rf'\b{re.escape(kw)}\b', re.IGNORECASE)
            self.rules.append((pat, self.fmt_keyword))

        # dynamic per-command color from registry if present
        registry = None
        try:
            win = self.parent.window()
            registry = getattr(win, 'registry', None)
        except Exception:
            registry = None

        if registry:
            for spec in registry.list_all():
                name = spec.name
                hexcol = registry.get_color_for_command(name) or registry._color_from_name_hex(name)
                fmt = QTextCharFormat()
                try:
                    qcol = QColor(hexcol)
                    fmt.setForeground(qcol)
                except Exception:
                    fmt = self.fmt_builtin
                fmt.setFontWeight(600)
                pat = re.compile(rf'\b{re.escape(name)}\b', re.IGNORECASE)
                self.rules.append((pat, fmt))

        # generic patterns
        self.rules.append((re.compile(r'#.*'), self.fmt_comment))
        self.rules.append((re.compile(r'\".*?\"'), self.fmt_string))
        self.rules.append((re.compile(r"'.*?'"), self.fmt_string))
        self.rules.append((re.compile(r'\b\d+\.?\d*\b'), self.fmt_number))

    def highlightBlock(self, text: str):
        for pattern, fmt in self.rules:
            for m in pattern.finditer(text):
                start, end = m.span()
                self.setFormat(start, end - start, fmt)

# Project & Editor

class Project:
    def __init__(self, folder_path: str):
        self.folder_path = folder_path
        self.name = os.path.basename(folder_path)
        os.makedirs(folder_path, exist_ok=True)

    def list_files(self):
        return sorted([f for f in os.listdir(self.folder_path) if f.endswith('.rs')])

    def create_file(self, name: str, content: str = ''):
        path = os.path.join(self.folder_path, name)
        with open(path, 'w', encoding='utf-8') as f:
            f.write(content)
        return path

    def read_file(self, name: str) -> str:
        path = os.path.join(self.folder_path, name)
        with open(path, 'r', encoding='utf-8') as f:
            return f.read()

    def save_file(self, name: str, content: str):
        path = os.path.join(self.folder_path, name)
        with open(path, 'w', encoding='utf-8') as f:
            f.write(content)

class CodeEditor(QPlainTextEdit):
    def __init__(self, parent=None):
        super().__init__(parent)
        font = QFont('Consolas')
        font.setPointSize(11)
        self.setFont(font)
        self.setTabStopDistance(4 * self.fontMetrics().horizontalAdvance(' '))
        self.highlighter = RedScriptHighlighter(self)
        self._lint_timer = QTimer(self)
        self._lint_timer.setSingleShot(True)
        self._lint_timer.timeout.connect(self._lint)
        self.textChanged.connect(self._on_text_changed)

    def _on_text_changed(self):
        self._lint_timer.start(300)

    def _lint(self):
        text = self.toPlainText()
        open_quotes = text.count('"') % 2 != 0 or text.count("'") % 2 != 0
        w = self.window()
        if w:
            if open_quotes:
                w.status.showMessage('Lint: unmatched quote')
            else:
                w.status.showMessage('')

# IDE

class RedScriptIDE(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle('RedScript IDE')
        self.registry = CommandRegistry()
        self.core = RedScriptCore(self.registry)
        self.project: Optional[Project] = None
        self.open_files: Dict[str, CodeEditor] = {}
        self.runner: Optional[RedScriptRunner] = None
        self._setup_ui()
        self.apply_qss()

    def _setup_ui(self):
        toolbar = QToolBar('Main')
        toolbar.setIconSize(QSize(20, 20))
        self.addToolBar(toolbar)

        new_proj = QAction('New Project', self)
        new_proj.triggered.connect(self.new_project)
        toolbar.addAction(new_proj)

        open_proj = QAction('Open Project', self)
        open_proj.triggered.connect(self.open_project)
        toolbar.addAction(open_proj)

        toolbar.addSeparator()

        new_file = QAction('New File', self)
        new_file.triggered.connect(self.new_file)
        toolbar.addAction(new_file)

        save = QAction('Save', self)
        save.setShortcut(QKeySequence('Ctrl+S'))
        save.triggered.connect(self.save_current)
        toolbar.addAction(save)

        run = QAction('Run', self)
        run.triggered.connect(self.run_current)
        toolbar.addAction(run)

        stop = QAction('Stop', self)
        stop.triggered.connect(self.stop_run)
        toolbar.addAction(stop)

        all_cmds = QAction('All Commands', self)
        all_cmds.triggered.connect(self.show_all_commands)
        toolbar.addAction(all_cmds)

        central = QWidget()
        self.setCentralWidget(central)
        l = QVBoxLayout(central)
        splitter = QSplitter(Qt.Orientation.Horizontal)
        l.addWidget(splitter)

        left = QWidget()
        left_layout = QVBoxLayout(left)
        left_layout.setContentsMargins(6, 6, 6, 6)
        self.file_list = QListWidget()
        self.file_list.itemDoubleClicked.connect(self.open_file_from_list)
        left_layout.addWidget(QLabel('Project Files'))
        left_layout.addWidget(self.file_list)
        splitter.addWidget(left)
        left.setMaximumWidth(260)

        center = QWidget()
        center_layout = QVBoxLayout(center)
        center_layout.setContentsMargins(6, 6, 6, 6)
        self.tabs = QTabWidget()
        self.tabs.setTabsClosable(True)
        self.tabs.tabCloseRequested.connect(self.close_tab)
        center_layout.addWidget(self.tabs)
        splitter.addWidget(center)

        self.terminal = QPlainTextEdit()
        self.terminal.setReadOnly(True)
        self.terminal.setMaximumHeight(220)
        l.addWidget(self.terminal)

        self.status = QStatusBar()
        self.setStatusBar(self.status)
        self.status.showMessage('Ready')

        right = QWidget()
        right_layout = QVBoxLayout(right)
        right_layout.setContentsMargins(6, 6, 6, 6)
        self.project_label = QLabel('No project opened')
        right_layout.addWidget(self.project_label)
        btn_new = QPushButton('New .rs file')
        btn_new.clicked.connect(self.new_file)
        right_layout.addWidget(btn_new)
        right_layout.addStretch()
        splitter.addWidget(right)
        right.setMaximumWidth(260)

    def show_all_commands(self):
        meta = {}
        for spec in self.registry.list_all():
            meta.setdefault(spec.category, []).append(spec)
        dlg = QDialog(self)
        dlg.setWindowTitle('All Commands')
        dlg.resize(900, 540)
        layout = QVBoxLayout(dlg)
        table = QTableWidget()
        rows = []
        for cat, specs in meta.items():
            for s in specs:
                rows.append((s.name, cat, s.signature, s.description))
        table.setColumnCount(4)
        table.setHorizontalHeaderLabels(['Command', 'Category', 'Signature', 'Description'])
        table.setRowCount(len(rows))
        for i, (n, c, sig, d) in enumerate(rows):
            table.setItem(i, 0, QTableWidgetItem(n))
            table.setItem(i, 1, QTableWidgetItem(c))
            table.setItem(i, 2, QTableWidgetItem(sig))
            table.setItem(i, 3, QTableWidgetItem(d))
        table.resizeColumnsToContents()
        layout.addWidget(table)
        dlg.exec()

    # project
    def new_project(self):
        folder = QFileDialog.getExistingDirectory(self, 'Select folder', os.getcwd())
        if not folder:
            return
        name, ok = QInputDialog.getText(self, 'Name', 'Project name')
        if not ok or not name.strip():
            return
        proj_path = os.path.join(folder, name)
        self.project = Project(proj_path)
        self.project.create_file('main.rs', 'PRINT "Hello from RedScript!"\n')
        self.refresh_file_list()
        self.project_label.setText(f'Project: {self.project.name}')

    def open_project(self):
        folder = QFileDialog.getExistingDirectory(self, 'Open project', os.getcwd())
        if not folder:
            return
        self.project = Project(folder)
        self.refresh_file_list()
        self.project_label.setText(f'Project: {self.project.name}')

    def refresh_file_list(self):
        self.file_list.clear()
        if not self.project:
            return
        for f in self.project.list_files():
            self.file_list.addItem(QListWidgetItem(f))

    def new_file(self):
        if not self.project:
            QMessageBox.warning(self, 'No project', 'Open or create a project first')
            return
        name, ok = QInputDialog.getText(self, 'New file', 'File name (example: script.rs)')
        if not ok or not name.strip():
            return
        if not name.endswith('.rs'):
            name += '.rs'
        self.project.create_file(name, f'PRINT "New file: {name}"\n')
        self.refresh_file_list()
        self.open_file(name)

    def open_file_from_list(self, item: QListWidgetItem):
        self.open_file(item.text())

    def open_file(self, filename: str):
        if not self.project:
            return
        if filename in self.open_files:
            idx = self.tabs.indexOf(self.open_files[filename])
            if idx >= 0:
                self.tabs.setCurrentIndex(idx)
            return
        content = self.project.read_file(filename)
        editor = CodeEditor()
        editor.setPlainText(content)
        self.open_files[filename] = editor
        self.tabs.addTab(editor, filename)
        self.tabs.setCurrentWidget(editor)

    def close_tab(self, index: int):
        name = self.tabs.tabText(index)
        widget = self.tabs.widget(index)
        if widget:
            self.tabs.removeTab(index)
            if name in self.open_files:
                del self.open_files[name]

    def save_current(self):
        widget = self.tabs.currentWidget()
        if not widget:
            return
        name = self.tabs.tabText(self.tabs.currentIndex())
        if self.project and name:
            self.project.save_file(name, widget.toPlainText())
            self.status.showMessage(f'Saved {name}')

    def save_all(self):
        for name, ed in list(self.open_files.items()):
            if self.project:
                self.project.save_file(name, ed.toPlainText())
        self.status.showMessage('All saved')

    # run/stop
    def run_current(self):
        widget = self.tabs.currentWidget()
        if not widget:
            QMessageBox.information(self, 'No file', 'Open an .rs file to run')
            return
        name = self.tabs.tabText(self.tabs.currentIndex())
        code = widget.toPlainText()
        if self.project:
            self.project.save_file(name, code)
        self.terminal.clear()
        self.terminal.appendPlainText(f'--- Running {name} ---')
        if self.runner and self.runner.isRunning():
            try:
                self.runner.stop()
            except Exception:
                pass
        self.runner = RedScriptRunner(code, self.core, project=self.project)
        self.runner.output.connect(self.terminal.appendPlainText)
        self.runner.error.connect(self._on_error)
        self.runner.finished.connect(lambda: self.terminal.appendPlainText('--- Finished ---'))
        self.runner.start()

    def stop_run(self):
        if self.runner and self.runner.isRunning():
            try:
                self.runner.stop()
                self.terminal.appendPlainText('--- Stop requested ---')
            except Exception:
                pass

    def _on_error(self, tb: str):
        self.terminal.appendPlainText('--- Error ---')
        self.terminal.appendPlainText(tb)

    def apply_qss(self):
        qss = """
        QWidget {
            background-color: #0d0f14;
            color: #e0e7f1;
            font-family: "Segoe UI", "Roboto", "Helvetica", "Arial", sans-serif;
            font-size: 14px;
        }

        QMainWindow {
            background-color: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                                              stop:0 #0a0c11, stop:1 #0d0f14);
            border: 1px solid #1a1d26;
        }

        QLabel {
            color: #cfd3dc;
            font-size: 14px;
            padding: 2px 4px;
        }

        QPushButton {
            font-size: 13px;
            padding: 8px 16px;
            border-radius: 6px;
            background-color: #1c1f29;
            color: #e4ebf5;
            border: 1px solid #2a2e3a;
        }

        QPushButton:hover {
            background-color: #2a2f3c;
            border: 1px solid #3a3f4f;
        }

        QPushButton:pressed {
            background-color: #151820;
            border: 1px solid #232733;
        }

        QLineEdit, QTextEdit, QPlainTextEdit {
            font-size: 13px;
            background-color: #14171f;
            border: 1px solid #2a2e3a;
            border-radius: 5px;
            padding: 4px 6px;
            color: #e0e7f1;
        }

        QLineEdit:focus, QTextEdit:focus, QPlainTextEdit:focus {
            border: 1px solid #5a78ff;
        }

        QListWidget {
            font-size: 13px;
            background-color: #14171f;
            border: 1px solid #2a2e3a;
            border-radius: 4px;
            padding: 2px;
            color: #dfe3ec;
        }

        QTabBar::tab {
            font-size: 13px;
            padding: 8px 12px;
            background-color: #1c1f29;
            color: #e0e7f1;
            border-top-left-radius: 4px;
            border-top-right-radius: 4px;
            margin-right: 2px;
        }

        QTabBar::tab:selected {
            background-color: #2a2f3c;
            color: #ffffff;
        }

        QStatusBar {
            font-size: 13px;
            background-color: #10121a;
            border-top: 1px solid #2a2e3a;
            color: #cfd3dc;
        }

        QScrollBar:vertical {
            background: #0d0f14;
            width: 12px;
            margin: 0px 0px 0px 0px;
            border-radius: 6px;
        }

        QScrollBar::handle:vertical {
            background: #2a2f3c;
            min-height: 20px;
            border-radius: 6px;
        }

        QScrollBar::handle:vertical:hover {
            background: #3a3f4f;
        }

        QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical {
            height: 0px;
        }

        QScrollBar:horizontal {
            background: #0d0f14;
            height: 12px;
            border-radius: 6px;
        }

        QScrollBar::handle:horizontal {
            background: #2a2f3c;
            min-width: 20px;
            border-radius: 6px;
        }

        QScrollBar::handle:horizontal:hover {
            background: #3a3f4f;
        }

        QScrollBar::add-line:horizontal, QScrollBar::sub-line:horizontal {
            width: 0px;
        }
        """
        self.setStyleSheet(qss)

# main
def main():
    app = QApplication(sys.argv)
    app.setApplicationName('RedScript IDE')

    win = RedScriptIDE()
    win.resize(1400, 800)

    win.show()
    win.setWindowIcon(QIcon("RedScript.ico"))
    sys.exit(app.exec())

if __name__ == '__main__':
    main()