HelpDatabase.cpp

#include "HelpDatabase.h"
#include <algorithm>

HelpDatabase &HelpDatabase::instance() {
  static HelpDatabase s_instance;
  return s_instance;
}

HelpDatabase::HelpDatabase() { initItems(); }

void HelpDatabase::initItems() {
  // --- Стек ---
  m_items.push_back(
      {"копія",
       {"dup"},
       "Стек",
       "( x -- x x )",
       "Дублює верхній елемент стека. Додає його копію на вершину.",
       "10 копія * друк"});
  m_items.push_back({"скинути",
                     {"drop"},
                     "Стек",
                     "( x -- )",
                     "Видаляє верхній елемент зі стека.",
                     "1 2 3 скинути друк_стеку"});
  m_items.push_back({"обміняти",
                     {"swap"},
                     "Стек",
                     "( a b -- b a )",
                     "Міняє місцями два верхні елементи стека.",
                     "1 2 обміняти друк друк"});
  m_items.push_back(
      {"поверх",
       {"over"},
       "Стек",
       "( a b -- a b a )",
       "Копіює другий з вершини елемент і кладе його на верх стека.",
       "10 20 поверх друк_стеку"});
  m_items.push_back({"ротація",
                     {"rot", "поворот"},
                     "Стек",
                     "( a b c -- b c a )",
                     "Переміщує третій елемент стека на саму вершину.",
                     "1 2 3 ротація друк_стеку"});
  m_items.push_back({"новий_рядок",
                     {"cr"},
                     "Вивід",
                     "( -- )",
                     "Переводить курсор на новий рядок у виводі.",
                     "\"Перший\" друк новий_рядок \"Другий\" друк"});
  m_items.push_back(
      {"друк_символ",
       {"emit"},
       "Вивід",
       "( char_code -- )",
       "Виводить символ із зазначеним кодом (ASCII / Unicode codepoint).",
       "65 друк_символ"});
  m_items.push_back({"пробіл",
                     {"space"},
                     "Вивід",
                     "( -- )",
                     "Виводить один пробіл у вікно результату.",
                     "1 друк_без_переводу пробіл 2 друк"});
  m_items.push_back({"пробіли",
                     {"spaces"},
                     "Вивід",
                     "( n -- )",
                     "Виводить n пробілів у вікно результату.",
                     "5 пробіли \"відступ\" друк"});
  m_items.push_back(
      {"друк_рядок",
       {"type"},
       "Вивід",
       "( str -- )",
       "Виводить рядок без додавання символу нового рядка в кінці.",
       "\"Привіт, світ!\" друк_рядок"});
  m_items.push_back({"друк",
                     {"."},
                     "Стек",
                     "( x -- )",
                     "Знімає верхній елемент стека і виводить його значення з "
                     "новим рядком у вікно результату.",
                     "42 друк"});
  m_items.push_back(
      {"друк_стеку",
       {".s"},
       "Стек",
       "( -- )",
       "Виводить поточний стан усього стека без видалення елементів.",
       "1 2 3 друк_стеку"});
  m_items.push_back({"nip",
                     {"висмикнути"},
                     "Стек",
                     "( a b -- b )",
                     "Видаляє передостанній елемент, лишаючи вершину стека.",
                     "1 2 nip друк"});
  m_items.push_back({"tuck",
                     {"підсунути"},
                     "Стек",
                     "( a b -- b a b )",
                     "Вставляє копію вершини під другий елемент.",
                     "1 2 tuck друк_стеку"});
  m_items.push_back({"2dup",
                     {"2копія"},
                     "Стек",
                     "( a b -- a b a b )",
                     "Дублює пару верхніх елементів стека.",
                     "1 2 2dup друк_стеку"});
  m_items.push_back({"2drop",
                     {"2скинути"},
                     "Стек",
                     "( a b -- )",
                     "Видаляє два верхні елементи стека.",
                     "1 2 3 4 2drop друк_стеку"});
  m_items.push_back({"2swap",
                     {"2обміняти"},
                     "Стек",
                     "( a b c d -- c d a b )",
                     "Міняє місцями дві верхні пари елементів.",
                     "1 2 3 4 2swap друк_стеку"});
  m_items.push_back({"depth",
                     {"глибина", "глибина_стеку"},
                     "Стек",
                     "( -- n )",
                     "Кладе на стек кількість елементів у стеку даних.",
                     "10 20 depth друк"});
  m_items.push_back({"clear",
                     {"очистити_стек", "очистити"},
                     "Стек",
                     "( ... -- )",
                     "Повністю очищає стек даних і стек повернень.",
                     "1 2 3 clear друк_стеку"});
  m_items.push_back({"2>r",
                     {"2>р"},
                     "Стек",
                     "( x y -- ) ( R: -- x y )",
                     "Переміщує два верхні елементи на стек повернень.",
                     "1 2 2>r 2r> + друк"});
  m_items.push_back({"2r>",
                     {"2р>"},
                     "Стек",
                     "( -- x y ) ( R: x y -- )",
                     "Повертає два елементи зі стека повернень.",
                     "3 4 2>r 2r> друк друк"});
  m_items.push_back(
      {"2r@",
       {"2р@"},
       "Стек",
       "( -- x y ) ( R: x y -- x y )",
       "Копіює два верхні елементи стека повернень на стек даних.",
       "5 6 2>r 2r@ 2r> 2drop + друк"});
  m_items.push_back({"0=",
                     {},
                     "Логіка та порівняння",
                     "( x -- flag )",
                     "Повертає 1, якщо значення дорівнює нулю.",
                     "0 0= друк"});
  m_items.push_back({"0<",
                     {},
                     "Логіка та порівняння",
                     "( x -- flag )",
                     "Повертає 1, якщо число від'ємне.",
                     "-3 0< друк"});
  m_items.push_back({"0>",
                     {},
                     "Логіка та порівняння",
                     "( x -- flag )",
                     "Повертає 1, якщо число додатне.",
                     "5 0> друк"});
  m_items.push_back({">r",
                     {">р", "в_r", "в_р"},
                     "Стек",
                     "( x -- ) ( R: -- x )",
                     "Переміщує верхній елемент зі стека даних на стек "
                     "повернень (Return Stack).",
                     "10 >r 5 r> + друк"});
  m_items.push_back(
      {"r>",
       {"р>", "з_r", "з_р"},
       "Стек",
       "( -- x ) ( R: x -- )",
       "Переміщує верхній елемент зі стека повернень назад на стек даних.",
       "42 >r r> друк"});
  m_items.push_back({"r@",
                     {"р@", "переглянути_r"},
                     "Стек",
                     "( -- x ) ( R: x -- x )",
                     "Копіює значення з вершини стека повернень на стек даних "
                     "без його видалення.",
                     "99 >r r@ друк r> друк"});
  m_items.push_back({"i",
                     {"і"},
                     "Стек",
                     "( -- index )",
                     "Кладе на стек даних поточний індекс найближчого циклу "
                     "'до ... цикл' (або 'do ... loop').",
                     "5 0 до і друк цикл"});
  m_items.push_back(
      {"j",
       {"й"},
       "Стек",
       "( -- outer_index )",
       "Кладе на стек даних індекс зовнішнього циклу (для вкладених циклів).",
       "3 0 до 2 0 до j друк і друк цикл цикл"});
  m_items.push_back(
      {"k",
       {"к"},
       "Стек",
       "( -- index3 )",
       "Кладе на стек даних індекс третього рівня вкладеного циклу.",
       "2 0 до 2 0 до 2 0 до k друк цикл цикл цикл"});

  // --- Арифметика ---
  m_items.push_back({"+",
                     {"додати"},
                     "Арифметика",
                     "( a b -- a+b )",
                     "Додає два числа (цілі, дійсні, комплексні) або виконує "
                     "конкатенацію двох рядків.",
                     "5 3 + друк\n\"Привіт, \" \"світ!\" + друк"});
  m_items.push_back({"-",
                     {"відняти"},
                     "Арифметика",
                     "( a b -- a-b )",
                     "Віднімає друге число від першого.",
                     "10 4 - друк"});
  m_items.push_back({"*",
                     {"множити"},
                     "Арифметика",
                     "( a b -- a*b )",
                     "Перемножує два числа (дійсні, комплексні).",
                     "6 7 * друк\n3+4i 1-2i * друк"});
  m_items.push_back({"/",
                     {"ділити"},
                     "Арифметика",
                     "( a b -- a/b )",
                     "Ділить перше число на друге. Має перевірку та захист від "
                     "ділення на нуль.",
                     "20 4 / друк"});
  m_items.push_back({"^",
                     {"степінь", "pow"},
                     "Арифметика",
                     "( a b -- a^b )",
                     "Підносить число a до степеня b. Підтримує дійсні, цілі, "
                     "дробові та комплексні степені.",
                     "2 8 ^ друк\n1+1i 4 ^ друк"});
  m_items.push_back({"корінь",
                     {"sqrt"},
                     "Арифметика",
                     "( x -- res )",
                     "Обчислює квадратний корінь. Для від'ємних дійсних чисел "
                     "повертає комплексне число 0+bi.",
                     "256 корінь друк\n-16 корінь друк"});
  m_items.push_back({"модуль",
                     {"abs"},
                     "Арифметика",
                     "( x -- res )",
                     "Обчислює абсолютну величину для дійсних чисел або норму "
                     "(довжину вектора) для комплексних.",
                     "-42.5 модуль друк\n3+4i модуль друк"});
  m_items.push_back({"мод",
                     {"mod", "%", "залишок"},
                     "Арифметика",
                     "( a b -- rem )",
                     "Обчислює остачу (залишок) від ділення a на b.",
                     "17 5 мод друк\n10 2 % друк"});
  m_items.push_back({"/мод",
                     {"/mod"},
                     "Арифметика",
                     "( a b -- rem quot )",
                     "Цілочисельне ділення та остача. Повертає остачу rem та "
                     "частку quot на стек.",
                     "17 5 /мод друк друк"});
  m_items.push_back({"мінімум",
                     {"min"},
                     "Арифметика",
                     "( a b -- min )",
                     "Повертає менше з двох значень.",
                     "10 20 мінімум друк"});
  m_items.push_back({"максимум",
                     {"max"},
                     "Арифметика",
                     "( a b -- max )",
                     "Повертає більше з двох значень.",
                     "10 20 максимум друк"});
  m_items.push_back({"змінити_знак",
                     {"negate", "протилежне"},
                     "Арифметика",
                     "( x -- -x )",
                     "Змінює знак числа на протилежний.",
                     "42 змінити_знак друк"});
  m_items.push_back({"1+",
                     {},
                     "Арифметика",
                     "( x -- x+1 )",
                     "Збільшує верхнє значення стека на 1.",
                     "5 1+ друк"});
  m_items.push_back({"1-",
                     {},
                     "Арифметика",
                     "( x -- x-1 )",
                     "Зменшує верхнє значення стека на 1.",
                     "5 1- друк"});
  m_items.push_back({"2*",
                     {},
                     "Арифметика",
                     "( x -- x*2 )",
                     "Множить верхнє значення стека на 2.",
                     "5 2* друк"});
  m_items.push_back({"2/",
                     {},
                     "Арифметика",
                     "( x -- x/2 )",
                     "Ділить верхнє значення стека на 2.",
                     "10 2/ друк"});

  // --- Комплексні числа ---
  m_items.push_back({"комплексне",
                     {"complex"},
                     "Комплексні числа",
                     "( re im -- c )",
                     "Динамічно створює комплексне число з двох чисел на "
                     "стеку: дійсної та уявної частини.",
                     "3 4 комплексне друк"});
  m_items.push_back({"re",
                     {"дійсна"},
                     "Комплексні числа",
                     "( c -- re )",
                     "Повертає дійсну частину комплексного числа (або саме "
                     "число, якщо воно дійсне).",
                     "3+4i re друк"});
  m_items.push_back(
      {"im",
       {"уявна"},
       "Комплексні числа",
       "( c -- im )",
       "Повертає уявну частину комплексного числа (або 0 для дійсних чисел).",
       "3+4i im друк"});
  m_items.push_back(
      {"спряжене",
       {"conj"},
       "Комплексні числа",
       "( a+bi -- a-bi )",
       "Комплексне спряження: змінює знак уявної частини числа на протилежний.",
       "3+4i спряжене друк"});

  // --- Тригонометрія ---
  m_items.push_back({"синус",
                     {"sin"},
                     "Тригонометрія",
                     "( x -- sin(x) )",
                     "Обчислює синус кута в радіанах (підтримує дійсні та "
                     "комплексні аргументи).",
                     "1.570796 синус друк"});
  m_items.push_back({"косинус",
                     {"cos"},
                     "Тригонометрія",
                     "( x -- cos(x) )",
                     "Обчислює косинус кута в радіанах.",
                     "0 косинус друк"});
  m_items.push_back({"тангенс",
                     {"tan"},
                     "Тригонометрія",
                     "( x -- tan(x) )",
                     "Обчислює тангенс кута в радіанах.",
                     "0.785398 тангенс друк"});
  m_items.push_back({"atan2",
                     {"арктангенс2"},
                     "Тригонометрія",
                     "( y x -- atan2(y,x) )",
                     "Двоаргументний арктангенс: кут у радіанах з урахуванням "
                     "квадранта. Стек: y потім x.",
                     "1 0 atan2 друк"});

  // --- Логіка та порівняння ---
  m_items.push_back(
      {"=",
       {"дорівнює"},
       "Логіка та порівняння",
       "( a b -- flag )",
       "Перевіряє два значення на рівність. Повертає 1 (істина) або 0 (хиба).",
       "5 5 = друк"});
  m_items.push_back({"<>",
                     {"!=", "не_дорівнює", "не_рівно"},
                     "Логіка та порівняння",
                     "( a b -- flag )",
                     "Перевіряє два значення на нерівність. Повертає 1, якщо "
                     "значення відрізняються.",
                     "4 5 != друк"});
  m_items.push_back({"<",
                     {"менше"},
                     "Логіка та порівняння",
                     "( a b -- flag )",
                     "Порівняння 'менше'. Повертає 1, якщо a < b.",
                     "3 5 < друк"});
  m_items.push_back({">",
                     {"більше"},
                     "Логіка та порівняння",
                     "( a b -- flag )",
                     "Порівняння 'більше'. Повертає 1, якщо a > b.",
                     "5 3 > друк"});
  m_items.push_back(
      {"<=",
       {"менше_рівне"},
       "Логіка та порівняння",
       "( a b -- flag )",
       "Порівняння 'менше або дорівнює'. Повертає 1, якщо a <= b.",
       "5 5 <= друк"});
  m_items.push_back(
      {">=",
       {"більше_рівне"},
       "Логіка та порівняння",
       "( a b -- flag )",
       "Порівняння 'більше або дорівнює'. Повертає 1, якщо a >= b.",
       "6 5 >= друк"});
  m_items.push_back({"і",
                     {"та", "and"},
                     "Логіка та порівняння",
                     "( a b -- flag )",
                     "Логічне І (кон'юнкція). Повертає 1, тільки якщо обидва "
                     "аргументи істинні.",
                     "1 1 і друк"});
  m_items.push_back({"або",
                     {"or"},
                     "Логіка та порівняння",
                     "( a b -- flag )",
                     "Логічне АБО (диз'юнкція). Повертає 1, якщо хоча б один "
                     "аргумент істинний.",
                     "0 1 або друк"});
  m_items.push_back({"ні",
                     {"not"},
                     "Логіка та порівняння",
                     "( a -- flag )",
                     "Логічне заперечення. Перетворює 0 на 1, а будь-яке "
                     "ненульове значення на 0.",
                     "0 ні друк"});

  // --- Керування виконанням ---
  m_items.push_back({"якщо",
                     {"if"},
                     "Керування",
                     "( flag -- )",
                     "Умовний перехід. Конструкція: 'умова якщо блок_true "
                     "[інакше блок_false] тоді' (або 'if ... else ... then').",
                     "1 якщо \"Так!\" друк тоді"});
  m_items.push_back({"інакше",
                     {"else"},
                     "Керування",
                     "( -- )",
                     "Альтернативна гілка в умовній конструкції 'якщо ... "
                     "інакше ... тоді' (або 'if ... else ... then').",
                     "0 якщо \"Так!\" друк інакше \"Ні!\" друк тоді"});
  m_items.push_back({"тоді",
                     {"then"},
                     "Керування",
                     "( -- )",
                     "Завершує умовний блок 'якщо ... тоді' або 'якщо ... "
                     "інакше ... тоді' (або 'if ... then').",
                     "5 0 > якщо \"Додатнє\" друк тоді"});
  m_items.push_back(
      {"початок",
       {"begin"},
       "Керування",
       "( -- )",
       "Початок циклу 'початок ... доки' (begin ... until) або 'початок ... "
       "поки ... повторити' (begin ... while ... repeat).",
       "змінна і\n5 і !\nпочаток\n  і @ друк\n  і @ 1 - і !\n  і @ 0 =\nдоки"});
  m_items.push_back(
      {"доки",
       {"until"},
       "Керування",
       "( flag -- )",
       "Завершує цикл 'початок ... доки' (begin ... until). Якщо flag на стеку "
       "дорівнює 0, цикл продовжується; якщо не 0 (істина) — виходить з циклу.",
       "змінна ліч\n3 ліч !\nпочаток\n  ліч @ друк\n  ліч @ 1 - ліч !\n  ліч @ "
       "0 =\nдоки"});
  m_items.push_back({"поки",
                     {"while"},
                     "Керування",
                     "( flag -- )",
                     "Перевірка умови всередині циклу 'початок ... поки ... "
                     "повторити' (begin ... while ... repeat). Якщо flag "
                     "хибний (0), відбувається негайний вихід з циклу.",
                     "початок умова поки тіло повторити"});
  m_items.push_back(
      {"повторити",
       {"repeat"},
       "Керування",
       "( -- )",
       "Завершує цикл 'початок ... поки ... повторити' (begin ... while ... "
       "repeat), повертаючи керування на початок циклу.",
       "початок умова поки тіло повторити"});
  m_items.push_back(
      {"до",
       {"do"},
       "Керування",
       "( limit start -- )",
       "Початок лічильного циклу з фіксованою кількістю ітерацій: 'межа "
       "початок до ... цикл'. Індекс доступний через 'і'.",
       "10 0 до\n  і друк\nцикл"});
  m_items.push_back({"цикл",
                     {"loop"},
                     "Керування",
                     "( -- )",
                     "Збільшує індекс поточного циклу на 1 та повертається на "
                     "початок, доки індекс менший за межу.",
                     "5 0 до\n  \"Ітерація: \" друк і друк\nцикл"});
  m_items.push_back({"+цикл",
                     {"+loop"},
                     "Керування",
                     "( step -- )",
                     "Збільшує поточний індекс циклу на довільний крок 'step' "
                     "зі стека. Підтримує додатні та від'ємні кроки.",
                     "10 0 до\n  і друк\n2 +цикл"});
  m_items.push_back(
      {"вийти_з_циклу",
       {"leave", "вихід_з_циклу"},
       "Керування",
       "( -- )",
       "Негайний достроковий вихід з найближчого циклу 'до ... цикл'.",
       "10 0 до\n  і 5 =\n  якщо вийти_з_циклу тоді\n  і друк\nцикл"});
  m_items.push_back(
      {"вибір",
       {"case"},
       "Керування",
       "( n -- )",
       "Початок конструкції вибору 'вибір ... варіант ... кінець_варіанту ... "
       "кінець_вибору' (case/of/endof/endcase).",
       "2 вибір\n  1 варіант \"Один\" друк кінець_варіанту\n  2 варіант "
       "\"Два\" друк кінець_варіанту\n  \"Інше\" друк\nкінець_вибору"});
  m_items.push_back({"варіант",
                     {"of"},
                     "Керування",
                     "( selector val -- [selector] )",
                     "Гілка у конструкції 'вибір'. Якщо selector == val, "
                     "виконує блок до 'кінець_варіанту' і виходить з вибору.",
                     "5 варіант \"П'ять\" друк кінець_варіанту"});
  m_items.push_back(
      {"кінець_варіанту",
       {"endof"},
       "Керування",
       "( -- )",
       "Завершує блок варіанту та передає керування за межі 'кінець_вибору'.",
       "1 варіант \"Так\" друк кінець_варіанту"});
  m_items.push_back({"кінець_вибору",
                     {"endcase"},
                     "Керування",
                     "( [selector] -- )",
                     "Завершує блок 'вибір' і автоматично знімає "
                     "невикористаний селектор зі стека.",
                     "кінець_вибору"});

  // --- Змінні та визначення ---
  m_items.push_back(
      {":",
       {},
       "Змінні та константи",
       "( \"ім'я\" -- )",
       "Початок створення власного слова: ': назва дія1 дія2 ... ;'.",
       ": квадрат копія * ;\n5 квадрат друк"});
  m_items.push_back(
      {";",
       {},
       "Змінні та константи",
       "( -- )",
       "Завершує визначення власного слова, що було розпочате двокрапкою ':'.",
       ": куб копія копія * * ;\n3 куб друк"});
  m_items.push_back(
      {"змінна",
       {"variable"},
       "Змінні та константи",
       "( \"ім'я\" -- )",
       "Оголошує глобальну змінну: 'змінна назва' (або 'variable name'). При "
       "зверненні за назвою на стек кладеться посилання.",
       "змінна х\n42 х !\nх @ друк"});
  m_items.push_back({"константа",
                     {"constant"},
                     "Змінні та константи",
                     "( val \"ім'я\" -- )",
                     "Створює константу з верхнього значення стека: 'значення "
                     "константа НАЗВА' (або 'constant NAME').",
                     "3.14159 константа ПІ\nПІ 2 * друк"});
  m_items.push_back({"!",
                     {"записати"},
                     "Змінні та константи",
                     "( val var -- )",
                     "Записує значення val у змінну var.",
                     "100 баланс !"});
  m_items.push_back({"@",
                     {"читати"},
                     "Змінні та константи",
                     "( var -- val )",
                     "Зчитує поточне значення змінної var на стек.",
                     "баланс @ друк"});
  m_items.push_back({"+!",
                     {"+записати"},
                     "Змінні та константи",
                     "( delta var -- )",
                     "Додає число delta до поточного значення змінної var.",
                     "5 лічильник +!"});
  m_items.push_back({"?",
                     {"переглянути"},
                     "Змінні та константи",
                     "( var -- )",
                     "Зчитує значення змінної var та виводить його у результат "
                     "(еквівалент '@ .').",
                     "лічильник ?"});

  // --- Пам'ять та масиви ---
  m_items.push_back({"створити",
                     {"create"},
                     "Пам'ять та масиви",
                     "( \"ім'я\" -- )",
                     "Створює заголовок нового слова-буфера або масиву. При "
                     "виклику ім'я кладе свою базову адресу на стек.",
                     "створити буфер 10 комірки виділити"});
  m_items.push_back(
      {"виділити",
       {"allot"},
       "Пам'ять та масиви",
       "( n -- ) або ( addr n -- )",
       "Виділяє n комірок пам'яті для поточної або вказаної змінної/буфера.",
       "змінна масив 10 комірки виділити"});
  m_items.push_back({"комірки",
                     {"cells"},
                     "Пам'ять та масиви",
                     "( n1 -- n2 )",
                     "Масштабує кількість елементів у розмір комірок пам'яті "
                     "(1 комірка = 1 елемент).",
                     "5 комірки виділити"});
  m_items.push_back({"комірка+",
                     {"cell+"},
                     "Пам'ять та масиви",
                     "( a-addr1 -- a-addr2 )",
                     "Збільшує адресу на розмір однієї комірки пам'яті (+1).",
                     "масив комірка+ @"});
  m_items.push_back({"комірка-",
                     {"cell-"},
                     "Пам'ять та масиви",
                     "( a-addr1 -- a-addr2 )",
                     "Зменшує адресу на розмір однієї комірки пам'яті (-1).",
                     "ptr комірка- @"});
  m_items.push_back({"виділити_пам'ять",
                     {"allocate"},
                     "Пам'ять та масиви",
                     "( u -- addr ior )",
                     "Динамічно виділяє блок із u комірок пам'яті (як C "
                     "malloc). Повертає адресу та код результату 0 (успіх).",
                     "10 комірки виділити_пам'ять"});
  m_items.push_back({"звільнити_пам'ять",
                     {"free"},
                     "Пам'ять та масиви",
                     "( addr -- ior )",
                     "Звільняє динамічно виділений блок пам'яті (як C free).",
                     "буфер звільнити_пам'ять"});
  m_items.push_back(
      {"змінити_розмір",
       {"resize"},
       "Пам'ять та масиви",
       "( addr u -- new-addr ior )",
       "Змінює розмір динамічно виділеного блоку пам'яті (як C realloc).",
       "буфер 20 змінити_розмір"});
  m_items.push_back({"розмір_масиву",
                     {"array-size"},
                     "Пам'ять та масиви",
                     "( addr -- u )",
                     "Повертає розмір (кількість комірок) масиву або буфера.",
                     "масив розмір_масиву друк"});
  m_items.push_back(
      {"заповнити",
       {"fill"},
       "Пам'ять та масиви",
       "( addr u val -- )",
       "Заповнює u комірок пам'яті, починаючи з addr, значенням val.",
       "масив 10 0 заповнити"});
  m_items.push_back({"очистити_пам'ять",
                     {"erase"},
                     "Пам'ять та масиви",
                     "( addr u -- )",
                     "Заповнює u комірок пам'яті, починаючи з addr, нулями.",
                     "масив 10 очистити_пам'ять"});
  m_items.push_back(
      {"дамп",
       {"dump"},
       "Пам'ять та масиви",
       "( addr u -- )",
       "Виводить у консоль вміст u комірок масиву, починаючи з адреси addr.",
       "масив 5 дамп"});
  m_items.push_back({"масив!",
                     {"array!"},
                     "Пам'ять та масиви",
                     "( val index addr -- )",
                     "Записує значення val за індексом index у масив addr "
                     "(еквівалент 'val addr index cells + !').",
                     "42 0 масив масив!"});
  m_items.push_back({"масив@",
                     {"array@"},
                     "Пам'ять та масиви",
                     "( index addr -- val )",
                     "Зчитує значення за індексом index з масиву addr "
                     "(еквівалент 'addr index cells + @').",
                     "0 масив масив@ друк"});

  // --- Рядки ---
  m_items.push_back(
      {"довжина",
       {"length"},
       "Рядки",
       "( str -- len )",
       "Повертає точну кількість символів у рядку (підтримує UTF-8).",
       "\"Привіт, світе!\" довжина друк"});
  m_items.push_back(
      {"підрядок",
       {"substring"},
       "Рядки",
       "( str start len -- sub )",
       "Виділяє з рядка підрядок довжиною len починаючи з індексу start.",
       "\"Програмування\" 0 7 підрядок друк"});
  m_items.push_back({"в_число",
                     {"to_num"},
                     "Рядки",
                     "( str -- num )",
                     "Перетворює рядок цифр на дійсне або комплексне число.",
                     "\"3.1415\" в_число 2 * друк"});
  m_items.push_back(
      {"в_рядок",
       {"to_str"},
       "Рядки",
       "( x -- str )",
       "Конвертує будь-яке число або об'єкт на стеку у рядковий вигляд.",
       "100 в_рядок \" грн\" + друк"});
  m_items.push_back({"в_верхній",
                     {"upper"},
                     "Рядки",
                     "( str -- STR )",
                     "Переводить усі літери рядка у верхній регістр.",
                     "\"київ\" в_верхній друк"});
  m_items.push_back({"в_нижній",
                     {"lower"},
                     "Рядки",
                     "( str -- str )",
                     "Переводить усі літери рядка у нижній регістр.",
                     "\"FORTHUKR\" в_нижній друк"});

  // --- Коментарі ---
  m_items.push_back({"\\",
                     {},
                     "Коментарі",
                     "( -- )",
                     "Однорядковий коментар: ігнорує всі символи до кінця "
                     "рядка. Після '\\' обов'язковий пробіл.",
                     "\\ Це коментар до кінця рядка\n5 5 + друк"});
  m_items.push_back({"(",
                     {")"},
                     "Коментарі",
                     "( -- )",
                     "Блоковий коментар у дужках. Дужки повинні бути "
                     "відокремлені пробілами: '( коментар )'.",
                     "( Це блоковий коментар Forth )\n10 друк"});

  // --- Черепашача графіка (Turtle Graphics) ---
  m_items.push_back({"вперед",
                     {"forward", "fd"},
                     "Черепашача графіка",
                     "( dist -- )",
                     "Переміщує черепашку вперед на відстань dist у поточному "
                     "напрямку. Якщо перо опущене, малює лінію.",
                     "100 вперед"});
  m_items.push_back({"назад",
                     {"backward", "bk"},
                     "Черепашача графіка",
                     "( dist -- )",
                     "Переміщує черепашку назад на відстань dist.",
                     "50 назад"});
  m_items.push_back({"вправо",
                     {"right", "rt"},
                     "Черепашача графіка",
                     "( angle -- )",
                     "Повертає напрямок черепашки за годинниковою стрілкою на "
                     "кут angle у градусах.",
                     "90 вправо"});
  m_items.push_back({"вліво",
                     {"left", "lt"},
                     "Черепашача графіка",
                     "( angle -- )",
                     "Повертає напрямок черепашки проти годинникової стрілки "
                     "на кут angle у градусах.",
                     "45 вліво"});
  m_items.push_back({"підняти_перо",
                     {"penup", "pu"},
                     "Черепашача графіка",
                     "( -- )",
                     "Піднімає перо — наступні переміщення відбуваються без "
                     "малювання слідів на полотні.",
                     "підняти_перо 50 вперед опустити_перо"});
  m_items.push_back(
      {"опустити_перо",
       {"pendown", "pd"},
       "Черепашача графіка",
       "( -- )",
       "Опускає перо — відновлює малювання лінії при русі черепашки.",
       "опустити_перо 100 вперед"});
  m_items.push_back({"колір_пера",
                     {"колір", "pencolor"},
                     "Черепашача графіка",
                     "( color -- )",
                     "Встановлює колір пера. Підтримує назви кольорів "
                     "(\"червоний\", \"синій\", \"зелений\", \"жовтий\", "
                     "\"фіолетовий\", \"золотий\") або шістнадцятковий код.",
                     "\"червоний\" колір_пера\n\"#38bdf8\" колір_пера"});
  m_items.push_back({"товщина_пера",
                     {"товщина", "pensize", "width"},
                     "Черепашача графіка",
                     "( width -- )",
                     "Встановлює товщину лінії пера у пікселях.",
                     "3 товщина_пера"});
  m_items.push_back({"до_точки",
                     {"setxy", "goto"},
                     "Черепашача графіка",
                     "( x y -- )",
                     "Переміщує черепашку у вказану точку з координатами (x, "
                     "y) відносно центру полотна (0, 0).",
                     "100 -50 до_точки"});
  m_items.push_back({"до_центру",
                     {"home"},
                     "Черепашача графіка",
                     "( -- )",
                     "Повертає черепашку в центр полотна (0, 0) зі скиданням "
                     "кута на 0 градусів (напрямок угору).",
                     "до_центру"});
  m_items.push_back({"напрямок",
                     {"setheading", "seth"},
                     "Черепашача графіка",
                     "( angle -- )",
                     "Встановлює абсолютний кут напрямку черепашки (0 — "
                     "північ/угору, 90 — схід/вправо).",
                     "90 напрямок"});
  m_items.push_back({"очистити_полотно",
                     {"clearscreen", "cs"},
                     "Черепашача графіка",
                     "( -- )",
                     "Повністю стирає всі малюнки на полотні та повертає "
                     "черепашку до центру.",
                     "очистити_полотно"});
  m_items.push_back(
      {"коло",
       {"circle"},
       "Черепашача графіка",
       "( radius -- )",
       "Малює коло з радіусом radius навколо поточної позиції черепашки.",
       "50 коло"});

  // --- Модульність та Файли ---
  m_items.push_back({"включити",
                     {"include", "потрібно", "require"},
                     "Файли та Модульність",
                     "( \"шлях\" -- ) або включити \"шлях\"",
                     "Підключає та виконує інший Forth-файл (.fukr). Дозволяє "
                     "розбивати програми на окремі бібліотеки та модулі.",
                     "\"math_lib.fukr\" включити"});
  m_items.push_back({"файл_існує?",
                     {"file-exists?", "існує_файл?"},
                     "Файли та Модульність",
                     "( \"шлях\" -- прапорець )",
                     "Перевіряє наявність файлу за вказаним шляхом. Повертає 1 "
                     "якщо файл існує, або 0 якщо ні.",
                     "\"data.txt\" файл_існує? якщо \"Знайдено!\" друк тоді"});
  m_items.push_back(
      {"читати_файл",
       {"read-file", "read-file-str", "прочитати_файл"},
       "Файли та Модульність",
       "( \"шлях\" -- \"вміст\" )",
       "Зчитує весь текстовий вміст файлу у рядок на вершину стека.",
       "\"log.txt\" читати_файл друк"});
  m_items.push_back({"записати_файл",
                     {"write-file", "write-file-str"},
                     "Файли та Модульність",
                     "( \"вміст\" \"шлях\" -- успіх )",
                     "Створює або перезаписує файл із переданим текстовим "
                     "вмістом. Повертає 1 у разі успіху, 0 якщо помилка.",
                     "\"Привіт, файл!\" \"hello.txt\" записати_файл"});
  m_items.push_back(
      {"дописати_файл",
       {"append-file", "append-file-str"},
       "Файли та Модульність",
       "( \"вміст\" \"шлях\" -- успіх )",
       "Дописує рядок у кінець існуючого файлу або створює новий.",
       "\"Новий запис\\n\" \"log.txt\" дописати_файл"});
  m_items.push_back({"видалити_файл",
                     {"delete-file"},
                     "Файли та Модульність",
                     "( \"шлях\" -- успіх )",
                     "Видаляє файл за вказаним шляхом з диска.",
                     "\"temp.txt\" видалити_файл"});
  m_items.push_back(
      {"поточна_папка",
       {"current-dir", "pwd"},
       "Файли та Модульність",
       "( -- \"шлях\" )",
       "Кладе на стек абсолютний шлях до поточної робочої директорії програми.",
       "поточна_папка друк"});
  m_items.push_back(
      {"розмір_файлу",
       {"file-size"},
       "Файли та Модульність",
       "( \"шлях\" -- розмір_байтів )",
       "Повертає розмір файлу у байтах або -1 якщо файл не знайдено.",
       "\"data.bin\" розмір_файлу друк"});
  m_items.push_back({"створити_папку",
                     {"create-dir", "mkdir"},
                     "Файли та Модульність",
                     "( \"шлях\" -- успіх )",
                     "Створює директорію за вказаним шляхом (включаючи "
                     "проміжні підкаталоги).",
                     "\"output/reports\" створити_папку"});
}

QVariantMap HelpDatabase::getWordHelp(const QString &word) const {
  QString clean = word.trimmed();
  if (clean.isEmpty())
    return QVariantMap();

  // Перевірка на лапки рядка
  if (clean.startsWith("\"") && clean.endsWith("\"") && clean.length() >= 2) {
    QVariantMap map;
    map["name"] = "Рядковий літерал";
    map["category"] = "Літерали";
    map["stack"] = "( -- str )";
    map["desc"] = "Текстовий рядок у лапках. Кладеться на вершину стека.";
    map["example"] = "\"Привіт, світ!\"";
    map["synonyms"] = "";
    return map;
  }

  // Перевірка на число або комплексне число
  bool ok = false;
  clean.toDouble(&ok);
  if (!ok && (clean.endsWith("i") || clean.endsWith("I"))) {
    // можливо комплексне число, напр. 3+4i
    ok = true;
  }
  if (ok) {
    QVariantMap map;
    map["name"] = clean;
    map["category"] = "Літерали";
    map["stack"] = "( -- num )";
    map["desc"] = "Числовий літерал (дійсне або комплексне число). Кладеться "
                  "на вершину стека.";
    map["example"] = clean + " друк";
    map["synonyms"] = "";
    return map;
  }

  // Пошук у базі слів
  QString lower = clean.toLower();
  for (const auto &item : m_items) {
    if (item.name.compare(clean, Qt::CaseInsensitive) == 0) {
      QVariantMap map;
      map["name"] = item.name;
      map["category"] = item.category;
      map["stack"] = item.stackEffect;
      map["desc"] = item.description;
      map["example"] = item.example;
      map["synonyms"] = item.synonyms.join(", ");
      return map;
    }
    for (const auto &syn : item.synonyms) {
      if (syn.compare(clean, Qt::CaseInsensitive) == 0) {
        QVariantMap map;
        map["name"] = item.name;
        map["category"] = item.category;
        map["stack"] = item.stackEffect;
        map["desc"] = item.description;
        map["example"] = item.example;
        map["synonyms"] = item.synonyms.join(", ");
        return map;
      }
    }
  }

  return QVariantMap();
}

QVariantList HelpDatabase::getAllHelp(const QString &category,
                                      const QString &search) const {
  QVariantList list;
  QString catFilter = category.trimmed();
  QString searchFilter = search.trimmed().toLower();

  for (const auto &item : m_items) {
    if (!catFilter.isEmpty() && catFilter != "Всі" &&
        item.category != catFilter) {
      continue;
    }
    if (!searchFilter.isEmpty()) {
      bool matches = item.name.toLower().contains(searchFilter) ||
                     item.description.toLower().contains(searchFilter) ||
                     item.stackEffect.toLower().contains(searchFilter);
      if (!matches) {
        for (const auto &s : item.synonyms) {
          if (s.toLower().contains(searchFilter)) {
            matches = true;
            break;
          }
        }
      }
      if (!matches)
        continue;
    }

    QVariantMap map;
    map["name"] = item.name;
    map["category"] = item.category;
    map["stack"] = item.stackEffect;
    map["desc"] = item.description;
    map["example"] = item.example;
    map["synonyms"] = item.synonyms.join(", ");
    list.append(map);
  }

  return list;
}

QStringList HelpDatabase::getCategories() const {
  return {"Всі",
          "Стек",
          "Вивід",
          "Арифметика",
          "Комплексні числа",
          "Тригонометрія",
          "Логіка та порівняння",
          "Керування",
          "Змінні та константи",
          "Пам'ять та масиви",
          "Рядки",
          "Черепашача графіка",
          "Файли та Модульність",
          "Коментарі"};
}

QVariantList HelpDatabase::getSuggestions(const QString &prefix) const {
  QVariantList list;
  QString p = prefix.trimmed().toLower();
  for (const auto &item : m_items) {
    bool matches = p.isEmpty() || item.name.toLower().startsWith(p);
    if (!matches) {
      for (const auto &syn : item.synonyms) {
        if (syn.toLower().startsWith(p)) {
          matches = true;
          break;
        }
      }
    }
    if (matches) {
      QVariantMap map;
      map["name"] = item.name;
      map["category"] = item.category;
      map["stack"] = item.stackEffect;
      map["desc"] = item.description;
      map["example"] = item.example;
      map["synonyms"] = item.synonyms.join(", ");
      list.append(map);
    }
  }
  return list;
}