flashcore-cli.c

/*
 * flashcore-cli.c — CLI Flashcard App
 * Compile: gcc -o flashcore-cli flashcore-cli.c
 * Usage:   ./flashcore-cli
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <time.h>
#include <unistd.h>
#include <termios.h>
#include <dirent.h>
#include <sys/stat.h>

/* ─── Configurações ──────────────────────────────────────────────── */
#define MAX_WORDS   512
#define MAX_LEN     128
#define SHOW_SECS   5
#define MAX_LISTAS  128

/* Pasta onde ficam as listas (arquivos .txt), uma por assunto:
 * ex: "palavras em italiano.txt", "frases em inglês.txt" ...   */
static char FLASHCARDS_DIR[512];

/* Arquivo da lista atualmente carregada/selecionada */
static char DATA_FILE[768];

static void garantir_pasta(const char *path) {
    struct stat st;
    if (stat(path, &st) == -1) mkdir(path, 0755);
}

static void init_paths(void) {
    const char *home = getenv("HOME");
    if (!home) home = "/tmp";

    char base[480];
    snprintf(base, sizeof base, "%s/flashcore", home);
    garantir_pasta(base);

    snprintf(FLASHCARDS_DIR, sizeof FLASHCARDS_DIR, "%s/flashcards", base);
    garantir_pasta(FLASHCARDS_DIR);
}

/* ─── Estruturas ─────────────────────────────────────────────────── */
typedef struct {
    char original[MAX_LEN];
    char traducao[MAX_LEN];
} Palavra;

/* ─── Globais ────────────────────────────────────────────────────── */
Palavra lista[MAX_WORDS];
int total = 0;

/* Listas (arquivos .txt) detectadas dentro de FLASHCARDS_DIR */
static char arquivos_listas[MAX_LISTAS][MAX_LEN]; /* nome do arquivo, ex: "italiano.txt"   */
static char nomes_listas[MAX_LISTAS][MAX_LEN];    /* nome de exibição, ex: "italiano"      */
static int total_listas = 0;

/* ═══════════════════════════════════════════════════════════════════
   Cores
   ═══════════════════════════════════════════════════════════════════ */
#define RESET    "\033[0m"
#define NEGRITO  "\033[1m"
#define VERDE    "\033[32m"
#define AMARELO  "\033[33m"
#define CIANO    "\033[36m"
#define VERMELHO "\033[31m"
#define CINZA    "\033[90m"
#define BG_AMARELO "\033[43m"
#define BRANCO   "\033[97m"

void cor(const char *c) { printf("%s", c); fflush(stdout); }

/* ═══════════════════════════════════════════════════════════════════
   Terminal raw mode
   ═══════════════════════════════════════════════════════════════════ */
static struct termios _orig;
static int _raw = 0;

static void term_raw(void) {
    if (_raw) return;
    tcgetattr(STDIN_FILENO, &_orig);
    struct termios t = _orig;
    t.c_lflag &= ~(ECHO | ICANON);
    t.c_cc[VMIN] = 1; t.c_cc[VTIME] = 0;
    tcsetattr(STDIN_FILENO, TCSAFLUSH, &t);
    _raw = 1;
}

static void term_restore(void) {
    if (!_raw) return;
    tcsetattr(STDIN_FILENO, TCSAFLUSH, &_orig);
    _raw = 0;
}

#define KEY_UP        1000
#define KEY_DOWN      1001
#define KEY_ENTER     1002
#define KEY_ESC       1003
#define KEY_LEFT      1004
#define KEY_RIGHT     1005
#define KEY_BACKSPACE 1006

static int ler_tecla(void) {
    term_raw();
    unsigned char c;
    if (read(STDIN_FILENO, &c, 1) != 1) return KEY_ESC;
    if (c == 27) {
        unsigned char seq[2] = {0, 0};
        if (read(STDIN_FILENO, &seq[0], 1) != 1) return KEY_ESC;
        if (read(STDIN_FILENO, &seq[1], 1) != 1) return KEY_ESC;
        if (seq[0] == '[') {
            if (seq[1] == 'A') return KEY_UP;
            if (seq[1] == 'B') return KEY_DOWN;
            if (seq[1] == 'C') return KEY_RIGHT;
            if (seq[1] == 'D') return KEY_LEFT;
        }
        return KEY_ESC;
    }
    if (c == '\r' || c == '\n') return KEY_ENTER;
    if (c == 127 || c == 8) return KEY_BACKSPACE;
    return (int)(unsigned char)c;
}

/* ═══════════════════════════════════════════════════════════════════
   Utilitários de terminal
   ═══════════════════════════════════════════════════════════════════ */

void limpar_tela(void) {
    printf("\033[2J\033[H");
    fflush(stdout);
}

/* Aguarda ENTER sem ecoar no terminal */
void aguardar_enter(void) {
    term_restore();
    struct termios old, novo;
    tcgetattr(STDIN_FILENO, &old);
    novo = old;
    novo.c_lflag &= ~(ICANON | ECHO);
    tcsetattr(STDIN_FILENO, TCSANOW, &novo);
    int c;
    while ((c = getchar()) != '\n' && c != '\r' && c != EOF);
    tcsetattr(STDIN_FILENO, TCSANOW, &old);
}

/* Barra de progresso de N segundos */
void barra_regressiva(int segundos) {
    int largura = 30;
    for (int s = segundos; s >= 0; s--) {
        int cheio = ((segundos - s) * largura) / segundos;

        printf("\r  ");
        cor(CIANO);
        printf("[");
        for (int i = 0; i < largura; i++)
            printf(i < cheio ? "█" : "░");
        printf("] %2ds ", s);
        cor(RESET);
        fflush(stdout);
        if (s > 0) sleep(1);
    }
    printf("\n");
}

/* ═══════════════════════════════════════════════════════════════════
   Detecção das listas (.txt) dentro de FLASHCARDS_DIR
   ═══════════════════════════════════════════════════════════════════ */

static int tem_extensao_txt(const char *nome) {
    size_t n = strlen(nome);
    return n > 4 && strcasecmp(nome + n - 4, ".txt") == 0;
}

static int cmp_linhas(const void *a, const void *b) {
    return strcasecmp((const char *)a, (const char *)b);
}

/* Escaneia FLASHCARDS_DIR em busca de arquivos .txt e preenche
 * arquivos_listas[]/nomes_listas[]. Retorna a quantidade encontrada. */
int carregar_lista_arquivos(void) {
    DIR *d = opendir(FLASHCARDS_DIR);
    total_listas = 0;
    if (!d) return 0;

    struct dirent *ent;
    while (total_listas < MAX_LISTAS && (ent = readdir(d)) != NULL) {
        if (ent->d_name[0] == '.') continue;
        if (!tem_extensao_txt(ent->d_name)) continue;
        strncpy(arquivos_listas[total_listas], ent->d_name, MAX_LEN - 1);
        arquivos_listas[total_listas][MAX_LEN - 1] = '\0';
        total_listas++;
    }
    closedir(d);

    qsort(arquivos_listas, total_listas, MAX_LEN, cmp_linhas);

    for (int i = 0; i < total_listas; i++) {
        strncpy(nomes_listas[i], arquivos_listas[i], MAX_LEN - 1);
        nomes_listas[i][MAX_LEN - 1] = '\0';
        char *ext = strstr(nomes_listas[i], ".txt");
        if (ext) *ext = '\0';
    }
    return total_listas;
}

/* Menu de seleção de lista (usado tanto por "Iniciar" quanto por
 * "Configurar"). Retorna o índice escolhido (preenchendo caminho_out
 * com o caminho completo do arquivo) ou -1 se o usuário cancelar
 * (BACKSPACE) ou não houver nenhuma lista cadastrada. */
int selecionar_arquivo(const char *titulo, char *caminho_out, size_t out_size) {
    int n = carregar_lista_arquivos();

    if (n == 0) {
        limpar_tela();
        cor(NEGRITO); cor(VERMELHO);
        printf("  ╔══════════════════════════════════════╗\n");
        printf("  ║ %-38s ║\n", titulo);
        printf("  ╚══════════════════════════════════════╝\n\n");
        cor(RESET);
        cor(AMARELO);
        printf("  Nenhuma lista encontrada em:\n  %s\n\n", FLASHCARDS_DIR);
        cor(RESET);
        printf("  Crie um arquivo .txt manualmente nessa pasta\n");
        printf("  para cada lista que quiser estudar, por exemplo:\n\n");
        cor(CINZA);
        printf("    palavras em italiano.txt\n");
        printf("    frases em inglês.txt\n");
        printf("    palavras em inglês.txt\n");
        cor(RESET);
        printf("\n  Pressione ENTER para voltar...\n");
        aguardar_enter();
        return -1;
    }

    int sel = 0;
    while (1) {
        limpar_tela();
        cor(NEGRITO); cor(VERMELHO);
        printf("  ╔══════════════════════════════════════╗\n");
        printf("  ║ %-38s ║\n", titulo);
        printf("  ╚══════════════════════════════════════╝\n");
        cor(RESET);

        cor(CINZA);
        printf("  Pasta: %s\n\n", FLASHCARDS_DIR);
        cor(RESET);

        printf("  Use " AMARELO "↑↓" RESET " para navegar, " AMARELO "ENTER" RESET
               " para selecionar, " AMARELO "BACKSPACE" RESET " para voltar\n\n");

        for (int i = 0; i < n; i++) {
            if (i == sel) {
                printf(BG_AMARELO BRANCO "  ➤  %-34s" RESET "\n", nomes_listas[i]);
            } else {
                cor(VERMELHO);
                printf("     %-34s\n", nomes_listas[i]);
                cor(RESET);
            }
        }
        printf("\n");
        fflush(stdout);

        int k = ler_tecla();

        if (k == KEY_UP) { if (sel > 0) sel--; }
        else if (k == KEY_DOWN) { if (sel < n - 1) sel++; }
        else if (k == KEY_BACKSPACE || k == KEY_ESC) {
            term_restore();
            return -1;
        } else if (k == KEY_ENTER) {
            term_restore();
            snprintf(caminho_out, out_size, "%s/%s", FLASHCARDS_DIR, arquivos_listas[sel]);
            return sel;
        }
    }
}

/* ═══════════════════════════════════════════════════════════════════
   Persistência
   ═══════════════════════════════════════════════════════════════════ */

void carregar_arquivo(void) {
    FILE *f = fopen(DATA_FILE, "r");
    total = 0;
    if (!f) return;
    while (total < MAX_WORDS &&
           fscanf(f, " %127[^|]|%127[^\n]\n",
                  lista[total].original,
                  lista[total].traducao) == 2)
        total++;
    fclose(f);
}

void salvar_arquivo(void) {
    FILE *f = fopen(DATA_FILE, "w");
    if (!f) { perror("Erro ao salvar"); return; }
    for (int i = 0; i < total; i++)
        fprintf(f, "%s|%s\n", lista[i].original, lista[i].traducao);
    fclose(f);
}

/* ═══════════════════════════════════════════════════════════════════
   Gerenciamento de palavras
   ═══════════════════════════════════════════════════════════════════ */

void trim(char *s) {
    int n = (int)strlen(s);
    while (n > 0 && (s[n-1] == '\n' || s[n-1] == '\r' || s[n-1] == ' '))
        s[--n] = '\0';
}

void adicionar_palavra(void) {
    term_restore();
    if (total >= MAX_WORDS) {
        cor(VERMELHO); printf("  Lista cheia (%d palavras).\n", MAX_WORDS); cor(RESET);
        return;
    }
    char orig[MAX_LEN], trad[MAX_LEN];

    printf("\n");
    cor(VERMELHO); printf("  Palavra/frase original : "); cor(RESET);
    fgets(orig, sizeof orig, stdin); trim(orig);
    if (orig[0] == '\0') { printf("  (cancelado)\n"); return; }

    cor(VERMELHO); printf("  Tradução               : "); cor(RESET);
    fgets(trad, sizeof trad, stdin); trim(trad);
    if (trad[0] == '\0') { printf("  (cancelado)\n"); return; }

    for (int i = 0; i < total; i++) {
        if (strcasecmp(lista[i].original, orig) == 0) {
            cor(AMARELO);
            printf("  \"%s\" já existe (tradução: %s).\n", orig, lista[i].traducao);
            cor(RESET);
            return;
        }
    }

    strcpy(lista[total].original, orig);
    strcpy(lista[total].traducao, trad);
    total++;
    salvar_arquivo();
    cor(VERDE); printf("\n  ✓ Adicionado: %s → %s\n", orig, trad); cor(RESET);
}

void listar_palavras(void) {
    printf("\n");
    if (total == 0) {
        cor(CINZA); printf("  (nenhuma palavra cadastrada)\n"); cor(RESET);
        return;
    }
    cor(NEGRITO); cor(VERMELHO);
    printf("  %-4s  %-30s  %s\n", "#", "Original", "Tradução");
    printf("  %-4s  %-30s  %s\n", "──", "──────────────────────────────", "──────────────────────────────");
    cor(RESET);
    for (int i = 0; i < total; i++) {
        cor(VERMELHO);
        printf("  %-4d  ", i + 1);
        cor(RESET);
        printf("%-30s  %s\n", lista[i].original, lista[i].traducao);
    }
    printf("\n");
}

void remover_palavra(void) {
    term_restore();
    listar_palavras();
    if (total == 0) return;

    cor(VERMELHO); printf("  Número para remover (0 = cancelar): "); cor(RESET);
    char buf[16];
    fgets(buf, sizeof buf, stdin);
    int n = atoi(buf);
    if (n <= 0 || n > total) { printf("  Cancelado.\n"); return; }

    cor(AMARELO);
    printf("  Removendo \"%s\" → \"%s\"...\n",
           lista[n-1].original, lista[n-1].traducao);
    cor(RESET);

    for (int i = n - 1; i < total - 1; i++)
        lista[i] = lista[i + 1];
    total--;
    salvar_arquivo();
    cor(VERDE); printf("  ✓ Removido.\n"); cor(RESET);
}

/* ═══════════════════════════════════════════════════════════════════
   Modo Flashcard
   ═══════════════════════════════════════════════════════════════════ */

void mascarar(const char *s) {
    int n = (int)strlen(s);
    for (int i = 0; i < n; i++) putchar(s[i] == ' ' ? ' ' : '*');
}

void embaralhar(int *idx, int n) {
    for (int i = n - 1; i > 0; i--) {
        int j = rand() % (i + 1);
        int tmp = idx[i]; idx[i] = idx[j]; idx[j] = tmp;
    }
}

void modo_flashcard(void) {
    term_restore();
    if (total == 0) {
        cor(VERMELHO);
        printf("\n  Nenhuma palavra cadastrada nessa lista. Adicione algumas primeiro.\n\n");
        cor(RESET);
        printf("  Pressione ENTER para continuar...\n");
        aguardar_enter();
        return;
    }

    int idx[MAX_WORDS];
    for (int i = 0; i < total; i++) idx[i] = i;
    embaralhar(idx, total);

    limpar_tela();
    cor(NEGRITO); cor(VERMELHO);
    printf("  ╔══════════════════════════════════════╗\n");
    printf("  ║            MODO  FLASHCARD           ║\n");
    printf("  ╚══════════════════════════════════════╝\n\n");
    cor(RESET);
    printf("  %d palavra(s) na sessão. Pressione BACKSPACE para sair.\n\n", total);
    sleep(1);

    int acertos = 0, erros = 0;

    for (int round = 0; round < total; round++) {
        Palavra *p = &lista[idx[round]];

        limpar_tela();
        cor(CINZA);
        printf("  Carta %d/%d   ✓ %d  ✗ %d\n\n", round + 1, total, acertos, erros);
        cor(RESET);

        cor(NEGRITO); cor(AMARELO);
        printf("  ┌─────────────────────────────────────┐\n");
        printf("  │  %-35s  │\n", p->original);
        printf("  └─────────────────────────────────────┘\n");
        cor(RESET);
        printf("\n");

        barra_regressiva(SHOW_SECS);

        limpar_tela();
        cor(CINZA);
        printf("  Carta %d/%d   ✓ %d  ✗ %d\n\n", round + 1, total, acertos, erros);
        cor(RESET);

        cor(NEGRITO); cor(CINZA);
        printf("  ┌─────────────────────────────────────┐\n");
        printf("  │  ");
        mascarar(p->original);
        int pad = 35 - (int)strlen(p->original);
        for (int i = 0; i < pad; i++) putchar(' ');
        printf("  │\n");
        printf("  └─────────────────────────────────────┘\n");
        cor(RESET);

        printf("\n");
        cor(CINZA); printf("  Lembra? Pressione "); cor(RESET);
        cor(NEGRITO); printf("ENTER"); cor(RESET);
        cor(CINZA); printf(" para revelar a tradução...\n"); cor(RESET);
        aguardar_enter();

        limpar_tela();
        cor(CINZA);
        printf("  Carta %d/%d   ✓ %d  ✗ %d\n\n", round + 1, total, acertos, erros);
        cor(RESET);

        cor(NEGRITO); cor(AMARELO);
        printf("  ┌─────────────────────────────────────┐\n");
        printf("  │  %-35s  │\n", p->original);
        printf("  └─────────────────────────────────────┘\n");
        cor(RESET);

        printf("              ↓\n");

        cor(NEGRITO); cor(VERDE);
        printf("  ┌─────────────────────────────────────┐\n");
        printf("  │  %-35s  │\n", p->traducao);
        printf("  └─────────────────────────────────────┘\n");
        cor(RESET);

        printf("\n");
        cor(CINZA); printf("  Você acertou?  "); cor(RESET);
        cor(VERDE); printf("[←]"); cor(RESET);
        printf(" Sim    ");
        cor(VERMELHO); printf("[→]"); cor(RESET);
        printf(" Não    ");
        cor(CINZA); printf("[BACKSPACE]"); cor(RESET);
        printf(" Sair\n");
        fflush(stdout);

        int k;
        do {
            k = ler_tecla();
        } while (k != KEY_LEFT && k != KEY_RIGHT && k != KEY_BACKSPACE);

        if (k == KEY_BACKSPACE) { term_restore(); break; }
        if (k == KEY_LEFT) acertos++;
        else erros++;
    }

    term_restore();
    limpar_tela();
    cor(NEGRITO); cor(VERMELHO);
    printf("  ╔══════════════════════════════════════╗\n");
    printf("  ║            RESULTADO FINAL            ║\n");
    printf("  ╚══════════════════════════════════════╝\n\n");
    cor(RESET);

    printf("  Total de cartas : %d\n", acertos + erros);
    cor(VERDE);  printf("  Acertos         : %d\n", acertos); cor(RESET);
    cor(VERMELHO); printf("  Erros           : %d\n", erros);   cor(RESET);

    if (acertos + erros > 0) {
        int pct = acertos * 100 / (acertos + erros);
        printf("\n  Aproveitamento  : ");
        if (pct >= 80) cor(VERDE);
        else if (pct >= 50) cor(AMARELO);
        else cor(VERMELHO);
        printf("%d%%\n", pct);
        cor(RESET);
    }
    printf("\n  Pressione ENTER para voltar ao menu...\n");
    aguardar_enter();
}

/* ═══════════════════════════════════════════════════════════════════
   Submenu: Configurar flashcards (opera sobre a lista selecionada)
   ═══════════════════════════════════════════════════════════════════ */

static const char *OPCOES_CONFIG[] = {
    "Adicionar card",
    "Listar cards",
    "Remover card",
    "Voltar"
};
#define N_OPCOES_CONFIG 4

void menu_configurar_lista(const char *nome_display) {
    int sel = 0;

    while (1) {
        limpar_tela();
        cor(NEGRITO); cor(VERMELHO);
        printf("  ╔══════════════════════════════════════╗\n");
        printf("  ║ CONFIGURAR: %-25.25s ║\n", nome_display);
        printf("  ╚══════════════════════════════════════╝\n");
        cor(RESET);

        cor(CINZA);
        printf("  Cards nessa lista: %d\n\n", total);
        cor(RESET);

        printf("  Use " AMARELO "↑↓" RESET " para navegar, " AMARELO "ENTER" RESET
               " para selecionar, " AMARELO "BACKSPACE" RESET " para voltar\n\n");

        for (int i = 0; i < N_OPCOES_CONFIG; i++) {
            if (i == sel) {
                printf(BG_AMARELO BRANCO "  ➤  %-34s" RESET "\n", OPCOES_CONFIG[i]);
            } else {
                cor(VERMELHO);
                printf("     %-34s\n", OPCOES_CONFIG[i]);
                cor(RESET);
            }
        }
        printf("\n");
        fflush(stdout);

        int k = ler_tecla();

        if (k == KEY_UP) { if (sel > 0) sel--; }
        else if (k == KEY_DOWN) { if (sel < N_OPCOES_CONFIG - 1) sel++; }
        else if (k == KEY_BACKSPACE || k == KEY_ESC) {
            term_restore();
            return;
        } else if (k == KEY_ENTER) {
            term_restore();
            switch (sel) {
                case 0:
                    limpar_tela();
                    cor(NEGRITO); cor(VERMELHO);
                    printf("  ╔══════════════════════════════════════╗\n");
                    printf("  ║             ADICIONAR CARD           ║\n");
                    printf("  ╚══════════════════════════════════════╝\n\n");
                    cor(RESET);
                    adicionar_palavra();
                    printf("\n  Pressione ENTER para continuar...\n");
                    aguardar_enter();
                    break;
                case 1:
                    limpar_tela();
                    cor(NEGRITO); cor(VERMELHO);
                    printf("  ╔══════════════════════════════════════╗\n");
                    printf("  ║             LISTA DE CARDS           ║\n");
                    printf("  ╚══════════════════════════════════════╝\n");
                    cor(RESET);
                    listar_palavras();
                    printf("  Pressione ENTER para continuar...\n");
                    aguardar_enter();
                    break;
                case 2:
                    limpar_tela();
                    cor(NEGRITO); cor(VERMELHO);
                    printf("  ╔══════════════════════════════════════╗\n");
                    printf("  ║              REMOVER CARD            ║\n");
                    printf("  ╚══════════════════════════════════════╝\n\n");
                    cor(RESET);
                    remover_palavra();
                    printf("\n  Pressione ENTER para continuar...\n");
                    aguardar_enter();
                    break;
                case 3:
                    return;
            }
        }
    }
}

/* ═══════════════════════════════════════════════════════════════════
   Menu principal — navegação por setas
   ═══════════════════════════════════════════════════════════════════ */

static const char *OPCOES[] = {
    "Iniciar flashcards",
    "Configurar flashcards",
    "Sair do flashcore"
};
#define N_OPCOES 3

static void desenhar_menu(int sel, int n_listas) {
    limpar_tela();

    cor(NEGRITO); cor(VERMELHO);
    printf("  ╔══════════════════════════════════════╗\n");
    printf("  ║            FLASHCORE  CLI            ║\n");
    printf("  ╚══════════════════════════════════════╝\n");
    cor(RESET);

    cor(CINZA);
    printf("  Pasta:  %s\n", FLASHCARDS_DIR);
    printf("  Listas: %d\n\n", n_listas);
    cor(RESET);

    printf("  Use " AMARELO "↑↓" RESET " para navegar, " AMARELO "ENTER" RESET " para selecionar\n\n");

    for (int i = 0; i < N_OPCOES; i++) {
        if (i == sel) {
            /* linha destacada: fundo amarelo + texto branco + seta */
            printf(BG_AMARELO BRANCO "  ➤  %-34s" RESET "\n", OPCOES[i]);
        } else {
            cor(VERMELHO);
            printf("     %-34s\n", OPCOES[i]);
            cor(RESET);
        }
    }
    printf("\n");
    fflush(stdout);
}

void menu(void) {
    int sel = 0;

    while (1) {
        int n_listas = carregar_lista_arquivos();
        desenhar_menu(sel, n_listas);

        int k = ler_tecla();

        if (k == KEY_UP)   { if (sel > 0)          sel--; }
        else if (k == KEY_DOWN) { if (sel < N_OPCOES - 1) sel++; }
        else if (k == KEY_ENTER) {
            term_restore();
            switch (sel) {
                case 0: {
                    char caminho[768];
                    int idx = selecionar_arquivo("INICIAR FLASHCARDS", caminho, sizeof caminho);
                    if (idx >= 0) {
                        strncpy(DATA_FILE, caminho, sizeof DATA_FILE - 1);
                        DATA_FILE[sizeof DATA_FILE - 1] = '\0';
                        carregar_arquivo();
                        modo_flashcard();
                    }
                    break;
                }
                case 1: {
                    char caminho[768];
                    int idx = selecionar_arquivo("CONFIGURAR FLASHCARDS", caminho, sizeof caminho);
                    if (idx >= 0) {
                        strncpy(DATA_FILE, caminho, sizeof DATA_FILE - 1);
                        DATA_FILE[sizeof DATA_FILE - 1] = '\0';
                        carregar_arquivo();
                        menu_configurar_lista(nomes_listas[idx]);
                    }
                    break;
                }
                case 2:
                    term_restore();
                    limpar_tela();
                    cor(VERMELHO); printf("  Bye bye! \n\n"); cor(RESET);
                    return;
            }
        }
    }
}

/* ═══════════════════════════════════════════════════════════════════
   main
   ═══════════════════════════════════════════════════════════════════ */

int main(void) {
    init_paths();
    srand((unsigned)time(NULL));
    menu();
    term_restore();
    return 0;
}