#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <windows.h>

typedef enum {
    ADMIN,
    USER
} UserType;

typedef enum {
    DEPOSIT,
    WITHDRAW,
    TRANSFER
} OperationType;

typedef enum {
    INITIATED,
    PROCESSING,
    CANCELED,
    BLOCKED,
    SUCCESFUL
} OperationResult;

//Structura pentru un cont bancar
typedef struct Cont {
    char IBAN[25];
    double sold;
    char CNP_proprietar[14];
    char valuta[4];
    struct Cont* next;
    struct Extrase* extraseLista;
} Cont;

//Structura pentru utilizator
typedef struct User {
    char username[50];
    char password[50];
    char CNP[14];
    char nume[50];
    char prenume[50];
    UserType type;
    struct User* next;
    Cont* headAccount;
    Cont* tailAccount;
} User;

//Structura pentru un extras de cont;
typedef struct Extrase {
    OperationType type;
    OperationResult result;
    char reason[100];
    struct Extrase* next;
} Extrase;

User *usersList = NULL;
User *currentUser = NULL;
Cont *accountsList = NULL;
Cont* currentAccount = NULL;
Extrase *listaExtrase = NULL;
int delogat;
const char* USERS_FILE = "users.txt";
const char* ACCOUNTS_FILE = "accounts.txt";


const char* operationToStrng(OperationType operation) {
    switch (operation)
    {
    case DEPOSIT: return "DEPOSIT"; break;
    case WITHDRAW: return "WITHDRAW"; break;
    case TRANSFER: return "TRANSFER"; break;
    default: return "nedefinit";
        break;
    }
}

enum OperationType typeToEnum(const char* type) {
    if (strcmp("DEPOSIT", type) == 0) return DEPOSIT;
    if (strcmp("WITHDRAW", type) == 0) return WITHDRAW;
    if (strcmp("TRANSFER", type) == 0) return TRANSFER;
}

enum OperationResult resultToEnum(const char* result) {
    if (strcmp("INITIATED", result) == 0) return INITIATED;
    if (strcmp("PROCESSING", result) == 0) return PROCESSING;
    if (strcmp("CANCELED", result) == 0) return CANCELED;
    if (strcmp("BLOCKED", result) == 0) return BLOCKED;
    if (strcmp("SUCCESFUL", result) == 0) return SUCCESFUL;
}



const char* resultToString(OperationResult result) {
    switch (result)
    {
    case INITIATED: return "INITIATED"; break;
    case PROCESSING: return "PROCESSING"; break;
    case CANCELED: return "CANCELED"; break;
    case BLOCKED: return "BLOCKED"; break;
    case SUCCESFUL: return "SUCCESFUL"; break;
    default: return "nedefinit";
        break;
    }
}

//Functie pentru a adauga un nou cont la sfarsit
User* addAccount(User* user, Cont* cont) {
    if (user->headAccount == NULL) {
        user->headAccount = cont;
        user->tailAccount = cont;
    }
    else {
        user->tailAccount->next = cont;
        user->tailAccount = cont;
    }
    return user;
}


void addAccountToUser(User* user, Cont* newAccount) {
    if (user->headAccount == NULL) {
        user->headAccount = newAccount;
    }
    else {
        Cont* current = user->headAccount;
        while (current->next != NULL) {
            current = current->next;
        }
        current->next = newAccount;
    }
}

//Adaugare utilizator
User* addSorted(struct User* head, struct User* p) {
    User* q = head;
    if (head == NULL) {
        head = p;
    }
    else if (strcmp(head->username, p->username) > 0) {
        p->next = head;
        head = p;
        return head;
    }
    else {
        while (q->next != NULL && strcmp(q->next->username, p->username) < 0) {
            q = q->next;
        }
        p->next = q->next;
        q->next = p;
    }
    return head;
}

void saveUsersToFile() {
    FILE* file = fopen(USERS_FILE, "w");
    if (file == NULL) {
        printf("Eroare la deschiderea fisierului.\n");
        return;
    }

    User* current = usersList;
    while (current != NULL) {
        fprintf(file, "%s %s %s %s %s %d\n", current->username, current->password, current->CNP,
            current->nume, current->prenume, current->type);
        current = current->next;

    }

    fclose(file);
}

void saveAccountsToFile() {
    FILE* file = fopen(ACCOUNTS_FILE, "w");
    if (file == NULL) {
        printf("Eroare la deschiderea fisierului conturilor.\n");
        return;
    }

    User* currentUser = usersList;
    while (currentUser != NULL) {
        Cont* currentAccount = currentUser->headAccount;
        while (currentAccount != NULL) {
            fprintf(file, "%s %s %s %lf\n", currentAccount->IBAN, currentAccount->CNP_proprietar, currentAccount->valuta, currentAccount->sold);
            currentAccount = currentAccount->next;
        }
        currentUser = currentUser->next;
    }

    fclose(file);
}

void saveExtraseToFile(Cont* cont) {
    char fileName[50];
    sprintf(fileName, "%s_extrase.txt", cont->IBAN);

    FILE* file = fopen(fileName, "w");
    if (file == NULL) {
        printf("Eroare la deschiderea fișierului de extrase.\n");
        return;
    }
    Extrase* current = cont->extraseLista;
    while (current != NULL) {
        const char* type = operationToStrng(current->type);
        const char* result = resultToString(current->result);
        fprintf(file, "%s %s %s %s\n", cont->IBAN, type, result, current->reason);
        current = current->next;
    }
    fclose(file);
}

void loadExtraseFromFile(Cont* cont) {
    char fileName[50];
    sprintf(fileName, "%s_extrase.txt", cont->IBAN);
    FILE* file = fopen(fileName, "r");
    if (file == NULL) {
        return;
    }
    char iban[25], type[20], reason[100], timestamp[20], result[20];
    int rezultat,tip;
    char line[100];
    while (fgets(line, sizeof(line), file)) {
        if (sscanf(line, "%s %s %s", iban, type, result) == 3) {
            if (strcmp(result, "SUCCESFUL") == 0) {
                if (strcmp(cont->IBAN, iban) == 0) {
                    Extrase* newExtrase = (Extrase*)malloc(sizeof(Extrase));
                    if (newExtrase != NULL) {
                        tip = typeToEnum(type);
                        rezultat = resultToEnum(result);
                        newExtrase->type = tip;
                        newExtrase->result = rezultat;
                        reason[0] = '\0';
                        strcpy(newExtrase->reason, reason);
                        newExtrase->next = cont->extraseLista;
                        cont->extraseLista = newExtrase;
                    }
                }
            }
            else {
                sscanf(line, "%*s %*s %*s %s", reason);
                if (strcmp(cont->IBAN, iban) == 0) {
                    Extrase* newExtrase = (Extrase*)malloc(sizeof(Extrase));
                    if (newExtrase != NULL) {
                        tip = typeToEnum(type);
                        rezultat = resultToEnum(result);
                        newExtrase->type = tip;
                        newExtrase->result = rezultat;
                        reason[0] = '\0';
                        strcpy(newExtrase->reason, reason);
                        newExtrase->next = cont->extraseLista;
                        cont->extraseLista = newExtrase;
                    }
                }
            }
        }
    }

    fclose(file);
}

void addExtrase(Cont* cont, OperationType type, OperationResult result, const char* reason) {
    Extrase* newExtrase = (Extrase*)malloc(sizeof(Extrase));
    if (newExtrase == NULL) {
        printf("Eroare la alocarea memoriei pentru extrase.\n");
        return;
    }

    newExtrase->type = type;
    newExtrase->result = result;
    strcpy(newExtrase->reason, reason);

    newExtrase->next = cont->extraseLista;
    cont->extraseLista = newExtrase;
}

//Functie pentru schimbarea parolei
void changePassword(User* user, const char* newPassword) {
    if (user == NULL) {
        printf("Eroare contul nu exista.\n");
        return;
    }

    strcpy(user->password, newPassword);
    printf("Parola utilizatorului a fost actualizata cu succes.\n");

    saveUsersToFile();
}

void printExtrase(Cont* cont) {
    printf("Extrasele pentru contul cu IBAN-ul %s:\n", cont->IBAN);
    Extrase* current = cont->extraseLista;
    while (current != NULL) {
        printf("Tip operatie: %s\n", operationToStrng(current->type));
        printf("Rezultat operatie: %s\n", resultToString(current->result));
        if(strcmp(resultToString(current->result),"SUCCESFUL")!=0)
            printf("Motiv esuare: %s\n", current->reason);
        printf("-------------------------\n");
        current = current->next;
    }
}

void loadAllExtrase() {
    currentUser = usersList;
    while (currentUser != NULL) {
        currentAccount = currentUser->headAccount;
        while (currentAccount != NULL) {
            loadExtraseFromFile(currentAccount);
            currentAccount = currentAccount->next;
        }
        currentUser = currentUser->next;
    }
}

//Incarca conturile IBAN existente
void loadAccountsFromFile() {
    FILE* file = fopen(ACCOUNTS_FILE, "r");
    if (file == NULL) {
        printf("Eroare la deschiderea fisierului conturilor.\n");
        return;
    }

    double sold;
    char iban[50], CNP[14], valuta[50];
    while (fscanf(file, "%s %s %s %lf\n", iban, CNP, valuta, &sold) != EOF) {
        Cont* newAccount = (Cont*)malloc(sizeof(Cont));
        if (newAccount != NULL) {
            strcpy(newAccount->IBAN, iban);
            strcpy(newAccount->CNP_proprietar, CNP);
            strcpy(newAccount->valuta, valuta);
            newAccount->sold = sold;
            newAccount->next = NULL;
            newAccount->extraseLista = NULL;

            User* currentUser = usersList;
            while (currentUser != NULL) {
                if (strcmp(currentUser->CNP, CNP) == 0) {
                    addAccountToUser(currentUser, newAccount);
                    break;
                }
                currentUser = currentUser->next;
            }


        }
    }

    fclose(file);
}
//Incarca conturile existente
void loadUsersFromFile() {
    FILE* file = fopen(USERS_FILE, "r");
    if (file == NULL) {
        printf("Eroare la deschiderea fisierului utilizatorilor.\n");
        return;
    }

    char username[50], password[50], CNP[14], nume[50], prenume[50];
    int type;
    while (fscanf(file, "%s %s %s %s %s %d\n", username, password, CNP, nume, prenume, &type) != EOF) {
        User* newUser = (User*)malloc(sizeof(User));
        if (newUser != NULL) {
            strcpy(newUser->username, username);
            strcpy(newUser->password, password);
            strcpy(newUser->CNP, CNP);
            strcpy(newUser->nume, nume);
            strcpy(newUser->prenume, prenume);
            newUser->type = type;
            newUser->next = NULL;
            newUser->headAccount = NULL;

            // Adaugă noul utilizator la lista de utilizatori
            usersList = addSorted(usersList, newUser);
        }
    }

    fclose(file);
}

//Meniu principal
void meniu_principal() {
    printf("Bine ati venit!\n");
    printf("1. Autentificare\n");
    printf("2. Inregistrare\n");
    printf("3. Iesire\n");
}

User* readUser() {
    User* newUser = (User*)malloc(sizeof(User));
    if (newUser == NULL) {
        printf("Eroare la alocarea memoriei pentru utilizator!\n");
        return NULL;
    }
    printf("Introduceti numele de utilizator: ");
    scanf("%s", newUser->username);

    printf("Introduceti parola: ");
    scanf("%s", newUser->password);

    printf("Introduceti CNP-ul: ");
    scanf("%s", newUser->CNP);

    printf("Introduceti numele: ");
    scanf("%s", newUser->nume);

    printf("Introduceti prenumele: ");
    scanf("%s", newUser->prenume);

    int userType;
    printf("Alegeti tipul de utilizator (0 - Admin, 1 - Utilizator): ");
    scanf("%d", &userType);
    newUser->type = userType == 0 ? ADMIN : USER;

    newUser->next = NULL;
    newUser->headAccount = NULL;

    return newUser;
}

int delogare(User** utilizator_curent) {
    *utilizator_curent = NULL;
    printf("Delogare efectuata cu succes.\n");
    return 1;
}

//Functie pentru a afisa conturile
void ShowAccounts(User* user) {
    if (user->headAccount == NULL) {
        printf("Utilizatorul nu are nici un cont.\n");
        return;
    }
    Cont* currentAccount = user->headAccount;

    printf("Conturile asociate utilizatorului %s sunt:\n", user->username);
    while (currentAccount != NULL) {
        printf("IBAN: %s | Sold: %.2f %s\n", currentAccount->IBAN, currentAccount->sold, currentAccount->valuta);
        printExtrase(currentAccount);
        currentAccount = currentAccount->next;
    }
}

//Functie pentru a afisa utilizatorii si conturile lor
void showUsers(User* head) {
    User* current = usersList;
    while (current != NULL) {
        printf("Utilizator: %s\nCNP: %s\n", current->username, current->CNP);
        ShowAccounts(current);
        current = current->next;
    }
}

void showUsersWithoutAccounts(User* head) {
    User* current = usersList;
    while (current != NULL) {
        printf("Utilizator: %s\nCNP: %s\n", current->username, current -> CNP);
        current = current->next;
    }
}

Cont* selectAccount(User* user) {
    char iban[25];
    printf("Introduceti IBAN-ul contului pe care doriti sa-l selectati: ");
    scanf("%s", iban);

    Cont* currentAccount = user->headAccount;
    while (currentAccount != NULL) {
        if (strcmp(currentAccount->IBAN, iban) == 0) {
            return currentAccount;
        }
        currentAccount = currentAccount->next;
    }

    printf("Contul cu IBAN-ul %s nu a fost gasit.\n", iban);
    return NULL;
}

void deleteAccountByIban(User* head, const char* ibanToDelete) {
    User* currentUser = head;
    while (currentUser != NULL) {
        Cont** headAccountPtr = &currentUser->headAccount;
        Cont* currentAccount = *headAccountPtr;

        if (currentAccount == NULL) {
            currentUser = currentUser->next;
            continue;
        }

        if (strcmp(currentAccount->IBAN, ibanToDelete) == 0) {
            *headAccountPtr = currentAccount->next;
            free(currentAccount);
            printf("Contul cu IBAN-ul %s a fost sters cu succes din lista utilizatorului %s.\n", ibanToDelete, currentUser->username);
            saveAccountsToFile();
        }
        else {
            while (currentAccount->next != NULL) {
                if (strcmp(currentAccount->next->IBAN, ibanToDelete) == 0) {
                    Cont* temp = currentAccount->next;
                    currentAccount->next = temp->next;
                    free(temp);
                    printf("Contul cu IBAN-ul %s a fost sters cu succes din lista utilizatorului %s.\n", ibanToDelete, currentUser->username);
                    saveAccountsToFile();
                    break;
                }
                currentAccount = currentAccount->next;
            }
        }
        currentUser = currentUser->next;
    }
}

void editUserByCNP(const char* CNP, const char* newNume, const char* newPrenume) {
    currentUser = usersList;
    while (currentUser != NULL) {
        if (strcmp(currentUser->CNP, CNP) == 0) {
            strcpy(currentUser->nume, newNume);
            strcpy(currentUser->prenume, newPrenume);

            saveUsersToFile();
            printf("Datele utilizatorului cu CNP-ul %s au fost actualizate cu succes.\n", CNP);
            return;
        }
        currentUser = currentUser->next;
    }
    printf("Utilizatorul cu CNP-ul %s nu a fost gasit.\n", CNP);
}

Cont* findAccountByIBAN(User* head, const char* iban) {
    User* current = head;
    while (current != NULL) {
        Cont* currentAcc = current->headAccount;
        while (currentAcc != NULL) {
            if (strcmp(currentAcc->IBAN, iban) == 0) {
                return currentAcc;
            }
            currentAcc = currentAcc->next;
        }
        current = current->next;
    }
    return NULL;
}

void transferMoney(Cont *cont, const char* ibanDestinatie, double suma) {
    //Cont* contSursa = findAccountByIBAN(accountsList, ibanSursa);
    Cont* contDestinatie = findAccountByIBAN(usersList, ibanDestinatie);

    if (cont == NULL || contDestinatie == NULL) {
        printf("Unul dintre conturi nu exista.\n");
        addExtrase(cont, TRANSFER, CANCELED, "Unul dintre conturi nu exista.");

        return;
    }

    if (strcmp(cont->valuta, contDestinatie->valuta) != 0) {
        printf("Conturile nu au aceasi valuta, transferul nu este posibil.\n");
        addExtrase(cont, TRANSFER, CANCELED, "Conturile nu au aceeasi valuta.");
        return;
    }

    if (cont->sold < suma) {
        printf("Nu exista sold suficient in contul sursa pentru a efectua transferul.\n");
        addExtrase(cont, TRANSFER, CANCELED, "Nu exista sold suficient in contul sursa pentru a efectua transferul.");
        return;
    }

    cont->sold -= suma;
    contDestinatie->sold += suma;

    saveAccountsToFile();

    printf("Transferul de %.2f %s de la contul %s la contul %s s-a efectuat cu succes.\n", suma, cont->valuta, cont->valuta, ibanDestinatie);
    addExtrase(cont, TRANSFER, SUCCESFUL, "");
}


//Meniul pentru Admin
int adminMenu() {
    int opt;
    do {
        printf("\n----- Meniu Admin -----\n");
        printf("1. Adaugare utilizator\n");
        printf("2. Adaugare cont IBAN\n");
        printf("3. Afisare utilizatori si extrase\n");
        printf("4. Stergere IBAN\n");
        printf("5. Editare date utilizator dupa CNP\n");
        printf("6. Schimbare parola\n");
        printf("7. Delogare\n");
        printf("0. Iesire\n");
        printf("Alegeti optiunea: ");
        scanf("%d", &opt);
        getchar();
        switch (opt)
        {
        case 1:
        {
            User* newUser = readUser();
            usersList = addSorted(usersList, newUser);
            saveUsersToFile();
            break;
        }
        case 2:
        {
            printf("Utilizatori disponibili:\n");
            showUsersWithoutAccounts(usersList);

            char username[50];
            printf("Introduceti numele de utilizator al destinatarului: ");
            scanf("%s", username);

            User* selectedUser = usersList;
            while (selectedUser != NULL) {
                if (strcmp(selectedUser->username, username) == 0) {
                    break;
                }
                selectedUser = selectedUser->next;
            }
            if (selectedUser == NULL) {
                printf("Utilizatorul nu a fost gasit.\n");
                break;
            }

            Cont* newAccount = (Cont*)malloc(sizeof(Cont));
            if (newAccount == NULL) {
                printf("Eroare la alocarea memoriei.\n");
                break;
            }
            printf("Introduceti IBAN-ul contului: ");
            scanf("%s", newAccount->IBAN);
            printf("Introduceti valuta contului: ");
            scanf("%s", newAccount->valuta);
            printf("Introduceti soldul contului: ");
            scanf("%lf", &newAccount->sold);
            strcpy(newAccount->CNP_proprietar, selectedUser->CNP);
            newAccount->next = NULL;
            addAccountToUser(selectedUser, newAccount);
            saveAccountsToFile();
            printf("Cont salvat cu succes");
            break;
        }
        case 3:
            showUsers(usersList);
            break;
        case 4:
            showUsers(usersList);
            char iban[25];
            printf("Introduceti IBAN-ul contului pe care doriti sa il stergeti: ");
            scanf("%s", iban);
            deleteAccountByIban(usersList, iban);
            break;
        case 5:
            showUsersWithoutAccounts(usersList);
            char cnp[14], newNume[20], newPrenume[20];
            printf("Introduceti CNP-ul persoanei careia doriti sa modificati datele: ");
            scanf("%s", cnp);
            printf("Introduceti noul nume: ");
            scanf("%s", newNume);
            printf("Introduceti noul prenume: ");
            scanf("%s", newPrenume);
            editUserByCNP(cnp, newNume, newPrenume);
            break;
        case 6:
        {
            char newPass[50];
            printf("Introduceti parola noua: ");
            scanf("%s", newPass);
            changePassword(currentUser, newPass);
            break;
        }
        case 7:
            return delogat = delogare(&currentUser);
            break;
        case 0:
            exit(0);
        default:
            break;
        }
    } while (opt != 0);
}

//Submeniu pentru user:
void submenu() {
    printf("1. Adaugare bani in cont\n");
    printf("2. Retragere bani din cont\n");
    printf("3. Transfer bani catre alt cont\n");
    printf("4. Afisare extrase de cont\n");
    printf("5. Iesire\n");
}

void addMoneyToAccount(User* user, Cont* account) {
    double amountToAdd;
    printf("Introduceti suma pe care doriti sa o adaugati in contul cu IBAN-ul %s: ", account->IBAN);
    scanf("%lf", &amountToAdd);
    if (amountToAdd <= 0) {
        printf("Suma introdusa trebuie sa fie mai mare decat 0.\n");
        addExtrase(account, DEPOSIT, CANCELED, "Suma introdusa trebuie sa fie mai mare decat 0.");
        return;
    }

    account->sold += amountToAdd;

    saveAccountsToFile();

    printf("Suma de %.2f a fost adaugata cu succes in contul cu IBAN-ul %s.\n", amountToAdd, account->IBAN);
    addExtrase(account, DEPOSIT, SUCCESFUL, "");
}

void removeMoneyFromAccount(User* user, Cont* account) {
    double amountToTake;
    printf("Introduceti suma pe care doriti sa o retrageti din contul cu IBAN-ul %s: ", account->IBAN);
    scanf("%lf", &amountToTake);
    if (amountToTake >= account->sold) {
        printf("Suma introdusa este mai mare decat sold-ul disponibil.\n");
        addExtrase(account, WITHDRAW, CANCELED, "Suma introdusa este mai mare decat sold-ul disponibil.");
        return;
    }

    account->sold -= amountToTake;

    saveAccountsToFile();
    printf("Suma de %.2f a fost retrasa cu succes din contul cu IBAN-ul %s.\n", amountToTake, account->IBAN);
    addExtrase(account, WITHDRAW, SUCCESFUL, "");
}

//Meniul pentru User
int userMenu() {
    int opt,opt2;
    do {
        printf("\n----- Meniu Utilizator -----\n");
        printf("1. Selectare cont pentru operatii\n");
        printf("2. Schimbare parola\n");
        printf("3. Delogare\n");
        printf("0. Iesire\n");
        printf("Alegeti optiunea: ");
        scanf("%d", &opt);
        getchar();

        switch (opt)
        {
        case 1:
            ShowAccounts(currentUser);
            currentAccount = selectAccount(currentUser);
            submenu();
            printf("Alegeti optiunea: ");
            scanf("%d", &opt2);
            switch (opt2)
            {
            case 1:
                addMoneyToAccount(currentUser, currentAccount);
                saveExtraseToFile(currentAccount);
                break;
            case 2:
                removeMoneyFromAccount(currentUser, currentAccount);
                saveExtraseToFile(currentAccount);
                break;
            case 3:
            {
                double s;
                char iban[25];
                showUsers(usersList);
                printf("Introduceti IBAN-ul contului catre care doriti sa transferati: ");
                scanf("%s", iban);
                printf("Introduceti suma pe care doriti sa o transferati: ");
                scanf("%lf", &s);
                transferMoney(currentAccount, iban, s);
                saveExtraseToFile(currentAccount);
                break;
            }
            case 4:
                printExtrase(currentAccount);
            default:
                break;
            }
            break;
        case 3:
            return delogat = delogare(&currentUser);
            break;
        case 0:
            exit(0);
        default:
            break;
        }
    } while (opt != 0);
}

//Autentificare
User *autentification(char username[], char password[], UserType* userType) {
    currentUser = usersList;
    while (currentUser != NULL) {
        if (strcmp(currentUser->username, username) == 0 && strcmp(currentUser->password, password) == 0) {
            *userType = currentUser->type;
            return currentUser;
        }
        currentUser = currentUser->next;
    }
    return NULL;
}

//Utilizator admin de baza
void addBaseAdminAccount() {
    // Creăm un utilizator admin de bază
    User* adminUtil = (User*)malloc(sizeof(User));
    if (adminUtil == NULL) {
        printf("Eroare la alocarea memoriei pentru utilizator.\n");
        return;
    }

    // Inițializăm valorile utilizatorului admin de bază
    strcpy(adminUtil->username, "admin");
    strcpy(adminUtil->password, "adminpass");
    strcpy(adminUtil->CNP, "1234567890123");
    strcpy(adminUtil->nume, "Admin");
    strcpy(adminUtil->prenume, "Administrator");
    adminUtil->type = ADMIN;
    adminUtil->next = NULL;

    usersList = addSorted(usersList, adminUtil);
}

//Proces autentificare
void autentificationProcess() {
    if (usersList == NULL) {
        addBaseAdminAccount();
        printf("Utilizator admin de baza creat. Foloseste numele de utilizator 'admin' si parola 'adminpass' pentru a te autentifica.\n");
    }
    char username[50];
    char password[50];
    printf("Introduceti numele de utilizator: ");
    scanf("%s", username);
    printf("Introduceti parola: ");
    scanf("%s", password);

    UserType userType;
    currentUser = autentification(username, password, &userType);
    if (currentUser != NULL) {
        if (userType == ADMIN) {
            adminMenu(currentUser);
        }
        else if (userType == USER) {
            userMenu(currentUser);
        }
        else {
            printf("Nume de utilizator sau parola incorecta!\n");
        }
    }
}

void registrationProcess() {
    User* newUser = readUser();
    if (newUser != NULL) {
        usersList = addSorted(usersList, newUser);
        saveUsersToFile();
        printf("Utilizator inregistrat cu succes!\n");
    }
}

int main() {
    loadUsersFromFile();
    loadAccountsFromFile();
    loadAllExtrase();
    int opt;
    do {
        if (delogat) {
            delogat = 0;
            meniu_principal();
        }
        else meniu_principal();
        printf("Introduceti optiunea: ");
        scanf("%d", &opt);
        getchar();
        system("cls");
        switch (opt) {
        case 1:
            autentificationProcess();
            break;
        case 2:
            registrationProcess();
            break;
        case 3:
            printf("Iesire din program. La revedere!\n");
            exit(0);
        default:
            printf("Optiune invalida. Va rugam sa selectati o optiune valida.\n");
        }

    } while (1);

    return 0;
}