remembered that versioning exist

.gitea/workflows/build_test.yaml

@@ -6,7 +6,7 @@ jobs:
     runs-on: arch
     steps:
       - name: get dependencies
-        run: pacman -Sy nodejs make gcc --needed --noconfirm
+        run: pacman -Sy nodejs make gcc libcups nlohmann-json --needed --noconfirm
 
       - name: Checkout code
         uses: actions/checkout@v4

.gitignore

@@ -4,3 +4,4 @@ compile_commands.json
 core*
 build
 log
+complaints

Makefile

@@ -1,7 +1,8 @@
 # Compiler and flags
 CPPC = g++
-CPPC_FLAGS = -std=c++23 -s -O3 -Wall -Wextra -Wno-write-strings -lncurses -lmenu
-DEBUG_FLAGS = -ggdb -std=c++23 -Wall -Wextra -Wno-write-strings -lncurses -lmenu
+CPPC_FLAGS = -std=c++23 -s -O3 -Wall -Wextra -lncurses -lmenu -lform -lcups
+DEBUG_FLAGS = -ggdb -std=c++23 -Wall -lncurses -lmenu -lform -lcups
+DEBUG_ASANITIZE = -fsanitize=address -ggdb -fno-omit-frame-pointer -std=c++23 -lncurses -lmenu -lform -lcups -Wall -Wextra
 
 
 SRC_PATH := src
@@ -19,6 +20,9 @@ all: make-build-dir $(BIN_PATH)/ParaDocs
 debug: CPPC_FLAGS = $(DEBUG_FLAGS)
 debug: make-build-dir $(BIN_PATH)/ParaDocs
 
+asan: CPPC_FLAGS = $(DEBUG_ASANITIZE)
+asan: make-build-dir $(BIN_PATH)/ParaDocs
+
 
 make-build-dir:
 	mkdir -p $(OBJ_PATH)
@@ -39,4 +43,4 @@ install:
 clean:
 	rm -fr build
 
-.PHONY: all clean install debug
+.PHONY: all clean install debug asan

src/const.h

@@ -1,7 +1,22 @@
 
+#include <string_view>
 #ifndef NAME
 
 #define NAME "ParaDocs"
-#define VERSION "0.0.1"
+#define VERSION "1.0.0"
+
+inline constexpr auto hash_djb2a(const std::string_view sv) {
+  unsigned long hash{5381};
+  for (unsigned char c : sv) {
+    hash = ((hash << 5) + hash) ^ c;
+  }
+  return hash;
+}
+
+inline constexpr auto operator""_sh(const char *str, size_t len) {
+  return hash_djb2a(std::string_view{str, len});
+}
+
+enum { NOT_SEND, SEND, REJECTED, ACCEPTED, STATUS_COUNT };
 
 #endif

src/cups.cpp

@@ -0,0 +1,169 @@
+#include <cups/cups.h>
+#include <menu.h>
+#include <ncurses.h>
+#include <cstring>
+#include <fstream>
+#include <string>
+#include <vector>
+#include "memory.h"
+#include "types.h"
+
+std::vector<allocation> cups_allocated;
+
+bool printDocument(const std::string& content) {
+  current_allocated = &cups_allocated;
+  // Initialize variables
+  bool success = false;
+  complete_menu printer_menu = {nullptr, nullptr, 0, nullptr};
+
+  // Write content to a temporary file
+  std::string tempFileName = "/tmp/print_temp_ParaDocs.txt";
+  std::ofstream tempFile(tempFileName);
+  if (!tempFile) {
+    return false;  // Failed to create temp file
+  }
+  tempFile << content;
+  tempFile.close();
+
+  // Get printer destinations from CUPS
+  cups_dest_t* dests = nullptr;
+  int num_dests = cupsGetDests(&dests);
+  if (num_dests <= 0) {
+    remove(tempFileName.c_str());
+    return false;  // No printers available
+  }
+
+  char** item_names = new char*[num_dests];
+  cups_allocated.push_back(
+      {CHAR_PTR_ARRAY, item_names, static_cast<size_t>(num_dests)});
+  char** item_descriptions = new char*[num_dests];
+  cups_allocated.push_back(
+      {CHAR_PTR_ARRAY, item_descriptions, static_cast<size_t>(num_dests)});
+
+  // Initialize ncurses
+  initscr();
+  start_color();
+  cbreak();
+  noecho();
+  keypad(stdscr, TRUE);
+
+  try {
+    // Allocate memory for menu items
+    printer_menu.items = new ITEM*[num_dests + 1];
+
+    // Prepare menu items for each printer
+    for (int i = 0; i < num_dests; i++) {
+      // Create display name
+      std::string display_name;
+      if (dests[i].instance) {
+        display_name = std::string(dests[i].name) + "/" + dests[i].instance;
+      } else {
+        display_name = dests[i].name;
+      }
+
+      // Allocate memory for name string
+      char* name_str = new char[display_name.length() + 1];
+      std::strcpy(name_str, display_name.c_str());
+      item_names[i] = name_str;
+
+      // Get description if available
+      const char* desc =
+          cupsGetOption("printer-info", dests[i].num_options, dests[i].options);
+      std::string description = desc ? desc : "";
+
+      // Allocate memory for description string
+      char* desc_str = new char[description.length() + 1];
+      std::strcpy(desc_str, description.c_str());
+      item_descriptions[i] = desc_str;
+
+      // Create menu item
+      printer_menu.items[i] = new_item(name_str, desc_str);
+      if (!printer_menu.items[i]) {
+        throw std::runtime_error("Failed to create menu item");
+      }
+    }
+    printer_menu.items[num_dests] = nullptr;  // NULL-terminate the array
+
+    // Create the menu
+    printer_menu.menu = new_menu(printer_menu.items);
+    if (!printer_menu.menu) {
+      throw std::runtime_error("Failed to create menu");
+    }
+
+    // Set up menu window
+    int rows, cols;
+    getmaxyx(stdscr, rows, cols);
+    printer_menu.win = newwin(rows - 4, cols - 4, 2, 2);
+    keypad(printer_menu.win, TRUE);
+
+    // Set menu window and sub window
+    set_menu_win(printer_menu.menu, printer_menu.win);
+    set_menu_sub(printer_menu.menu,
+                 derwin(printer_menu.win, rows - 6, cols - 6, 1, 1));
+    set_menu_format(printer_menu.menu, rows - 8, 1);
+    set_menu_mark(printer_menu.menu, " * ");
+
+    // Post the menu with instructions
+    mvprintw(0, 0, "Select a printer and press Enter:");
+    mvprintw(rows - 2, 0, "Press q to cancel");
+    refresh();
+    post_menu(printer_menu.menu);
+    wrefresh(printer_menu.win);
+
+    // Menu interaction loop
+    int c;
+    while ((c = wgetch(printer_menu.win)) != 'q') {
+      switch (c) {
+        case KEY_DOWN:
+          menu_driver(printer_menu.menu, REQ_DOWN_ITEM);
+          break;
+        case KEY_UP:
+          menu_driver(printer_menu.menu, REQ_UP_ITEM);
+          break;
+        case 10:  // Enter key
+        {
+          ITEM* cur = current_item(printer_menu.menu);
+          int index = item_index(cur);
+
+          // Print the document to the selected printer
+          int job_id =
+              cupsPrintFile(dests[index].name, tempFileName.c_str(),
+                            "Document from application",
+                            dests[index].num_options, dests[index].options);
+
+          if (job_id > 0) {
+            success = true;
+            mvprintw(rows - 1, 0, "Printing job %d submitted successfully",
+                     job_id);
+          } else {
+            mvprintw(rows - 1, 0, "Error: %s", cupsLastErrorString());
+          }
+          refresh();
+          napms(2000);  // Display message for 2 seconds
+          c = 'q';      // Exit the loop
+          goto exit_menu;
+          break;
+        }
+      }
+      wrefresh(printer_menu.win);
+    }
+  } catch (const std::exception& e) {
+    mvprintw(0, 0, "Error: %s", e.what());
+    refresh();
+    napms(2000);
+  }
+exit_menu:
+
+  unpost_menu(printer_menu.menu);
+  wclear(printer_menu.win);
+  clear();
+
+  // Remove temp file
+  remove(tempFileName.c_str());
+
+  // Free CUPS destinations
+  cupsFreeDests(num_dests, dests);
+  delete_all(&cups_allocated);
+
+  return success;
+}

src/cups.h

@@ -0,0 +1,9 @@
+#include <string>
+
+#ifndef PARADOCS_CUPS_H_
+#define PARADOCS_CUPS_H_
+
+
+bool printDocument(const std::string& content);
+
+#endif

src/editor_easy.cpp

@@ -0,0 +1,241 @@
+#include "gameske_funkce.h"
+#include "memory.h"
+#include "strings.h"
+#include <cstring>
+#include <ctime>
+#include <form.h>
+#include <format>
+#include <ncurses.h>
+#include <string>
+#include <vector>
+
+#define HEADER_COLOR_PAIR COLOR_RED
+#define FIELD_NAME_COLOR_PAIR 10
+#define INPUT_COLOR_PAIR 11
+
+std::vector<allocation> editor_easy_allocated;
+
+[[nodiscard]] std::string vytvorTrestniOznameni() {
+  current_allocated = &editor_easy_allocated;
+  auto trim = [](const char *str) -> std::string {
+    std::string s(str);
+    if (s.empty())
+      return s;
+    size_t start = s.find_first_not_of(" \t\n\r\f\v");
+    if (start == std::string::npos)
+      return "";
+    size_t end = s.find_last_not_of(" \t\n\r\f\v");
+    return s.substr(start, end - start + 1);
+  };
+
+  curs_set(1);
+
+  // Minimální velikost terminálu
+  const int MIN_WIDTH = 90;
+  const int MIN_HEIGHT = 28;
+  if (COLS < MIN_WIDTH || LINES < MIN_HEIGHT) {
+    endwin();
+    throw std::runtime_error(loc_strings->min_terminal_size);
+  }
+
+  // Nastavení barev
+  start_color();
+  init_pair(FIELD_NAME_COLOR_PAIR, COLOR_BLACK, COLOR_CYAN); // Popisky
+  init_pair(INPUT_COLOR_PAIR, COLOR_WHITE, COLOR_BLACK);     // Vstupní pole
+
+  // Hlavní okno s rámečkem
+  WINDOW *main_win = newwin(LINES - 4, COLS - 4, 2, 2);
+  box(main_win, 0, 0);
+  wrefresh(main_win);
+
+  // Okno pro popisky
+  WINDOW *label_win = derwin(main_win, LINES - 8, 30, 1, 1);
+  wbkgd(label_win, COLOR_PAIR(FIELD_NAME_COLOR_PAIR));
+
+  // Okno pro vstupní pole
+  WINDOW *field_win = derwin(main_win, LINES - 8, COLS - 38, 1, 32);
+  wbkgd(field_win, COLOR_PAIR(INPUT_COLOR_PAIR));
+  keypad(field_win, TRUE);
+
+  // Definice polí
+  struct FieldConfig {
+    const char *label;
+    int height;
+    int width;
+    bool multiline;
+  };
+
+  FieldConfig field_configs[] = {
+      {loc_strings->name_of_submiter, 1, 40, false},
+      {loc_strings->address_of_submiter, 1, 50, false},
+      {loc_strings->phone_of_submiter, 1, 20, false},
+      {loc_strings->email_of_submiter, 1, 30, false},
+
+      {loc_strings->name_of_recipient, 1, 40, false},
+      {loc_strings->address_of_recipient, 1, 50, false},
+      {loc_strings->phone_of_recipient, 1, 20, false},
+      {loc_strings->email_of_recipient, 1, 30, false},
+
+      {loc_strings->place_of_incident, 1, 40, false},
+      {loc_strings->date_of_incident, 1, 15, false},
+      {loc_strings->description_of_incident, 4, 60, true},
+      {loc_strings->evidence_of_incident, 4, 60, true},
+      {loc_strings->additional_info, 4, 60, true}};
+
+  // Vykreslení popisků
+  int label_row = 0;
+  for (const FieldConfig &cfg : field_configs) {
+    mvwprintw(label_win, label_row, 0, "%s", cfg.label);
+    label_row += cfg.height + 1;
+  }
+  wrefresh(label_win);
+
+  // Vytvoření formuláře
+  std::vector<FIELD *> fields;
+  int field_row = 0;
+
+  for (const FieldConfig &cfg : field_configs) {
+    FIELD *field = new_field(cfg.height, cfg.width, field_row, 0, 0, 0);
+    set_field_back(field, A_UNDERLINE | COLOR_PAIR(INPUT_COLOR_PAIR));
+    field_opts_off(field, O_AUTOSKIP | O_STATIC);
+
+    if (cfg.multiline) {
+      field_opts_on(field, O_WRAP);
+      set_max_field(field, 500);
+    }
+
+    fields.push_back(field);
+    field_row += cfg.height + 1;
+  }
+  fields.push_back(nullptr);
+
+  FORM *form = new_form(&fields[0]);
+  set_form_win(form, field_win);
+  set_form_sub(form, derwin(field_win, LINES - 10, COLS - 40, 0, 1));
+
+  post_form(form);
+  form_driver(form, REQ_FIRST_FIELD);
+
+  // Hlavička
+  attron(COLOR_PAIR(HEADER_COLOR_PAIR));
+  mvprintw(0, (COLS - 40) / 2, "%s",
+           loc_strings->cease_and_desist_entry_of_information);
+  mvprintw(1, 2, "%s", loc_strings->enter_all_information_and_press_f10);
+  refresh();
+
+  // Hlavní smyčka
+  int ch;
+  bool exit_loop = false;
+  while (!exit_loop && (ch = wgetch(field_win))) {
+    switch (ch) {
+    case KEY_F(10):
+      exit_loop = true;
+      break;
+
+    case KEY_DOWN:
+      form_driver(form, REQ_NEXT_FIELD);
+      form_driver(form, REQ_END_LINE);
+      break;
+
+    case KEY_UP:
+      form_driver(form, REQ_PREV_FIELD);
+      form_driver(form, REQ_END_LINE);
+      break;
+
+    case KEY_LEFT:
+      form_driver(form, REQ_PREV_CHAR);
+      break;
+
+    case KEY_RIGHT:
+      form_driver(form, REQ_NEXT_CHAR);
+      break;
+
+    case KEY_BACKSPACE:
+    case 127:
+      form_driver(form, REQ_DEL_PREV);
+      break;
+
+    case KEY_DC:
+      form_driver(form, REQ_DEL_CHAR);
+      break;
+
+    case 10: // Enter
+      if (field_configs[current_field(form)->index].multiline) {
+        form_driver(form, REQ_NEW_LINE);
+      } else {
+        form_driver(form, REQ_NEXT_FIELD);
+      }
+      break;
+
+    case '\t':
+      form_driver(form, REQ_NEXT_FIELD);
+      break;
+
+    case KEY_BTAB:
+      form_driver(form, REQ_PREV_FIELD);
+      break;
+
+    default:
+      form_driver(form, ch);
+      break;
+    }
+
+    // Ruční aktualizace všech oken
+    touchwin(main_win);
+    wrefresh(main_win);
+    wrefresh(label_win);
+    wrefresh(field_win);
+  }
+
+  // Získání dat
+  form_driver(form, REQ_VALIDATION);
+  std::vector<std::string> field_values;
+  for (size_t i = 0; i < ARRAY_SIZE(field_configs); i++) {
+    field_values.push_back(trim(field_buffer(fields[i], 0)));
+  }
+
+  // Úklid
+  unpost_form(form);
+  free_form(form);
+  for (fieldnode *&f : fields)
+    if (f)
+      free_field(f);
+  delwin(label_win);
+  delwin(field_win);
+  delwin(main_win);
+  curs_set(0);
+  clear();
+
+  // Aktuální datum
+  std::time_t t = std::time(nullptr);
+  std::tm *now = std::localtime(&t);
+  char date_str[100];
+  std::strftime(date_str, sizeof(date_str), "%d.%m.%Y", now);
+
+  auto comp_args =
+      std::make_format_args(field_values[0], // Jméno a příjmení odesílatele
+                            field_values[1], // Adresa odesílatele
+                            field_values[2], // Telefon odesílatele
+                            field_values[3], // Email odesílatele
+
+                            field_values[4], // Jméno a příjmení adresáta
+                            field_values[5], // Adresa adresáta
+                            field_values[6], // Telefon adresáta
+                            field_values[7], // Email adresáta
+
+                            date_str,        // Aktuální datum
+                            field_values[8], // Místo činu
+                            field_values[9], // Datum činu
+
+                            field_values[10], // Popis činu
+                            field_values[11], // Důkazy
+                            field_values[12], // Další informace
+                            field_values[0]   // Jméno pro podpis
+      );
+
+  std::string complaint =
+      std::vformat(loc_strings->criminal_complaint_template, comp_args);
+
+  delete_all(&editor_easy_allocated);
+  return complaint;
+}

src/editor_easy.h

@@ -0,0 +1,8 @@
+#include <string>
+
+#ifndef PARADOCS_EDEA_H_
+#define PARADOCS_EDEA_H_
+
+[[nodiscard]] std::string vytvorTrestniOznameni();
+
+#endif

src/editor_hard.cpp

@@ -0,0 +1,190 @@
+#include "strings.h"
+#include <cstddef>
+#include <cstdint>
+#include <ncurses.h>
+#include <nlohmann/json.hpp>
+#include <nlohmann/json_fwd.hpp>
+#include <sstream>
+#include <string>
+#include <vector>
+using nlohmann::json;
+
+void save_document(std::string &text, std::vector<std::string> &lines) {
+  text = "";
+  for (const std::string &line : lines) {
+    text.append(line);
+    text.append("\n");
+  }
+}
+
+void editor_hard(std::string &text) {
+  uint16_t cursor_x = 0;
+  uint16_t cursor_y = 0;
+  std::vector<std::string> lines;
+  char mode = 'n';
+  uint16_t window_height, window_width;
+
+  mode = 'n';
+
+  noecho();
+  curs_set(1);
+  cbreak();
+  keypad(stdscr, TRUE);
+  getmaxyx(stdscr, window_height, window_width);
+
+  // Parse the multi-line string into individual lines
+  lines.clear();
+  std::stringstream ss(text);
+  std::string line;
+
+  while (std::getline(ss, line)) {
+    lines.push_back(line);
+  }
+
+  // Ensure at least one empty line exists
+  if (lines.empty()) {
+    lines.push_back("");
+  }
+  while (true) {
+    clear();
+    // Draw text lines
+    for (size_t i = 0;
+         i < static_cast<size_t>(window_height) - 1 && i < lines.size(); i++) {
+      mvprintw(i, 0, "%s", lines[i].c_str());
+    }
+
+    // Draw status line
+    std::string status = "Mode: " + std::string(1, mode);
+    mvprintw(window_height - 1, 0, "%s", status.c_str());
+
+    move(cursor_y, cursor_x);
+    refresh();
+    {
+      int ch = getch();
+      switch (mode) {
+      case 'n': // Normal mode
+        switch (ch) {
+        case 'h':
+          if (cursor_x > 0) {
+            cursor_x--;
+          }
+          break;
+        case 'j':
+          if (cursor_y < lines.size() - 1) {
+            cursor_y++;
+            if (cursor_x > lines[cursor_y].length()) {
+              cursor_x = lines[cursor_y].length();
+            }
+          }
+          break;
+        case 'k':
+          if (cursor_y > 0) {
+            cursor_y--;
+            if (cursor_x > lines[cursor_y].length()) {
+              cursor_x = lines[cursor_y].length();
+            }
+          }
+
+          break;
+        case 'l':
+          if (cursor_x < lines[cursor_y].length()) {
+            cursor_x++;
+          }
+          break;
+        case 'i':
+        case 'a':
+          mode = 'i';
+          break;
+        case 'x':
+          if (cursor_x < lines[cursor_y].length()) {
+            lines[cursor_y].erase(cursor_x, 1);
+          }
+          break;
+        case ':': {
+          // Enter command mode
+          std::string command = "";
+          int cmd_ch;
+          // Show command prompt
+          mvprintw(window_height - 1, 0, ":%s", command.c_str());
+          clrtoeol();
+          refresh();
+
+          while ((cmd_ch = getch()) != '\n' && cmd_ch != '\r') {
+            if (cmd_ch == 27) { // ESC - cancel command
+              break;
+            } else if (cmd_ch == KEY_BACKSPACE || cmd_ch == 127) {
+              if (!command.empty()) {
+                command.pop_back();
+              }
+            } else if (cmd_ch >= 32 && cmd_ch <= 126) {
+              command += static_cast<char>(cmd_ch);
+            }
+
+            mvprintw(window_height - 1, 0, ":%s", command.c_str());
+            clrtoeol();
+            refresh();
+          }
+
+          // Execute command
+          if (cmd_ch != 27) { // If not cancelled
+            switch (hash_djb2a(command)) {
+            case "q"_sh:
+              return;
+              break;
+            case "w"_sh:
+              save_document(text, lines);
+              break;
+
+            case "wq"_sh:
+            case "x"_sh:
+              save_document(text, lines);
+              return;
+              break;
+
+            case "q!"_sh:
+              return;
+              break;
+            }
+          }
+        } break;
+        }
+        break;
+
+      case 'i': // Insert mode
+        switch (ch) {
+        case 27: // ESC
+          mode = 'n';
+          if (cursor_x > 0)
+            cursor_x--;
+          break;
+        case KEY_BACKSPACE:
+        case 127:
+          if (mode == 'i' && cursor_x > 0) {
+            lines[cursor_y].erase(cursor_x - 1, 1);
+            cursor_x--;
+          }
+          break;
+        case '\n':
+        case '\r': {
+          // Insert new line
+          std::string new_line = lines[cursor_y].substr(cursor_x);
+          lines[cursor_y] = lines[cursor_y].substr(0, cursor_x);
+          lines.insert(lines.begin() + cursor_y + 1, new_line);
+          cursor_y++;
+          cursor_x = 0;
+          break;
+        }
+        default:
+          if (ch >= 32 && ch <= 126) {
+            if (mode == 'i') {
+              lines[cursor_y].insert(cursor_x, 1, ch);
+              cursor_x++;
+            }
+          }
+          break;
+        }
+        break;
+      }
+    }
+  }
+}

src/editor_hard.h

@@ -0,0 +1,5 @@
+#ifndef PARADOCS_EDEH_H_
+#define PARADOCS_EDEH_H_
+#include <string>
+void editor_hard(std::string& text);
+#endif

src/gameske_funkce.cpp

@@ -1,78 +1,23 @@
 #include "gameske_funkce.h"
+#include <curses.h>
 #include <menu.h>
+#include <ncurses.h>
+#include <unistd.h>
+#include <chrono>
 #include <clocale>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
-
-size_t spawn_menu(uint16_t begin_y, uint16_t begin_x, const char** choices,
-                  size_t n_choices) {
-  ITEM** sp_items;
-  int c;
-  MENU* sp_menu;
-  WINDOW* sp_menu_win;
-  int i;
-
-  sp_items = new ITEM*[n_choices];
-  /* Create items */
-  for (i = 0; i < n_choices; ++i) {
-    sp_items[i] = new_item(choices[i], choices[i]);
-  }
-
-  /* Crate menu */
-  sp_menu = new_menu(sp_items);
-
-  /* Create the window to be associated with the menu */
-  sp_menu_win = newwin(10, 40, begin_y, begin_x);
-  keypad(sp_menu_win, TRUE);
-
-  /* Set main window and sub window */
-  set_menu_win(sp_menu, sp_menu_win);
-  set_menu_sub(sp_menu, derwin(sp_menu_win, 6, 38, begin_y - 1, begin_x - 3));
-
-  /* Set menu mark to the string " * " */
-  set_menu_mark(sp_menu, " * ");
-
-  /* Print a border around the main window and print a title */
-  box(sp_menu_win, 0, 0);
-  print_in_middle(sp_menu_win, 1, 0, 40, "My Menu", COLOR_PAIR(1));
-  mvwaddch(sp_menu_win, 2, 0, ACS_LTEE);
-  mvwhline(sp_menu_win, 2, 1, ACS_HLINE, 38);
-  mvwaddch(sp_menu_win, 2, 39, ACS_RTEE);
-  mvprintw(LINES - 2, 0, "F1 to exit");
-  refresh();
-
-  /* Post the menu */
-  post_menu(sp_menu);
-  wrefresh(sp_menu_win);
-
-  while ((c = wgetch(sp_menu_win)) != 10) {
-    switch (c) {
-      case KEY_DOWN:
-        menu_driver(sp_menu, REQ_DOWN_ITEM);
-        break;
-      case KEY_UP:
-        menu_driver(sp_menu, REQ_UP_ITEM);
-        break;
-    }
-    wrefresh(sp_menu_win);
-  }
-  size_t selected = item_index(current_item(sp_menu));
-
-  /* Unpost and free all the memory taken up */
-  unpost_menu(sp_menu);
-  free_menu(sp_menu);
-  for (i = 0; i < n_choices; ++i)
-    free_item(sp_items[i]);
-  delete[] sp_items;
-
-  return selected;
-}
+#include <format>
+#include <iostream>
+#include <string>
+#include <thread>
+#include "memory.h"
 
 void print_in_middle(WINDOW* win, int starty, int startx, int width,
-                     char* string, chtype color) {
+                     const char* string, chtype color) {
   int length, x, y;
-  float temp;
+  uint8_t temp;
 
   if (win == NULL)
     win = stdscr;
@@ -86,9 +31,121 @@ void print_in_middle(WINDOW* win, int starty, int startx, int width,
 
   length = strlen(string);
   temp = (width - length) / 2;
-  x = startx + (int)temp;
+  x = startx + temp;
   wattron(win, color);
   mvwprintw(win, y, x, "%s", string);
   wattroff(win, color);
   refresh();
 }
+
+std::string spawncmd(const std::string prompt) {
+  char cmd[100] = {0};
+  int pos = 0;
+  int ch;
+
+  WINDOW* cmd_win = newwin(3, 40, LINES - 3, 0);
+  if (cmd_win == NULL)
+    return "";
+
+  keypad(cmd_win, TRUE);
+  box(cmd_win, 0, 0);
+  mvwprintw(cmd_win, 1, 1, "%s: ", prompt.c_str());
+  curs_set(1);
+  wrefresh(cmd_win);
+
+  wattron(cmd_win, COLOR_PAIR(COLOR_CYAN));
+
+  // Get input character by character
+  while (pos < 99) {
+    ch = wgetch(cmd_win);
+
+    if (ch == '\n' || ch == KEY_ENTER) {
+      // Enter key pressed, end input
+      break;
+    } else if (ch == KEY_BACKSPACE || ch == 127) {
+      // Backspace key
+      if (pos > 0) {
+        pos--;
+        // Move cursor back and erase the character
+        wmove(cmd_win, 1, prompt.length() + 3 + pos);
+        waddch(cmd_win, ' ');
+        wmove(cmd_win, 1, 10 + pos);
+      }
+    } else if (ch == KEY_DC) {
+      // Delete key - not implemented in this simple example
+    } else if (isprint(ch)) {
+      // Printable character
+      cmd[pos] = ch;
+      mvwaddch(cmd_win, 1, prompt.length() + 3 + pos,
+               ch);  // Echo the character
+      pos++;
+    }
+
+    wrefresh(cmd_win);
+  }
+  wattroff(cmd_win, COLOR_PAIR(COLOR_CYAN));
+
+  cmd[pos] = '\0';  // Ensure null termination
+  // Restore echo state as needed
+  curs_set(0);
+
+  wclear(cmd_win);
+  wrefresh(cmd_win);
+  delwin(cmd_win);
+  return std::string(cmd);
+}
+
+void async_clock(WINDOW* win, WINDOW* text_win) {
+  std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  bool prev_echo_state;
+  uint16_t prev_y, prev_x;
+  while (true) {
+    prev_echo_state = is_echo();
+    getyx(stdscr, prev_y, prev_x);
+    noecho();
+    wborder(text_win, 0, ' ', 0, 0, 0, ACS_HLINE, 0, ACS_HLINE);
+    mvwprintw(text_win, 1, 1, "správný čas na podání trestního oznámení je");
+    wrefresh(text_win);
+    auto now =
+        std::chrono::current_zone()->to_local(std::chrono::system_clock::now());
+    std::string time_str;
+    try {
+      // Format just the time (HH:MM:SS)
+      time_str = std::format("{:%T}", now);
+      // Remove fractional seconds
+      size_t dot_pos = time_str.find('.');
+      if (dot_pos != std::string::npos) {
+        time_str.erase(dot_pos);
+      }
+    } catch (const std::exception& e) {
+      std::clog << "Format error: " << e.what() << std::endl;
+      time_str = "Error";
+    }
+
+    werase(win);
+    wborder(win, 0, 0, 0, 0, ACS_TTEE, 0, ACS_BTEE, 0);
+
+    mvwprintw(win, 1, 1, "%s", time_str.c_str());
+    wrefresh(win);
+    if (prev_echo_state) {
+      echo();
+    }
+    move(prev_y, prev_x);
+    refresh();
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+  }
+}
+
+void async_clock_init() {
+
+  // memory leak
+  WINDOW* win = newwin(3, 10, LINES - 3, COLS - 10);
+  current_allocated->push_back({WINDOW_TYPE, win, 1});
+
+  // memory leak
+  WINDOW* text_win = newwin(3, 52, LINES - 3, COLS - 10 - 44);
+  current_allocated->push_back({WINDOW_TYPE, text_win, 1});
+
+  std::thread clock_thread(async_clock, win, text_win);
+  clock_thread.detach();
+}

src/gameske_funkce.h

@@ -1,9 +1,20 @@
+#include "strings.h"
 #include <ncurses.h>
+#include <string>
+
+#ifndef PARADOCS_GAFU_H_
+#define PARADOCS_GAFU_H_
 
 #define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
 
-size_t spawn_menu(uint16_t begin_y, uint16_t begin_x, const char** choices,
+size_t spawn_menu(uint16_t begin_y, uint16_t begin_x, const char **choices,
                   size_t n_choices);
 
-void print_in_middle(WINDOW* win, int starty, int startx, int width,
-                     char* string, chtype color);
+void print_in_middle(WINDOW *win, int starty, int startx, int width,
+                     const char *string, chtype color);
+
+std::string spawncmd(const std::string prompt = loc_strings->command);
+
+void async_clock_init();
+
+#endif // PARADOCS_GAFU_H_

src/main.cpp

@@ -1,9 +1,14 @@
-#include <unistd.h>
-#include <cstdlib>
-#include <iostream>
 #include "color.h"
 #include "const.h"
 #include "menu.h"
+#include "signal.h"
+#include "strings.h"
+#include <csignal>
+#include <cstdlib>
+#include <iostream>
+#include <locale>
+#include <regex>
+#include <unistd.h>
 
 void PrintHelp() {
   std::cout << RED R"( ____                         ____
@@ -13,19 +18,41 @@ void PrintHelp() {
   \ \ \/\ \L\.\_\ \ \//\ \L\.\_\ \ \_\ \/\ \L\ \/\ \__//\__, `\
    \ \_\ \__/.\_\\ \_\\ \__/.\_\\ \____/\ \____/\ \____\/\____/
     \/_/\/__/\/_/ \/_/ \/__/\/_/ \/___/  \/___/  \/____/\/___/)"
-            << RESET "\nUsage:\n"
-            << NAME << " [options]\n"
-            << "-h\t\tPrint this help\n"
-            << "-V\t\tPrint version\n";
+            << RESET "\n"
+            << loc_strings->usage << ":\n"
+            << NAME << " [" << loc_strings->options << "]\n"
+            << "-h\t\t" << loc_strings->print_this_help << "\n"
+            << "-V\t\t" << loc_strings->print_version << "\n";
   exit(0);
 }
 
 void PrintVersion() {
-  std::cout << NAME << " version " << VERSION << "\n";
+  std::cout << NAME << " " << loc_strings->version << ": " << VERSION << "\n";
   exit(0);
 }
 
-int main(int argc, char* argv[]) {
+int main(int argc, char *argv[]) {
+  // signal handlers
+  std::signal(SIGTERM, safe_exit);
+  std::signal(SIGINT, safe_exit);
+  std::signal(SIGQUIT, safe_exit);
+  std::signal(SIGHUP, safe_exit);
+
+  // error signal handlers
+  signal(SIGSEGV, safe_exit);
+
+  // set locale
+  {
+    std::locale loc("");
+    std::regex czech_regex("czech|cz", std::regex_constants::icase |
+                                           std::regex_constants::ECMAScript);
+
+    if (std::regex_search(loc.name(), czech_regex)) {
+      loc_strings = &czech_strings;
+    } else {
+      loc_strings = &english_strings;
+    }
+  }
 
   int opt;
   while ((opt = getopt(argc, argv, "hV")) != -1) {
@@ -37,8 +64,9 @@ int main(int argc, char* argv[]) {
       PrintVersion();
       break;
     default:
-        std::cerr << RED "[ERROR]" << RESET " invalid option: " << (char)optopt
-                  << "\ntry: -h\n";
+      std::cerr << RED "[ERROR]" << RESET " " << loc_strings->invalid_option
+                << ": " << (char)optopt << "\n"
+                << loc_strings->try_str << ": -h\n";
       return EINVAL;
     }
   }

src/memory.cpp

@@ -0,0 +1,99 @@
+#include "memory.h"
+#include <curses.h>
+#include <menu.h>
+#include <ncurses.h>
+// #include <panel.h> UNCOMENT IF IF WE USE PANELs
+#include <iostream>
+#include "color.h"
+#include "types.h"
+
+std::vector<allocation>* current_allocated;
+
+template <typename T>
+struct NcursesDeleter {
+  static void delete_element(T obj);
+};
+
+template <>
+void NcursesDeleter<WINDOW*>::delete_element(WINDOW* win) {
+  delwin(win);
+}
+/*template <>
+void NcursesDeleter<PANEL*>::delete_element(PANEL* pan) {
+  del_panel(pan);
+} UNCOMENT IF WE USE PANELs*/
+template <>
+void NcursesDeleter<ITEM*>::delete_element(ITEM* item) {
+  free_item(item);
+}
+
+template <typename T>
+void delete_ncurses_arrays(void* ptr, std::size_t size) {
+  T* array = static_cast<T*>(ptr);
+  for (std::size_t j = 0; j < size; ++j) {
+    NcursesDeleter<T>::delete_element(array[j]);
+  }
+  delete[] array;
+}
+
+void delete_all(std::vector<allocation>* allocated) {
+  if (allocated == nullptr) {
+    return;
+  }
+  for (long long i = allocated->size() - 1; i >= 0; i--) {
+    switch (allocated->at(i).type) {
+      case WINDOW_ARRAY: {
+        delete_ncurses_arrays<WINDOW*>(allocated->at(i).ptr,
+                                       allocated->at(i).size);
+        break;
+      }
+      /* case PANEL_ARRAY: {
+        delete_ncurses_arrays<PANEL*>(allocated->at(i).ptr,
+                                      allocated->at(i).size);
+        break;
+      } UNCOMENT IF WE USE PANELs*/
+      case ITEM_ARRAY: {
+        delete_ncurses_arrays<ITEM*>(allocated->at(i).ptr,
+                                     allocated->at(i).size);
+        break;
+      }
+      case CHAR_PTR_ARRAY: {
+        char** array = static_cast<char**>(allocated->at(i).ptr);
+        for (std::size_t j = 0; j < allocated->at(i).size; ++j) {
+          delete[] array[j];
+        }
+        delete[] array;
+        break;
+      }
+      case GENERIC_ARRAY:
+        delete[] static_cast<char*>(allocated->at(i).ptr);
+        break;
+      case WINDOW_TYPE:
+        delwin(static_cast<WINDOW*>(allocated->at(i).ptr));
+        break;
+      /*case PANEL_TYPE:
+        del_panel(static_cast<PANEL*>(allocated->at(i).ptr));
+        break; UNCOMENT IF WE USE PANELs */
+      case MENU_TYPE:
+        free_menu(static_cast<MENU*>(allocated->at(i).ptr));
+        break;
+      case COMPLETE_MENU_TYPE: {
+        free_menu(static_cast<complete_menu*>(allocated->at(i).ptr)->menu);
+        delwin(static_cast<complete_menu*>(allocated->at(i).ptr)->win);
+        delete_ncurses_arrays<ITEM*>(
+            static_cast<complete_menu*>(allocated->at(i).ptr)->items,
+            static_cast<complete_menu*>(allocated->at(i).ptr)->items_size);
+
+        break;
+      }
+      case GENERIC_TYPE:
+        delete static_cast<char*>(allocated->at(i).ptr);
+        break;
+      default:
+        std::cerr << RED "[!!CRITICAL!!]" << RESET " Unknown allocation type"
+                  << "\n";
+        break;
+    }
+    allocated->pop_back();
+  }
+}

src/memory.h

@@ -0,0 +1,30 @@
+// header guard
+#ifndef PARADOCS_MEMORY_H_
+#define PARADOCS_MEMORY_H_
+
+#include <menu.h>
+#include <cstddef>
+#include <vector>
+enum AllocationType {
+  WINDOW_ARRAY,
+  //  PANEL_ARRAY, UNCOMENT IF WE USE PANELs
+  ITEM_ARRAY,
+  CHAR_PTR_ARRAY,
+  GENERIC_ARRAY,
+  WINDOW_TYPE,
+  //  PANEL_TYPE, UNCOMENT IF WE USE PANELs
+  MENU_TYPE,
+  COMPLETE_MENU_TYPE,
+  GENERIC_TYPE
+};
+
+struct allocation {
+  AllocationType type;
+  void* ptr;
+  std::size_t size;
+};
+
+extern std::vector<allocation>* current_allocated;
+
+void delete_all(std::vector<allocation>* allocated);
+#endif

src/menu.cpp

@@ -1,87 +1,448 @@
-#include <curses.h>
-#include <menu.h>
-#include <clocale>
+#include "color.h"
+#include "const.h"
+#include "cups.h"
+#include "editor_easy.h"
+#include "editor_hard.h"
+#include "gameske_funkce.h"
+#include "memory.h"
+#include "signal.h"
+#include "strings.h"
+#include "types.h"
+#include <array>
+#include <cerrno>
+#include <climits>
+#include <cstddef>
+#include <cstdint>
 #include <cstdlib>
 #include <cstring>
-#include "gameske_funkce.h"
+#include <curses.h>
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+#include <menu.h>
+#include <ncurses.h>
+#include <nlohmann/json.hpp>
+#include <sstream>
+#include <string>
+#include <vector>
 
-#define CTRLD 4
+using nlohmann::json;
 
-const char* choices[] = {"paradox", "kompromis", "Stereotyp", "Žena"};
-const char* date[] = {"2023-10-01", "2023-10-02", "2023-10-03", "2023-10-04"};
-const char* choices2[] = {"PRINT", "EDIT", "DELETE", "Žena"};
+std::vector<allocation> main_menu_allocated;
+#define COMPLAINTS_DIR "complaints"
+
+std::array<std::string, 2> get_name_date_from_item(ITEM *item) {
+  std::stringstream ss(item_description(item));
+  std::array<std::string, 2> name_date;
+  name_date[0] = item_name(item);
+  std::getline(ss, name_date[1], ' ');
+  return name_date;
+}
+
+void reload_menu_from_directory(complete_menu &main_menu) {
+  // Clean up existing menu items and allocated memory
+  if (main_menu.menu != nullptr) {
+    unpost_menu(main_menu.menu);
+    free_menu(main_menu.menu);
+    main_menu.menu = nullptr;
+  }
+
+  // Free existing menu items
+  if (main_menu.items != nullptr) {
+    for (size_t i = 0; i < main_menu.items_size; i++) {
+      if (main_menu.items[i] != nullptr) {
+        free_item(main_menu.items[i]);
+      }
+    }
+    delete[] main_menu.items;
+    main_menu.items = nullptr;
+  }
+
+  // Clean up allocated memory (excluding the complete_menu itself)
+  for (auto it = main_menu_allocated.begin();
+       it != main_menu_allocated.end();) {
+    if (it->type == GENERIC_TYPE) {
+      delete[] static_cast<char *>(it->ptr);
+      it = main_menu_allocated.erase(it);
+    } else {
+      ++it;
+    }
+  }
+
+  // Recreate items from directory (same logic as initialization)
+  std::vector<ITEM *> items;
+
+  if (std::filesystem::exists(COMPLAINTS_DIR)) {
+    for (const std::filesystem::directory_entry &directroy_entry :
+         std::filesystem::directory_iterator(COMPLAINTS_DIR)) {
+      if (directroy_entry.is_regular_file()) {
+        std::ifstream file(directroy_entry.path());
+        std::string name_date[2];
+        std::stringstream ssfn(directroy_entry.path().filename().string());
+
+        for (uint8_t i = 0; i < ARRAY_SIZE(name_date); i++) {
+          std::getline(ssfn, name_date[i], '_');
+        }
+        try {
+          json complaint_json = json::parse(file);
+
+          if (complaint_json["status"].is_null() ||
+              complaint_json["status"].get<uint8_t>() >= STATUS_COUNT) {
+            std::cerr << "Invalid status in file: "
+                      << directroy_entry.path().filename().string()
+                      << std::endl;
+            safe_exit(EINVAL);
+          }
+
+          name_date[1].append(" ");
+          name_date[1].append(
+              loc_strings
+                  ->status_strings[complaint_json["status"].get<uint8_t>()]);
+        } catch (...) {
+          continue;
+        }
+
+        char *name = new char[name_date[0].length() + 1];
+        main_menu_allocated.push_back({GENERIC_TYPE, name, 1});
+        char *date = new char[name_date[1].length() + 1];
+        main_menu_allocated.push_back({GENERIC_TYPE, date, 1});
+
+        strcpy(name, name_date[0].c_str());
+        strcpy(date, name_date[1].c_str());
+        items.push_back(new_item(name, date));
+      }
+    }
+  }
+
+  // Add null terminator
+  items.push_back(nullptr);
+
+  // Create new menu items array
+  main_menu.items = new ITEM *[items.size()];
+  main_menu.items_size = items.size() - 1;
+  memcpy(main_menu.items, items.data(), (items.size() * sizeof(ITEM *)));
+
+  // Create new menu
+  main_menu.menu = new_menu(main_menu.items);
+
+  // Restore menu settings
+  set_menu_win(main_menu.menu, main_menu.win);
+  set_menu_sub(main_menu.menu, derwin(main_menu.win, 6, 38, 3, 1));
+  set_menu_mark(main_menu.menu, " * ");
+
+  // Post the menu
+  post_menu(main_menu.menu);
+  wrefresh(main_menu.win);
+}
 
 void menu() {
-  ITEM** my_items;
-  int c;
-  MENU* my_menu;
-  WINDOW* my_menu_win;
-  int n_choices, i;
-
+  current_allocated = &main_menu_allocated;
   /* Initialize curses */
+
   setlocale(LC_ALL, "");
   initscr();
   start_color();
   cbreak();
   noecho();
+  curs_set(0); // Makes cursor invisible
   keypad(stdscr, TRUE);
-  init_pair(1, COLOR_RED, COLOR_BLACK);
+  for (uint8_t i = 0; i < 8; i++) {
+    init_pair(i, i, COLOR_BLACK);
+  }
+  async_clock_init();
 
-  /* Create items */
-  n_choices = ARRAY_SIZE(choices);
-  my_items = new ITEM*[ARRAY_SIZE(choices)];
-  for (i = 0; i < n_choices; ++i)
-    my_items[i] = new_item(choices[i], date[i]);
+  // Create items
+  complete_menu main_menu = {nullptr, nullptr, 0, nullptr};
+  main_menu_allocated.push_back({COMPLETE_MENU_TYPE, &main_menu, 1});
+  {
+    std::vector<ITEM *> items;
+    if (std::filesystem::exists(COMPLAINTS_DIR)) {
+      for (const std::filesystem::directory_entry &directroy_entry :
+           std::filesystem::directory_iterator(COMPLAINTS_DIR)) {
+        if (directroy_entry.is_regular_file()) {
+          std::ifstream file(directroy_entry.path());
+          std::string name_date[2];
+          std::stringstream ssfn(directroy_entry.path().filename().string());
+          for (uint8_t i = 0; i < ARRAY_SIZE(name_date); i++) {
+            std::getline(ssfn, name_date[i], '_');
+          }
+          try {
+            json complaint_json = json::parse(file);
+            if (complaint_json["status"].is_null() ||
+                complaint_json["status"].get<size_t>() >= STATUS_COUNT) {
+              std::cerr << "Invalid status in file: "
+                        << directroy_entry.path().filename().string()
+                        << std::endl;
+              safe_exit(EINVAL);
+            }
+            name_date[1].append(" ");
+            name_date[1].append(
+                loc_strings
+                    ->status_strings[complaint_json["status"].get<uint8_t>()]);
+          } catch (...) {
+            continue;
+          }
+
+          char *name = new char[name_date[0].length() + 1];
+          main_menu_allocated.push_back({GENERIC_TYPE, name, 1});
+          char *date = new char[name_date[1].length() + 1];
+          main_menu_allocated.push_back({GENERIC_TYPE, date, 1});
+          strcpy(name, name_date[0].c_str());
+          strcpy(date, name_date[1].c_str());
+          items.push_back(new_item(name, date));
+        }
+      }
+    } else {
+      std::filesystem::create_directory(COMPLAINTS_DIR);
+    }
+    items.push_back(nullptr);
+    main_menu.items = new ITEM *[items.size()];
+    main_menu.items_size = items.size() - 1;
+    memcpy(main_menu.items, items.data(), (items.size() * sizeof(ITEM *)));
+  }
 
   /* Crate menu */
-  my_menu = new_menu(my_items);
+  main_menu.menu = new_menu(main_menu.items);
 
   /* Create the window to be associated with the menu */
-  my_menu_win = newwin(10, 40, 4, 4);
-  keypad(my_menu_win, TRUE);
+  main_menu.win = newwin(10, 40, 4, 4);
+  keypad(main_menu.win, TRUE);
 
   /* Set main window and sub window */
-  set_menu_win(my_menu, my_menu_win);
-  set_menu_sub(my_menu, derwin(my_menu_win, 6, 38, 3, 1));
+  set_menu_win(main_menu.menu, main_menu.win);
+  set_menu_sub(main_menu.menu, derwin(main_menu.win, 6, 38, 3, 1));
 
   /* Set menu mark to the string " * " */
-  set_menu_mark(my_menu, " * ");
+  set_menu_mark(main_menu.menu, " * ");
 
   /* Print a border around the main window and print a title */
-  box(my_menu_win, 0, 0);
-  print_in_middle(my_menu_win, 1, 0, 40, "My Menu", COLOR_PAIR(1));
-  mvwaddch(my_menu_win, 2, 0, ACS_LTEE);
-  mvwhline(my_menu_win, 2, 1, ACS_HLINE, 38);
-  mvwaddch(my_menu_win, 2, 39, ACS_RTEE);
-  mvprintw(LINES - 2, 0, "F1 to exit");
+  box(main_menu.win, 0, 0);
+  print_in_middle(main_menu.win, 1, 0, 40, loc_strings->main_menu,
+                  COLOR_PAIR(1));
+  mvwaddch(main_menu.win, 2, 0, ACS_LTEE);
+  mvwhline(main_menu.win, 2, 1, ACS_HLINE, 38);
+  mvwaddch(main_menu.win, 2, 39, ACS_RTEE);
+  mvprintw(LINES - 2, 0, "%s", loc_strings->f1_to_exit);
   refresh();
 
   /* Post the menu */
-  post_menu(my_menu);
-  wrefresh(my_menu_win);
+  post_menu(main_menu.menu);
+  wrefresh(main_menu.win);
 
-  while ((c = wgetch(my_menu_win)) != KEY_F(1)) {
+  int c;
+  while ((c = wgetch(main_menu.win)) != KEY_F(1)) {
     switch (c) {
     case KEY_DOWN:
-        menu_driver(my_menu, REQ_DOWN_ITEM);
+      menu_driver(main_menu.menu, REQ_DOWN_ITEM);
       break;
     case KEY_UP:
-        menu_driver(my_menu, REQ_UP_ITEM);
+      menu_driver(main_menu.menu, REQ_UP_ITEM);
       break;
     case 10:
-        mvprintw(LINES - 1, 0, "%lu",
-                 spawn_menu(15, 45, choices2, ARRAY_SIZE(choices2)));
+
       refresh();
       break;
+    case ':':
+      switch (hash_djb2a(spawncmd())) {
+      case "print"_sh:
+      case "p"_sh: {
+        // DONT FORGET TO PRINT ACTUAL DOCUMENT
+        std::array<std::string, 2> name_date =
+            get_name_date_from_item(current_item(main_menu.menu));
+        std::ifstream selected_file(COMPLAINTS_DIR "/" + name_date[0] + '_' +
+                                    name_date[1]);
+        if (!selected_file.is_open()) {
+          std::clog << selected_file.rdstate() << "\n";
+          std::cerr << RED "[ERROR] " RESET << loc_strings->invalid_input
+                    << "\n"
+                    << "File: "
+                    << COMPLAINTS_DIR "/" + name_date[0] + '_' + name_date[1]
+                    << "\n";
+          exit(EINVAL);
         }
-    wrefresh(my_menu_win);
+        try {
+          json selected_file_json = json::parse(selected_file);
+
+          printDocument(
+              selected_file_json["complaint_text"].get<std::string>());
+          current_allocated = &main_menu_allocated;
+        } catch (...) {
+          safe_exit(EINVAL);
+        }
+        break;
+      }
+      case "easy_edit"_sh:
+      case "ee"_sh: {
+        const std::string name = spawncmd(loc_strings->reference_name);
+        if (name == "") {
+          print_in_middle(main_menu.win, 10, 0, 40, loc_strings->invalid_input,
+                          COLOR_PAIR(1));
         }
 
-  /* Unpost and free all the memory taken up */
-  unpost_menu(my_menu);
-  free_menu(my_menu);
-  for (i = 0; i < n_choices; ++i)
-    free_item(my_items[i]);
-  delete[] my_items;
+        const time_t current_time = time(nullptr);
+        const tm *local_time = localtime(&current_time);
+
+        char formatted_date[11];
+        strftime(formatted_date, sizeof(formatted_date), "%d-%m-%Y",
+                 local_time);
+
+        std::ofstream complaint_file(COMPLAINTS_DIR "/" + name + "_" +
+                                     formatted_date);
+
+        const std::string complaint_text = vytvorTrestniOznameni();
+
+        json complaint_json = {{"date", formatted_date},
+                               {"status", NOT_SEND},
+                               {"complaint_text", complaint_text}};
+
+        complaint_file << complaint_json;
+        complaint_file.close();
+        current_allocated = &main_menu_allocated;
+        reload_menu_from_directory(main_menu);
+        break;
+      }
+      case "eh"_sh: {
+        std::array<std::string, 2> name_date =
+            get_name_date_from_item(current_item(main_menu.menu));
+        std::ifstream selected_file(COMPLAINTS_DIR "/" + name_date[0] + '_' +
+                                    name_date[1]);
+        if (!selected_file.is_open()) {
+          std::clog << selected_file.rdstate() << "\n";
+          std::cerr << RED "[ERROR] " RESET << loc_strings->invalid_input
+                    << "\n"
+                    << "File: "
+                    << COMPLAINTS_DIR "/" + name_date[0] + '_' + name_date[1]
+                    << "\n";
+          exit(EINVAL);
+        }
+
+        json selected_file_json = json::parse(selected_file);
+        selected_file.close();
+        std::string complaint_text =
+            selected_file_json["complaint_text"].get<std::string>();
+        editor_hard(complaint_text);
+        curs_set(0);
+        clear();
+        selected_file_json["complaint_text"] = complaint_text;
+        std::ofstream selected_file_out(COMPLAINTS_DIR "/" + name_date[0] +
+                                        '_' + name_date[1]);
+        selected_file_out << selected_file_json;
+        selected_file_out.close();
+
+        break;
+      }
+      default:
+        print_in_middle(main_menu.win, 10, 0, 40, loc_strings->unknown_command,
+                        COLOR_PAIR(1));
+        break;
+      }
+      break;
+    case 'm': {
+      int current_item_index = item_index(current_item(main_menu.menu));
+      std::array<std::string, 2> name_date =
+          get_name_date_from_item(current_item(main_menu.menu));
+
+      {
+        uint8_t n = 0;
+        size_t indexes[2] = {ULONG_MAX, ULONG_MAX}; // fix compiler warning
+        for (size_t i = 0; (i < main_menu_allocated.size()); i++) {
+          if (main_menu_allocated[i].ptr ==
+              item_name(current_item(main_menu.menu))) {
+            delete[] static_cast<char *>(main_menu_allocated[i].ptr);
+            indexes[0] = i;
+            n++;
+          } else if (main_menu_allocated[i].ptr ==
+                     item_description(current_item(main_menu.menu))) {
+            delete[] static_cast<char *>(main_menu_allocated[i].ptr);
+            indexes[1] = i;
+            n++;
+          }
+          if (n >= 2) {
+            break;
+          }
+        }
+        if (indexes[0] == ULONG_MAX || indexes[1] == ULONG_MAX) {
+          std::cerr << RED "[ERROR]" << RESET " HOW DID THIS EVEN HAPPEN\n";
+          safe_exit(84);
+        }
+        if (indexes[0] > indexes[1]) {
+          std::swap(indexes[0], indexes[1]);
+        }
+        main_menu_allocated.erase(main_menu_allocated.begin() + indexes[1]);
+        main_menu_allocated.erase(main_menu_allocated.begin() + indexes[0]);
+      }
+      {
+        std::ifstream selected_file(COMPLAINTS_DIR "/" + name_date[0] + '_' +
+                                    name_date[1]);
+        if (!selected_file.is_open()) {
+          std::clog << selected_file.rdstate() << "\n";
+          std::cerr << RED "[ERROR] " RESET << loc_strings->invalid_input
+                    << "\n"
+                    << "File: "
+                    << COMPLAINTS_DIR "/" + name_date[0] + '_' + name_date[1]
+                    << "\n";
+          exit(EINVAL);
+        }
+        json selected_file_json = json::parse(selected_file);
+        selected_file.close();
+        if (selected_file_json["status"].is_null() ||
+            selected_file_json["status"].get<size_t>() < STATUS_COUNT) {
+
+          (selected_file_json["status"].get<uint8_t>() + 1 >= STATUS_COUNT)
+              ? selected_file_json["status"] = NOT_SEND
+              : selected_file_json["status"] =
+                    selected_file_json["status"].get<uint8_t>() + 1;
+
+          std::ofstream selected_file(COMPLAINTS_DIR "/" + name_date[0] + '_' +
+                                      name_date[1]);
+          selected_file << selected_file_json;
+          selected_file.close();
+        } else {
+          std::cerr << RED "[ERROR] " RESET << loc_strings->invalid_input
+                    << "\n";
+          exit(EINVAL);
+        }
+
+        name_date[1].append(" ");
+        name_date[1].append(
+            loc_strings
+                ->status_strings[selected_file_json["status"].get<uint8_t>()]);
+        char *date_status = new char[name_date[1].length() + 1];
+        main_menu_allocated.push_back({GENERIC_TYPE, date_status, 1});
+        strlcpy(date_status, name_date[1].c_str(), name_date[1].length() + 1);
+
+        char *name = new char[name_date[0].length() + 1];
+        main_menu_allocated.push_back({GENERIC_TYPE, name, 1});
+        strlcpy(name, name_date[0].c_str(), name_date[0].length() + 1);
+
+        for (size_t i = 0; i < main_menu.items_size; i++) {
+          if (main_menu.items[i] == current_item(main_menu.menu)) {
+            free_item(main_menu.items[i]);
+            main_menu.items[i] = new_item(name, date_status);
+            break;
+          }
+        }
+      }
+      WINDOW *old_win_sub = menu_sub(main_menu.menu);
+      unpost_menu(main_menu.menu);
+      free_menu(main_menu.menu);
+      main_menu.menu = new_menu(main_menu.items);
+      set_menu_win(main_menu.menu, main_menu.win);
+      set_menu_sub(main_menu.menu, old_win_sub);
+      set_menu_format(main_menu.menu, 7, 1);
+      set_menu_mark(main_menu.menu, " * ");
+      set_current_item(main_menu.menu, main_menu.items[current_item_index]);
+      post_menu(main_menu.menu);
+      break;
+    }
+    }
+    wrefresh(main_menu.win);
+    refresh();
+    redrawwin(main_menu.win);
+    wrefresh(main_menu.win);
+  }
+
+  unpost_menu(main_menu.menu);
+  delete_all(&main_menu_allocated);
   endwin();
 }

src/signal.cpp

@@ -0,0 +1,33 @@
+#include "memory.h"
+#include <csignal>
+#include <curses.h>
+#include <iostream>
+void safe_exit(int code) {
+  switch (code) {
+  case SIGTERM:
+    std::cerr << "\nreceived SIGTERM exiting...\n";
+    break;
+  case SIGINT:
+    std::cerr << "\nreceived SIGINT exiting...\n";
+    break;
+  case SIGQUIT:
+    std::cerr << "\nreceived SIGQUIT exiting...\n";
+    break;
+  case SIGHUP:
+    std::cerr << "\nreceived SIGHUP exiting...\n";
+    break;
+
+  case SIGSEGV:
+    std::cerr << "\nreceived SIGSEGV(segmentation fault) exiting...\nIf this "
+                 "repeats please report it as a bug\n";
+    break;
+
+  default:
+    break;
+  }
+  delete_all(current_allocated);
+  echo();
+  endwin();
+
+  exit(code);
+}

src/signal.h

@@ -0,0 +1,7 @@
+
+#ifndef PARADOCS_SIGNAL_H_
+#define PARADOCS_SIGNAL_H_
+
+void safe_exit(int code);
+
+#endif

src/strings.cpp

@@ -0,0 +1,161 @@
+#include "strings.h"
+
+constexpr strings english_strings{
+    .invalid_option = "Invalid option:",
+    .try_str = "try",
+    .usage = "Usage",
+    .options = "OPTIONS",
+    .print_this_help = "Print this help",
+    .print_version = "Print version",
+    .version = "version",
+    .main_menu = "List of complaints",
+    .f1_to_exit = "F1 to exit",
+    .unknown_command = "Unknown command:",
+    .min_terminal_size = "Minimum terminal size: 90x28",
+    .name_of_submiter = "Name of submiter:",
+    .address_of_submiter = "Address of submiter:",
+    .phone_of_submiter = "Phone of submiter:",
+    .email_of_submiter = "Email of submiter:",
+    .name_of_recipient = "Name of recipient:",
+    .address_of_recipient = "Address of recipient:",
+    .phone_of_recipient = "Phone of recipient:",
+    .email_of_recipient = "Email of recipient:",
+    .place_of_incident = "Place of incident:",
+    .date_of_incident = "Date of incident (dd.mm.rrrr):",
+    .description_of_incident = "Description of incident:",
+    .evidence_of_incident = "Evidence of incident:",
+    .additional_info = "Additional info:",
+    .cease_and_desist_entry_of_information =
+        "CEASE AND DESIST - ENTRY OF INFORMATION",
+    .enter_all_information_and_press_f10 =
+        "Enter all information and press F10 to finish",
+    .criminal_complaint_template = R"(
+CRIMINAL COMPLAINT
+
+To:
+Police of the Czech Republic
+
+Complainant:
+Name and Surname: {0}
+Address: {1}
+Phone: {2}
+E-mail: {3}
+
+Accused:
+Name and Surname: {4}
+Address: {5}
+Phone: {6}
+E-mail: {7}
+
+Subject:
+suspicion of committing a criminal offence
+
+Date of submission of the complaint: {8}
+
+On {9} at {10}.
+
+    Factual circumstances:
+    {11}
+
+    Evidence:
+    {12}
+
+    Additional information:
+    {13}
+
+I request the Police of the Czech Republic to:
+
+    take all measures to clarify and investigate the matter,
+
+    interview witnesses and secure evidentiary materials,
+
+    submit a proposal to the public prosecutor.
+
+Signature of the complainant: {0}
+
+*This is not a legal document, but only a template for informational purposes. For legal advice, please consult a qualified attorney.*
+)",
+    .command = "Command",
+    .invalid_input = "Invalid input",
+    .reference_name = "Reference Name",
+    .status_strings = {"Not sent", "Sent", "Rejected", "Accepted"}};
+
+constexpr strings czech_strings{
+    .invalid_option = "Neplatná volba: ",
+    .try_str = "zkus",
+    .usage = "Použití",
+    .options = "MOŽNOSTI",
+    .print_this_help = "Zobrazit tuto nápovědu",
+    .print_version = "Zobrazit verzi",
+    .version = "verze",
+    .main_menu = "Seznam Oznámení",
+    .f1_to_exit = "F1 pro ukončení",
+    .unknown_command = "Neznámý příkaz: ",
+    .min_terminal_size = "Minimální velikost terminálu: 90x28",
+    .name_of_submiter = "Jméno podavatele: ",
+    .address_of_submiter = "Adresa podavatele: ",
+    .phone_of_submiter = "Telefon podavatele: ",
+    .email_of_submiter = "Email podavatele: ",
+    .name_of_recipient = "Jméno adresáta: ",
+    .address_of_recipient = "Adresa adresáta: ",
+    .phone_of_recipient = "Telefon adresáta: ",
+    .email_of_recipient = "Email adresáta: ",
+    .place_of_incident = "Místo činu: ",
+    .date_of_incident = "Datum činu (dd.mm.rrrr):",
+    .description_of_incident = "Popis činu:",
+    .evidence_of_incident = "Důkazy:",
+    .additional_info = "Další informace:",
+    .cease_and_desist_entry_of_information = "TRESTNÍ OZNÁMENÍ - ZADÁNÍ ÚDAJŮ",
+    .enter_all_information_and_press_f10 =
+        "Zadejte všechny údaje a stiskněte F10 pro dokončení",
+    .criminal_complaint_template = R"(
+TRESTNÍ OZNÁMENÍ
+
+Komu:
+  Policie ČR
+
+Oznamovatel:
+  Jméno a příjmení: {0}
+  Adresa:           {1}
+  Telefon:          {2}
+  E-mail:           {3}
+
+Obviněný:
+  Jméno a příjmení: {4}
+  Adresa:           {5}
+  Telefon:          {6}
+  E-mail:           {7}
+
+Věc:
+  podezření ze spáchání trestného činu
+
+Datum podání oznámení: {8}
+
+Dne {9} v místě {10}.
+
+  1. Skutkové okolnosti:
+    {11}
+
+  2. Důkazy:
+    {12}
+
+3. Další informace:
+{13}
+
+Žádám Policii ČR:
+  - přijmout veškerá opatření k objasnění a prošetření věci,
+  - vyslechnout svědky a zajistit důkazní materiály,
+  - podat podnět státnímu zástupci.
+
+
+
+Podpis oznamovatele: {0}
+
+*Toto není právní dokument, ale pouze vzor pro informativní účely. Pro právní poradenství se obraťte na kvalifikovaného právníka.*
+)",
+    .command = "Příkaz",
+    .invalid_input = "Neplatný vstup",
+    .reference_name = "Referenční Název",
+    .status_strings = {"Nebylo odesláno", "Odesláno", "Zamítnuto", "Přijato"}};
+
+const strings *loc_strings;

src/strings.h

@@ -0,0 +1,47 @@
+
+#ifndef PARADOCS_STRINGS_H_
+#define PARADOCS_STRINGS_H_
+#include "const.h"
+typedef struct {
+  const char* invalid_option;
+  const char* try_str;
+  const char* usage;
+  const char* options;
+  const char* print_this_help;
+  const char* print_version;
+  const char* version;
+  const char* main_menu;
+  const char* f1_to_exit;
+  const char* unknown_command;
+
+  const char* min_terminal_size;
+  const char* name_of_submiter;
+  const char* address_of_submiter;
+  const char* phone_of_submiter;
+  const char* email_of_submiter;
+
+  const char* name_of_recipient;
+  const char* address_of_recipient;
+  const char* phone_of_recipient;
+  const char* email_of_recipient;
+
+  const char* place_of_incident;
+  const char* date_of_incident;
+  const char* description_of_incident;
+  const char* evidence_of_incident;
+  const char* additional_info;
+
+  const char* cease_and_desist_entry_of_information;
+  const char* enter_all_information_and_press_f10;
+
+  const char* criminal_complaint_template;
+  const char* command;
+  const char* invalid_input;
+  const char* reference_name;
+  const char* status_strings[STATUS_COUNT];
+} strings;
+
+extern const strings english_strings;
+extern const strings czech_strings;
+extern const strings* loc_strings;
+#endif

src/types.h

@@ -0,0 +1,14 @@
+#include <menu.h>
+#include <ncurses.h>
+
+#ifndef PARADOCS_TYPES_H_
+#define PARADOCS_TYPES_H_
+
+struct complete_menu {
+  WINDOW* win;
+  ITEM** items;
+  size_t items_size;
+  MENU* menu;
+};
+
+#endif