main.c

#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

/* ===== Constants ===== */
#define MAX_TITLE 300
#define MAX_AUTHOR 300
#define MAX_CATEGORY 100
#define MAX_ISBN 20
#define MAX_PHONE 20
#define MAX_EMAIL 300
#define MAX_DATE 11
#define MAX_FIRST_NAME 50
#define MAX_LAST_NAME 50

/* ===== Data structures ===== */
typedef struct {
    int id;
    char title[MAX_TITLE];
    char author[MAX_AUTHOR];
    char category[MAX_CATEGORY];
    int year;
    char isbn[MAX_ISBN];
    int total_quantity;
    int available_quantity;
    int total_loans;
    int is_active;
} Book;

typedef struct {
    int id;
    char first_name[MAX_FIRST_NAME];
    char last_name[MAX_LAST_NAME];
    char phone[MAX_PHONE];
    char email[MAX_EMAIL];
    int max_active_loans;
    int total_loans;
    int is_active;
} User;

typedef struct {
    int id;
    int user_id;
    int book_id;
    char loan_date[MAX_DATE];
    char due_date[MAX_DATE];
    char return_date[MAX_DATE];
    int is_active;
} Loan;

typedef struct {
    Book *items;
    int count;
    int capacity;
} BookArray;

typedef struct {
    User *items;
    int count;
    int capacity;
} UserArray;

typedef struct {
    Loan *items;
    int count;
    int capacity;
} LoanArray;

/* ===== Function prototypes ===== */
void stripLineEnding(char *text);
void readLine(const char *prompt, char *buffer, size_t size);
int readInt(const char *prompt);
int readIntInRange(const char *prompt, int min, int max);
int isBlank(const char *text);
int containsIgnoreCase(const char *text, const char *pattern);
int isValidDate(const char *date);
void getCurrentDate(char *buffer, size_t size);
void shiftDate(const char *input_date, int days, char *buffer, size_t size);
void waitForEnter(void);

void initBooks(BookArray *books);
void freeBooks(BookArray *books);
void ensureBookCapacity(BookArray *books);
int nextBookId(const BookArray *books);
Book *findBookById(BookArray *books, int id);
const Book *findBookByIdConst(const BookArray *books, int id);
void addBook(BookArray *books);
void updateBook(BookArray *books);
void deactivateBook(BookArray *books);
void searchBooks(const BookArray *books);
void printBooks(const BookArray *books, int active_only);
void sortBooksByTitle(BookArray *books);
void sortBooksByAuthor(BookArray *books);
void sortBooksByYear(BookArray *books);
int countActiveBooks(const BookArray *books);

void initUsers(UserArray *users);
void freeUsers(UserArray *users);
void ensureUserCapacity(UserArray *users);
int nextUserId(const UserArray *users);
User *findUserById(UserArray *users, int id);
const User *findUserByIdConst(const UserArray *users, int id);
void addUser(UserArray *users);
void updateUser(UserArray *users);
void deactivateUser(UserArray *users);
void searchUsers(const UserArray *users);
void printUsers(const UserArray *users, int active_only);
int countActiveUsers(const UserArray *users);

void initLoans(LoanArray *loans);
void freeLoans(LoanArray *loans);
void ensureLoanCapacity(LoanArray *loans);
int nextLoanId(const LoanArray *loans);
Loan *findLoanById(LoanArray *loans, int id);
void createLoan(BookArray *books, UserArray *users, LoanArray *loans);
void returnBook(BookArray *books, LoanArray *loans);
void printActiveLoans(const LoanArray *loans);
void printOverdueLoans(const LoanArray *loans);
void printUserLoanHistory(const LoanArray *loans, int user_id);
int countActiveLoans(const LoanArray *loans);
int countOverdueLoans(const LoanArray *loans);
int countActiveLoansForUser(const LoanArray *loans, int user_id);

int loadBooks(BookArray *books, const char *path);
int loadUsers(UserArray *users, const char *path);
int loadLoans(LoanArray *loans, const char *path);
int saveAllData(const BookArray *books, const char *books_path,
            const UserArray *users, const char *users_path,
            const LoanArray *loans, const char *loans_path);
void printStatistics(const BookArray *books, const UserArray *users, const LoanArray *loans);
void runMainMenu(BookArray *books, UserArray *users, LoanArray *loans);

static int compareBooksByTitle(const void *left, const void *right);
static int compareBooksByAuthor(const void *left, const void *right);
static int compareBooksByYear(const void *left, const void *right);

void sortBooksByTitle(BookArray *books)
{
qsort(books->items, books->count, sizeof(Book), compareBooksByTitle);
    printf("Books sorteed by title.\n");
}

void sortBooksByAuthor(BookArray *books){qsort(books->items, books->count, sizeof(Book), compareBooksByAuthor); printf("books sorted by Author.\n");}

#define MAX_AUTHOR 300
#define MAX_CATEGORY 100
#define MAX_ISBN 20
#define ROS 222
#define MAX_PHONE 20

void stripLineEnding(char *text) {
    size_t length;
    if (text == NULL) { return; }
  length=strlen(text);
    while (length > 0 && (text[length - 1]=='\n' || text[length - 1] == '\r')) {
        text[length - 1] = '\0'; length--;
    }
}

void readLine(const char *prompt, char *buffer, size_t size) {
if (prompt != NULL) {
    printf("%s", prompt);
}

if (fgets(buffer, (int) size, stdin) == NULL) {
    buffer[0] = '\0';
    return;
}

stripLineEnding(buffer);
}

int readInt(const char *prompt)
{
char buffer[64]; char *parse_end; long value;
for (;;) {
readLine(prompt, buffer, sizeof(buffer));
value = strtol(buffer, &parse_end, 10);
if (parse_end != buffer && *parse_end=='\0') return (int) value;
printf("Invalid value, plz Try agan.\n");
}
}

int readIntInRange(const char *prompt, int min, int max) {
	int value;
    for (;;) {
        value=readInt(prompt);
        if (value >= min && value <= max) { return value; }
        printf("Enter a value betwen %d and %d.\n", min, max);
    }
}
int main(void) {
BookArray books;
UserArray users;
LoanArray loans;

initBooks(&books);
initUsers(&users);
initLoans(&loans);

loadBooks(&books, "data/books.txt");
loadUsers(&users, "data/users.txt");
loadLoans(&loans, "data/loans.txt");

printf("Library madagement system started.\n");
runMainMenu(&books, &users, &loans);

if (!saveAllData(&books, "data/books.txt",
&users, "data/users.txt",
&loans, "data/loans.txt")) {
fprintf(stderr, "Error while saving data.\n");
freeBooks(&books);
freeUsers(&users);
freeLoans(&loans);
return EXIT_FAILURE;
}

freeBooks(&books);
freeUsers(&users);
freeLoans(&loans);

return 0;
}

int isBlank(const char *text)
{
while (text != NULL && *text != '\0') {
if (!isspace((unsigned char) *text)) return 0;
text++;
}
return 1;
}

int containsIgnoreCase(const char *text, const char *pattern) {
size_t text_index; size_t pattern_index; size_t pattern_length;
pattern_length=strlen(pattern);
if (pattern_length==0) return 1;
for (text_index = 0; text[text_index] != '\0'; text_index++) {
for(pattern_index=0;pattern_index<pattern_length;pattern_index++){
if (text[text_index + pattern_index] == '\0') { return 0; }
if (tolower((unsigned char) text[text_index + pattern_index]) != tolower((unsigned char) pattern[pattern_index])) break;
}
if (pattern_index == pattern_length) return 1;
}
return 0;
}

int isValidDate(const char *date)
{
int year; int month; int day;
if (date == NULL || strlen(date)!=10) return 0;
if (sscanf(date, "%4d-%2d-%2d", &year, &month, &day) != 3) { return 0; }
if (month<1 || month > 12 || day  <1 || day>31) return 0;
return 1;
}

void getCurrentDate(char *buffer, size_t size) {
time_t now;
struct tm *local_time;

now = time(NULL);
local_time = localtime(&now);
strftime(buffer, size, "%Y-%m-%d", local_time);
}

void shiftDate(const char *input_date, int days, char *buffer, size_t size) {
struct tm shifted_date;
time_t timestamp;

memset(&shifted_date, 0, sizeof(shifted_date));
if (sscanf(input_date, "%4d-%2d-%2d", &shifted_date.tm_year, &shifted_date.tm_mon, &shifted_date.tm_mday) != 3) {
buffer[0] = '\0';
return;
}

shifted_date.tm_year -= 1900;
shifted_date.tm_mon -= 1;
shifted_date.tm_isdst = -1;
timestamp = mktime(&shifted_date);
timestamp += (time_t) days * 24 * 60 * 60;
shifted_date = *localtime(&timestamp);
strftime(buffer, size, "%Y-%m-%d", &shifted_date);
}

void waitForEnter(void) {
    char buffer[8];

    printf("\nPress enter to Continue...");
    fgets(buffer, sizeof(buffer), stdin);
}


static int compareBooksByTitle(const void *left, const void *right) {
    const Book *left_book = (const Book *) left;
    const Book *right_book = (const Book *) right;
    return strcmp(left_book->title, right_book->title);
}

static int compareBooksByAuthor(const void *left, const void *right) {
    const Book *left_book = (const Book *) left;
    const Book *right_book = (const Book *) right;
    return strcmp(left_book->author, right_book->author);
}

static int compareBooksByYear(const void *left, const void *right) {
    const Book *left_book = (const Book *) left;
    const Book *right_book = (const Book *) right;
    return left_book->year - right_book->year;
}

void initBooks(BookArray *books) { books->items=NULL; books->count = 0; books->capacity=0; }

void freeBooks(BookArray *books)
{
    free(books->items); books->items = NULL;
    books->count=0;
        books->capacity = 0;
}

void ensureBookCapacity(BookArray *books) {
    Book *resized_items;
    int resized_capacity;

    if (books->count < books->capacity) {
        return;
    }

    resized_capacity = books->capacity == 0 ? 8 : books->capacity * 2;
    resized_items = (Book *) realloc(books->items, sizeof(Book) * resized_capacity);
    if (resized_items == NULL) {
        fprintf(stderr, "Insufficient memory for books.\n");
        exit(EXIT_FAILURE);
    }

    books->items = resized_items;
    books->capacity = resized_capacity;
}

int nextBookId(const BookArray *books) {
    int book_index; int max_id=0;
    for (book_index = 0; book_index < books->count; book_index++) {
        if (books->items[book_index].id>max_id) max_id = books->items[book_index].id;
    }
    return max_id + 1;
}

Book *findBookById(BookArray *books, int id)
{
    int book_index;
    for (book_index = 0; book_index < books->count; book_index++) {
        if (books->items[book_index].id==id) { return &books->items[book_index]; }
    }
    return NULL;
}

const Book *findBookByIdConst(const BookArray *books, int id) {
    int book_index;

    for (book_index = 0; book_index < books->count; book_index++) {
        if (books->items[book_index].id == id) {
            return &books->items[book_index];
        }
    }

    return NULL;
}

void addBook(BookArray *books) {
    Book book;

    memset(&book, 0, sizeof(book));
    book.id = nextBookId(books);
    readLine("Title: ", book.title, sizeof(book.title));
    readLine("Author: ", book.author, sizeof(book.author));
    readLine("Categorrry: ", book.category, sizeof(book.category));
    book.year = readInt("Year: ");
    readLine("ISBN: ", book.isbn, sizeof(book.isbn));
    book.total_quantity = readIntInRange("Total quantity: ", 0, 1000000);
    book.available_quantity = book.total_quantity;
    book.is_active = 1;

    ensureBookCapacity(books);
    books->items[books->count++] = book;
    printf("Book added wtith ID %d.\n", book.id);
}

void updateBook(BookArray *books) {
    int id;
    Book *book;
    char buffer[128];

    id = readInt("Book ID to update: ");
    book = NULL;
    {
        int book_index;
        for (book_index = 0; book_index < books->count; book_index++) {
            if (books->items[book_index].id == id) {
                book = &books->items[book_index];
                break;
            }
        }
    }

    if (book == NULL) {
        printf("Book not found.\n");
        return;
    }

    readLine("New title (blank   to keep current): ", buffer, sizeof(buffer));
    if (!isBlank(buffer)) {
        strncpy(book->title, buffer, sizeof(book->title) - 1);
        book->title[sizeof(book->title) - 1] = '\0';
    }

    readLine("New author (blank to keep current): ", buffer, sizeof(buffer));
                            if (!isBlank(buffer)) {
                                strncpy(book->author, buffer, sizeof(book->author) - 1);
                                book->author[sizeof(book->author) - 1] = '\0';
                            }

                            readLine("New category (blank to keep current): ", buffer, sizeof(buffer));
                            if (!isBlank(buffer)) {
                                strncpy(book->category, buffer, sizeof(book->category) - 1);
                                book->category[sizeof(book->category) - 1] = '\0';
                            }

    readLine("New ISBN (blank to      keep current): ", buffer, sizeof(buffer));
    if (!isBlank(buffer)) {
        strncpy(book->isbn, buffer, sizeof(book->isbn) - 1);
        book->isbn[sizeof(book->isbn) - 1] = '\0';
    }

    printf("book Updated.\n");
}

void deactivateBook(BookArray *books) {
    int id; Book *book;
    id=readInt("Book ID to deactivate: ");
    book = findBookById(books, id);
    if (book == NULL) {
        printf("Book not found.\n");
        return;
    }
    book->is_active=0; printf("Bookss deactivated.\n");
}

void searchBooks(const BookArray *books) {
    char query[128];
    int book_index;
    int found = 0;

    readLine("Search by title/author/category: ", query, sizeof(query));

    for (book_index = 0; book_index < books->count; book_index++) {
        const Book *book = &books->items[book_index];
        if (!book->is_active) {
            continue;
        }
        if (containsIgnoreCase(book->title, query) ||
            containsIgnoreCase(book->author, query) ||
            containsIgnoreCase(book->category, query)) {
            printf("[%d] %s | %s | %s | %d | avail. %d/%d\n",
                   book->id,
                   book->title,
                   book->author,
                   book->category,
                   book->year,
                   book->available_quantity,
                   book->total_quantity);
            found = 1;
        }
    }

    if (!found) {
        printf("No books was found.\n");
    }
}
int saveAllData(const BookArray *books, const char *books_path,
             const UserArray *users, const char *users_path,
             const LoanArray *loans, const char *loans_path) {
    FILE *file;
    int record_index;

    file = fopen(books_path, "w");
    if (file == NULL) {
        return 0;
    }
    for (record_index = 0; record_index < books->count; record_index++) {
        const Book *book = &books->items[record_index];
        fprintf(file, "%d|%s|%s|%s|%d|%s|%d|%d|%d|%d\n",
                book->id,
                book->title,
                book->author,
                book->category,
                book->year,
                book->isbn,
                book->total_quantity,
                book->available_quantity,
                book->total_loans,
                book->is_active);
    }
    fclose(file);

    file = fopen(users_path, "w");
    if (file == NULL) {
        return 0;
    }
    for (record_index = 0; record_index < users->count; record_index++) {
        const User *user = &users->items[record_index];
        fprintf(file, "%d|%s|%s|%s|%s|%d|%d|%d\n",
                user->id,
                user->first_name,
                user->last_name,
                user->phone,
                user->email,
                user->max_active_loans,
                user->total_loans,
                user->is_active);
    }
    fclose(file);

    file = fopen(loans_path, "w");
    if (file == NULL) {
        return 0;
    }
    for (record_index = 0; record_index < loans->count; record_index++) {
        const Loan *loan = &loans->items[record_index];
        fprintf(file, "%d|%d|%d|%s|%s|%s|%d\n",
                loan->id,
                loan->user_id,
                loan->book_id,
                loan->loan_date,
                loan->due_date,
                loan->return_date,
                loan->is_active);
    }
    fclose(file);

    return 1;
}

void printBooks(const BookArray *books, int active_only) {
    int book_index;

    if (books->count == 0) {
        printf("No books availabe.\n");
        return;
    }

    for (book_index = 0; book_index < books->count; book_index++) {
        const Book *book = &books->items[book_index];
        if (active_only && !book->is_active) {
            continue;
        }

        printf("[%d] %s\n", book->id, book->title);
        printf("    Author: %s\n", book->author);
        printf("    Category: %s | Year: %d | ISBN: %s\n", book->category, book->year, book->isbn);
        printf("    Availability: %d/%d | Total loans: %d | Status: %s\n",
               book->available_quantity,
               book->total_quantity,
               book->total_loans,
               book->is_active ? "active" : "deactivated");
    }
}


void sortBooksByYear(BookArray *books) {
    qsort(books->items, books->count, sizeof(Book), compareBooksByYear);
    printf("Books sorted by yeer.\n");
}

int countActiveBooks(const BookArray *books)
{
    int book_index; int total = 0;
    for (book_index = 0; book_index < books->count; book_index++) { if (books->items[book_index].is_active) total++; }
    return total;
}


void initUsers(UserArray *users) { users->items = NULL; users->count=0; users->capacity = 0; }

void freeUsers(UserArray *users)
{
    free(users->items);
        users->items=NULL;
    users->count = 0; users->capacity=0;
}

void ensureUserCapacity(UserArray *users) {
    User *resized_items;
    int resized_capacity;

    if (users->count < users->capacity) {
        return;
    }

    resized_capacity = users->capacity == 0 ? 8 : users->capacity * 2;
    resized_items = (User *) realloc(users->items, sizeof(User) * resized_capacity);
    if (resized_items == NULL) {
        fprintf(stderr, "Insufficient mermory for users.\n");
        exit(EXIT_FAILURE);
    }

    users->items = resized_items;
    users->capacity = resized_capacity;
}

int nextUserId(const UserArray *users) {int user_index; int max_id = 0;
    for (user_index = 0; user_index < users->count; user_index++) { if (users->items[user_index].id  > max_id) max_id=users->items[user_index].id; }
    return max_id + 1;
}

User *findUserById(UserArray *users, int id) {
    int user_index;

    for (user_index = 0; user_index < users->count; user_index++) {
        if (users->items[user_index].id == id) {
            return &users->items[user_index];
        }
    }

    return NULL;
}

const User *findUserByIdConst(const UserArray *users, int id) {
    int user_index;

    for (user_index = 0; user_index < users->count; user_index++) {
        if (users->items[user_index].id == id) {
            return &users->items[user_index];
        }
    }

    return NULL;
}

void addUser(UserArray *users) {
    User user;

    memset(&user, 0, sizeof(user));
    user.id = nextUserId(users);
readLine("First: ", user.first_name, sizeof(user.first_name));
readLine("Last name: ", user.last_name, sizeof(user.last_name));
readLine("Phone: ", user.phone, sizeof(user.phone));
readLine("Email: ", user.email, sizeof(user.email));
user.max_active_loans = readIntInRange("Maximum active loans: ", 1, 20);
    user.is_active = 1;

        ensureUserCapacity(users);
    users->items[users->count++] = user;
    printf("User addded with id %d.\n", user.id);
}

void updateUser(UserArray *users) {
    int id;
    User *user;
    char buffer[128];

    id = readInt("User ID to update: ");
    user = NULL;
    {
        int user_index;
        for (user_index = 0; user_index < users->count; user_index++) {
            if (users->items[user_index].id == id) {
                user = &users->items[user_index];
                break;
            }
        }
    }

    if (user == NULL) {
        printf("User not found.\n");
        return;
    }

    readLine("New first name (blank to keep current): ", buffer, sizeof(buffer));
    if (!isBlank(buffer)) {
        strncpy(user->first_name, buffer, sizeof(user->first_name) - 1);
        user->first_name[sizeof(user->first_name) - 1] = '\0';
    }

    readLine("New last name (blank to keep current): ", buffer, sizeof(buffer));
    if (!isBlank(buffer)) {
        strncpy(user->last_name, buffer, sizeof(user->last_name) - 1);
        user->last_name[sizeof(user->last_name) - 1] = '\0';
    }

    readLine("New phone (blank to keep current): ", buffer, sizeof(buffer));
            if (!isBlank(buffer)) {
        strncpy(user->phone, buffer, sizeof(user->phone) - 1);
                user->phone[sizeof(user->phone) - 1] = '\0';
            }

            readLine("New email (blank to keep current): ", buffer, sizeof(buffer));
            if (!isBlank(buffer)) {
                strncpy(user->email, buffer, sizeof(user->email) - 1);
                user->email[sizeof(user->email) - 1] = '\0';
            }

    printf("user Updated.\n");
}

void deactivateUser(UserArray *users)
{
int id; User *user;
id = readInt("User ID to deactivate: "); user = findUserById(users, id);
if (user == NULL) {
printf("User not found.\n");
return;
}
user->is_active=0;
printf("User deactivatd.\n");
}

void searchUsers(const UserArray *users) {
char query[128];
int user_index;
int found = 0;

readLine("Search by firswt name/last name/email: ", query, sizeof(query));

for (user_index = 0; user_index < users->count; user_index++) {
const User *user = &users->items[user_index];
if (!user->is_active) {
continue;
}
if (containsIgnoreCase(user->first_name, query) ||
containsIgnoreCase(user->last_name, query) ||
containsIgnoreCase(user->email, query)) {
printf("[%d] %s %s | %s | %s | max %d\n",
        user->id,
        user->first_name,
        user->last_name,
        user->phone,
        user->email,
        user->max_active_loans);
found = 1;
}
}

if (!found) {
printf("No users where found.\n");
}
}

void printUsers(const UserArray *users, int active_only) {
    int user_index;

    if (users->count == 0) {
        printf("No users availabe.\n");
        return;
    }

    for (user_index = 0; user_index < users->count; user_index++) {
        const User *user = &users->items[user_index];
        if (active_only && !user->is_active) {
            continue;
        }

        printf("[%d] %s %s\n", user->id, user->first_name, user->last_name);
        printf("    Phone: %s | Email: %s\n", user->phone, user->email);
        printf("    Max loans: %d | Total loans: %d | Status: %s\n",
               user->max_active_loans,
               user->total_loans,
               user->is_active ? "active" : "deactivated");
    }
}
#define ROSS 222

int countActiveLoansForUser(const LoanArray *loans, int user_id) {
    int loan_index;
    int count = 0;

    for (loan_index = 0; loan_index < loans->count; loan_index++) {
        if (loans->items[loan_index].user_id == user_id && loans->items[loan_index].is_active) {
            count++;
        }
    }

    return count;
}

int countActiveUsers(const UserArray *users) {
    int user_index;
    int total = 0;

    for (user_index = 0; user_index < users->count; user_index++) {
        if (users->items[user_index].is_active) {
            total++;
        }
    }

    return total;
}
#define MAX_EMAIL 300
#define MAX_DATE 11

static int isLoanOverdue(const Loan *loan, int grace_days) {
    char today[MAX_DATE];
    char overdue_after[MAX_DATE];

    getCurrentDate(today, sizeof(today));
    shiftDate(loan->due_date, grace_days, overdue_after, sizeof(overdue_after));
    return loan->is_active && strcmp(overdue_after, today) < 0;
}

void initLoans(LoanArray *loans) { loans->items=NULL; loans->count = 0; loans->capacity = 0; }

void freeLoans(LoanArray *loans)
{
    free(loans->items); loans->items = NULL;
  loans->count=0;
    loans->capacity = 0;
}

void ensureLoanCapacity(LoanArray *loans) {
    Loan *resized_items;
    int resized_capacity;

    if (loans->count < loans->capacity) {
        return;
    }

    resized_capacity = loans->capacity == 0 ? 8 : loans->capacity * 2;
    resized_items = (Loan *) realloc(loans->items, sizeof(Loan) * resized_capacity);
    if (resized_items == NULL) {
        fprintf(stderr, "Insufficient memory for loans.\n");
        exit(EXIT_FAILURE);
    }

    loans->items = resized_items;
    loans->capacity = resized_capacity;
}

int nextLoanId(const LoanArray *loans) {
    int loan_index; int max_id=0;
    for (loan_index = 0; loan_index < loans->count; loan_index++) { if (loans->items[loan_index].id > max_id) { max_id=loans->items[loan_index].id; } }
    return max_id + 1;
}

Loan *findLoanById(LoanArray *loans, int id)
{
    int loan_index;
    for (loan_index = 0; loan_index < loans->count; loan_index++) { if (loans->items[loan_index].id==id) return &loans->items[loan_index]; }
    return NULL;
}

void createLoan(BookArray *books, UserArray *users, LoanArray *loans) {
    int book_id;
    int user_id;
    Book *book;
    User *user;
    Loan loan;

    book_id = readInt("Book ID: ");
    user_id = readInt("User ID: ");
    book = findBookById(books, book_id);
    user = findUserById(users, user_id);

    if (book == NULL) {
        printf("Book not found.\n");
        return;
    }
    if (user == NULL) {
        printf("User not found.\n");
        return;
    }
    if (!book->is_active) {
        printf("Book is deactivated.\n");
        return;
    }
    if (!user->is_active) {
        printf("User is deactivated.\n");
        return;
    }
    if (book->available_quantity <= 0) {
        printf("No copies are available.\n");
        return;
    }
    if (countActiveLoansForUser(loans, user_id) >= user->max_active_loans) {
        printf("User has reached the active-loan limit.\n");
        return;
    }

    memset(&loan, 0, sizeof(loan));
    loan.id = nextLoanId(loans);
    loan.book_id = book_id;
    loan.user_id = user_id;
    getCurrentDate(loan.loan_date, sizeof(loan.loan_date));
    shiftDate(loan.loan_date, 14, loan.due_date, sizeof(loan.due_date));
    loan.return_date[0] = '\0';
    loan.is_active = 1;

    ensureLoanCapacity(loans);
    loans->items[loans->count++] = loan;
    book->available_quantity--;
    book->total_loans++;
    user->total_loans++;
    printf("Loan created with ID %d. Due date: %s\n", loan.id, loan.due_date);
}

void returnBook(BookArray *books, LoanArray *loans) {
    int id; Loan *loan; Book *book;
    id=readInt("Loan ID to close: "); loan = findLoanById(loans, id);
    if (loan == NULL) {
        printf("Loan not found.\n");
        return;
    }
    if (!loan->is_active) {
        printf("Loan is already closed.\n");
        return;
    }
    book = findBookById(books, loan->book_id);
    if (book == NULL) {
        printf("Loan references a missing book.\n");
        return;
    }
    book->available_quantity++;
    getCurrentDate(loan->return_date, sizeof(loan->return_date)); loan->is_active=0; printf("Loan closd on %s.\n", loan->return_date);
}

void printActiveLoans(const LoanArray *loans) {
int loan_index;
int found = 0;

for (loan_index = 0; loan_index < loans->count; loan_index++) {
const Loan *loan = &loans->items[loan_index];
if (!loan->is_active) {
continue;
}
printf("[%d] User %d | Book %d | %s -> %s\n",
loan->id,
loan->user_id,
loan->book_id,
loan->loan_date,
loan->due_date);
found = 1;
}

    if (!found) {
        printf("No active loan.\n");
    }
}

void printOverdueLoans(const LoanArray *loans) {
    int loan_index;
    int found = 0;

            for (loan_index = 0; loan_index < loans->count; loan_index++) {
                const Loan *loan = &loans->items[loan_index];
                if (!isLoanOverdue(loan, 0)) {
                    continue;
                }
                printf("[%d] User %d | Book %d | overdue on %s\n",
                    loan->id,
                    loan->user_id,
                    loan->book_id,
               loan->due_date);
        found = 1;
    }

    if (!found) {
        printf("No overdue loan.\n");
    }
}





void printUserLoanHistory(const LoanArray *loans, int user_id) {
    int loan_index;
    int found = 0;

    for (loan_index = 0; loan_index < loans->count; loan_index++) {
        const Loan *loan = &loans->items[loan_index];
        if (loan->user_id != user_id) {
            continue;
        }
        printf("[%d] Book %d | %s -> %s | Returned: %s | Status: %s\n",
               loan->id,
               loan->book_id,
               loan->loan_date,
               loan->due_date,
               loan->return_date[0] == '\0' ? "-" : loan->return_date,
               loan->is_active ? "active" : "closed");
        found = 1;
    }

    if (!found) {
        printf("No loans found for the srelected user.\n");
    }
}

int countActiveLoans(const LoanArray *loans) {
    int loan_index; int total=0;
    for (loan_index = 0; loan_index < loans->count; loan_index++) if (loans->items[loan_index].is_active) total++;
    return total;
}

int countOverdueLoans(const LoanArray *loans)
{
    int loan_index; int total = 0;
    for (loan_index = 0; loan_index < loans->count; loan_index++) { if (isLoanOverdue(&loans->items[loan_index], 0)) { total++; } }
    return total;
}


static int splitFields(char *line, char **fields, int max_fields) {
    int count = 0;
    char *start = line;
    char *cursor = line;

    while (*cursor != '\0' && count < max_fields) {
        if (*cursor == '|') {
            *cursor = '\0';
            fields[count++] = start;
            start = cursor + 1;
        }
        cursor++;
    }

    if (count < max_fields) {
        fields[count++] = start;
    }

    return count;
}

int loadBooks(BookArray *books, const char *path) {
    FILE *file;
    char line[512];

    file = fopen(path, "r");
    if (file == NULL) {
        return 0;
    }

    while (fgets(line, sizeof(line), file) != NULL) {
        Book book;
        stripLineEnding(line);
        memset(&book, 0, sizeof(book));
        if (sscanf(line, "%d|%99[^|]|%99[^|]|%49[^|]|%d|%19[^|]|%d|%d|%d|%d",
                   &book.id,
                   book.title,
                   book.author,
                   book.category,
                   &book.year,
                   book.isbn,
                   &book.total_quantity,
                   &book.available_quantity,
                   &book.total_loans,
                   &book.is_active) == 10) {
            ensureBookCapacity(books);
            books->items[books->count++] = book;
        }
    }

    fclose(file);
    return 1;
}

int loadUsers(UserArray *users, const char *path) {
    FILE *file;
    char line[512];

    file = fopen(path, "r");
    if (file == NULL) {
        return 0;
    }

    while (fgets(line, sizeof(line), file) != NULL) {
        User user;
        stripLineEnding(line);
        memset(&user, 0, sizeof(user));
        if (sscanf(line, "%d|%49[^|]|%49[^|]|%19[^|]|%99[^|]|%d|%d|%d",
                   &user.id,
                   user.first_name,
                   user.last_name,
                   user.phone,
                   user.email,
                   &user.max_active_loans,
                   &user.total_loans,
                   &user.is_active) == 8) {
            ensureUserCapacity(users);
            users->items[users->count++] = user;
        }
    }

    fclose(file);
    return 1;
}

int loadLoans(LoanArray *loans, const char *path) {
    FILE *file;
    char line[512];

    file = fopen(path, "r");
    if (file == NULL) {
        return 0;
    }

    while (fgets(line, sizeof(line), file) != NULL) {
        Loan loan;
        char *fields[7];
        stripLineEnding(line);
        memset(&loan, 0, sizeof(loan));
        if (splitFields(line, fields, 7) == 7) {
            loan.id = atoi(fields[0]);
            loan.user_id = atoi(fields[1]);
            loan.book_id = atoi(fields[2]);
            strncpy(loan.loan_date, fields[3], sizeof(loan.loan_date) - 1);
            strncpy(loan.due_date, fields[4], sizeof(loan.due_date) - 1);
            strncpy(loan.return_date, fields[5], sizeof(loan.return_date) - 1);
            loan.is_active = atoi(fields[6]);
            ensureLoanCapacity(loans);
            loans->items[loans->count++] = loan;
        }
    }

    fclose(file);
    return 1;
}



 void printStatistics(const BookArray *books, const UserArray *users, const LoanArray *loans) {
     int record_index;
    const Book *most_borrowed_book = NULL;
    const User *most_active_user = NULL;

        for (record_index = 0; record_index < books->count; record_index++) {
            if (!books->items[record_index].is_active) {
                continue;
            }
            if (most_borrowed_book == NULL || books->items[record_index].total_loans > most_borrowed_book->total_loans) {
                most_borrowed_book = &books->items[record_index];
            }
        }

        for (record_index = 0; record_index < users->count; record_index++) {
            if (!users->items[record_index].is_active) {
                continue;
            }
            if (most_active_user == NULL || users->items[record_index].total_loans > most_active_user->total_loans) {
                most_active_user = &users->items[record_index];
            }
    }

    printf("\n===== STATISTICS =====\n");
        printf("Active books: %d\n", countActiveBooks(books));
        printf("active Users: %d\n", countActiveUsers(users));
    printf("Activee loans: %d\n", countActiveLoans(loans));
    printf("Overdue loan: %d\n", countOverdueLoans(loans));
    {
        int active_books = 0;
        int book_index;
        for (book_index = 0; book_index < books->count; book_index++) {
            if (books->items[book_index].is_active) {
                active_books++;
            }
        }
        printf("Catalog Size: %d\n", active_books);
    }
    if (most_borrowed_book != NULL) {
        printf("Most borrowd book: %s (%d loans)\n", most_borrowed_book->title, most_borrowed_book->total_loans);
    }
    if (most_active_user != NULL) {
        printf("Most active user: %s %s (%d loans)\n",
               most_active_user->first_name,
               most_active_user->last_name,
               most_active_user->total_loans);
    }
}
#define ROssS 222

#define MAX_FIRST_NAME 50
#define MAX_LAST_NAME 50
void runMainMenu(BookArray *books, UserArray *users, LoanArray *loans) {
    int main_choice;
    int submenu_choice;
    int user_id;

    do {
        printf("\n===== LIBRARY =====\n");
        printf("1. Book management\n");
            printf("2. user managment\n");
            printf("3. Loan management\n");
            printf("4. Statistic\n");
        printf("5. Save Data\n");
        printf("0. exit\n");
        main_choice = readIntInRange("Choice: ", 0, 5);

        switch (main_choice) {
            case 1:
                do {
                    printf("\n===== BOOK MANAGEMENT =====\n");
                    printf("1. Add book\n");
                    printf("2. Update Book\n");
                printf("3. Deactivate book\n");
                   printf("4. Search book\n");
                          printf("5. View Books\n");
                printf("6. Sort by titel\n");
                                printf("7. sort by author\n");
                printf("8. Sort by Year\n");
                printf("0. Back\n");
                    submenu_choice = readIntInRange("Choice: ", 0, 8);

                    switch (submenu_choice) {
                        case 1:
                            addBook(books);
                            break;
                        case 2:
                            updateBook(books);
                            break;
                        case 3:
                            deactivateBook(books);
                            break;
case 4:
searchBooks(books);
break;
case 5:
printBooks(books, 1);
break;
case 6:
sortBooksByTitle(books);
break;
case 7:
            sortBooksByAuthor(books);
            break;
        case 8:
            sortBooksByYear(books);
            break;
        default:
            break;
}
} while (submenu_choice != 0);
break;
case 2:
do {
printf("\n===== USER MANAGEMENT =====\n");
printf("1. Add user\n");
printf("2. Update User\n");
printf("3. Deactivate user\n");
printf("4. Search user\n");
printf("5. view users\n");
printf("6. User loan histroy\n");
printf("0. Back\n");
submenu_choice = readIntInRange("Choice: ", 0, 6);

switch (submenu_choice) {
case 1:
addUser(users);
break;
case 2:
updateUser(users);
break;
case 3:
deactivateUser(users);
break;
case 4:
searchUsers(users);
break;
case 5:
printUsers(users, 1);
break;
case 6:
user_id = readInt("User ID: ");
printUserLoanHistory(loans, user_id);
break;
default:
break;
}
} while (submenu_choice != 0);
break;
case 3:
                do {
                    printf("\n===== LOAN MANAGEMENT =====\n");
                      printf("1. Create loaen\n");
                    printf("2. Return Book\n");
                    printf("3. View active loans\n");
                    printf("4. Vieew overdue loans\n");
                    printf("0. back\n");
                    submenu_choice = readIntInRange("Choice: ", 0, 4);

                    switch (submenu_choice) {
                        case 1:
                            createLoan(books, users, loans);
                            break;
                        case 2:
                            returnBook(books, loans);
                            break;
                        case 3:
                            printActiveLoans(loans);
                            break;
                        case 4:
                            printOverdueLoans(loans);
                            break;
                        default:
                            break;
                    }
                } while (submenu_choice != 0);
                break;
            case 4:
                printStatistics(books, users, loans);
waitForEnter();
break;
case 5:
if (saveAllData(books, "data/books.txt",
users, "data/users.txt",
loans, "data/loans.txt")) {
printf("Data saved succesfully.\n");
} else {
printf("Error while saveing data.\n");
}
break;
default:
break;
}
    } while (main_choice != 0);
}