client.cpp

#include <iostream>
#include <stdio.h>      /* printf, sprintf */
#include <stdlib.h>     /* exit, atoi, malloc, free */
#include <unistd.h>     /* read, write, close */
#include <string.h>     /* memcpy, memset */
#include <sys/socket.h> /* socket, connect */
#include <netinet/in.h> /* struct sockaddr_in, struct sockaddr */
#include <netdb.h>      /* struct hostent, gethostbyname */
#include <arpa/inet.h>
#include <vector>
#include <string>
#include "helpers.hpp"
#include "requests.hpp"

#include "nlohmann/json.hpp"
using json = nlohmann::json;

#define PORT 8081
#define LOGIN "/api/v1/tema/admin/login"
#define USERS "/api/v1/tema/admin/users"
#define PAYLOAD_TYPE "application/json"
#define LOGIN_USER_URL    "/api/v1/tema/user/login"
#define LIB_ACCESS "/api/v1/tema/library/access"
#define MOVIES "/api/v1/tema/library/movies"
#define COLLECTIONS "/api/v1/tema/library/collections"
#define LOGOUT_USER "/api/v1/tema/user/logout"

using namespace std;

/* Extracts the first cookie (up to ';' or CRLF) */
char *extract_cookie(char *response, char **cookies, int *cookie_count) {
    char *start = strstr(response, "Set-Cookie: ");
    if (!start) return NULL;
    start += strlen("Set-Cookie: ");
    char *end = strstr(start, ";");
    if (!end) end = strstr(start, "\r\n");
    int len = end - start;
    cookies[*cookie_count] = (char *)calloc(len+1, 1);
    strncpy(cookies[*cookie_count], start, len);
    (*cookie_count)++;
    return cookies[*cookie_count - 1];
}

/* Extracts the value from JSON: "key":"<value>" */
char *extract_key(char *response) {
    char *p = strstr(response, "\"key\"");
    if (!p) return NULL;
    p = strchr(p, ':');
    if (!p) return NULL;
    p++;
    while (*p == ' ' || *p == '\"') p++;
    char *end = strchr(p, '\"');
    if (!end) return NULL;
    int len = end - p;
    char *key = (char *) calloc(len+1, 1);
    strncpy(key, p, len);
    return key;
}


void extract_cookies(char *response, char **cookies, int *cookie_count) {
    *cookie_count = 0;
    char *p = response;

    while ((p = strstr(p, "Set-Cookie: ")) != nullptr && *cookie_count < 16) {
        p += strlen("Set-Cookie: ");
        char *end = strstr(p, ";");
        if (!end) end = strstr(p, "\r\n");
        if (!end) break;

        int len = end - p;
        cookies[*cookie_count] = (char*)calloc(len + 1, 1);
        strncpy(cookies[*cookie_count], p, len);
        (*cookie_count)++;
    }
}



void handle_response_and_store_cookies(char *response, std::vector<char *> &cookie_storage, const std::string &success_msg, const std::string &error_msg) {
    int code = 0;
    sscanf(response, "HTTP/%*s %d", &code);

    // Check if the HTTP response code indicates success
    if (code >= 200 && code < 300) {
        std::cout << success_msg << "\n";

        // Extract cookies from the response and store them
        char *cookie_arr[16];
        int cookie_count = 0;
        extract_cookies(response, cookie_arr, &cookie_count);
        for (int i = 0; i < cookie_count; i++) {
            cookie_storage.push_back(cookie_arr[i]);
        }
    } else {
        // Print error message if the response code is not successful
        std::cout << error_msg << "\n";
    }
}

void send_json_auth_request(const std::string &endpoint,
                            const std::string &success_msg,
                            const std::string &error_msg,
                            int sockfd,
                            std::vector<char *> &cookies,
                            const char *hostIp) {
    std::string username, password;

    // Prompt for username and password from the user
    std::cout << "username=";
    std::getline(std::cin, username);
    std::cout << "password=";
    std::getline(std::cin, password);

    // Validate input: must not be empty or contain spaces
    if (username.empty() || password.empty() ||
        username.find(' ') != std::string::npos ||
        password.find(' ') != std::string::npos) {
        std::cout << "ERROR: Invalid username or password\n";
        return;
    }

    // Build JSON payload for authentication
    json request_json = {
        {"username", username},
        {"password", password}
    };
    std::string payload = request_json.dump();
    char *payload_body = strdup(payload.c_str());

    char *request = compute_post_request(
        (char *)hostIp,
        (char *)endpoint.c_str(),
        (char *)PAYLOAD_TYPE,
        &payload_body,
        1,
        cookies,
        cookies.size(),
        nullptr
    );

    // Send request and handle response
    send_to_server(sockfd, request);
    char *response = receive_from_server(sockfd);
    close_connection(sockfd);

    // Handle response and store cookies if authentication is successful
    handle_response_and_store_cookies(response, cookies, success_msg, error_msg);

    free(payload_body);
    free(request);
    free(response);
}



void login_admin(int sockfd, std::vector<char *> &admin_cookies, char *hostIp) {
    send_json_auth_request(LOGIN, "SUCCESS: Admin authenticated successfully",
                                  "ERROR: Authentication failed",
                                  sockfd, admin_cookies, hostIp);
}

void add_user(int sockfd, std::vector<char *> &admin_cookies, char *hostIp) {
    send_json_auth_request(USERS, "SUCCESS: User added successfully",
                                  "ERROR: User addition failed",
                                  sockfd, admin_cookies, hostIp);
}


void get_users(int sockfd, std::vector<char *> &admin_cookies, char *hostIp) {
    // Build the GET request for the users endpoint, including admin cookies
    char *request = compute_get_request(
        hostIp,
        (char *)USERS,
        nullptr,
        admin_cookies,
        (int)admin_cookies.size(),
        nullptr
    );
    // Send the request to the server
    send_to_server(sockfd, request);

    // Receive the response from the server
    char *resp = receive_from_server(sockfd);

    // Close the socket connection
    close_connection(sockfd);

    // Parse the HTTP status code from the response
    int code = 0;
    sscanf(resp, "HTTP/%*s %d", &code);

    if (code >= 200 && code < 300) {
        // Find the start of the response body (after headers)
        char *body = strstr(resp, "\r\n\r\n");
        if (body) {
            body += 4; // Skip the header delimiter

            // Parse the JSON body
            nlohmann::json json_response = nlohmann::json::parse(body, nullptr, false);
            std::cout << "SUCCESS: Users list\n";

            // If the response is an object with a "users" array
            if (json_response.is_object() && json_response.contains("users") && json_response["users"].is_array()) {
                for (const auto &user : json_response["users"]) {
                    int id = user.value("id", -1);
                    std::string name = user.value("username", "");
                    std::string pass = user.value("password", "");
                    std::cout << "#" << id << " " << name << ":" << pass << "\n";
                }
            }
            // If the response is a top-level array
            else if (json_response.is_array()) {
                for (const auto &user : json_response) {
                    int id = user.value("id", -1);
                    std::string name = user.value("username", "");
                    std::string pass = user.value("password", "");
                    std::cout << "#" << id << " " << name << ":" << pass << "\n";
                }
            }
        } else {
            // No body found, but still a success code
            std::cout << "SUCCESS: Users List\n";
        }
    } else {
        // Non-success HTTP code
        std::cout << "ERROR: Failed to retrieve users\n";
    }

    // Free allocated memory for request and response
    free(request);
    free(resp);
}

void delete_user(int sockfd, std::vector<char *> &admin_cookies, const char *hostIp, char *token) {
    

    // Prompt the admin to enter the username of the user to delete
    std::cout << "username=";
    std::string username;
    std::getline(std::cin, username);

    // Check if the username is empty and print an error if so
    if (username.empty()) {
        std::cout << "ERROR: Invalid username\n";
        return;
    }

    // Construct the API path for deleting the specified user
    std::string path = "/api/v1/tema/admin/users/" + username;

    auto build_delete_message = [&](const std::string &host,
                                    const std::string &resource,
                                    const std::vector<char *> &cookies)
                                  -> std::string {
        std::ostringstream out;

        // Start the DELETE request line
        out << "DELETE " << resource << " HTTP/1.1\r\n";

        // Add the Host header
        out << "Host: " << host << "\r\n";

        // Add cookies if any are present
        if (!cookies.empty()) {
            out << "Cookie: ";
            for (size_t i = 0; i < cookies.size(); ++i) {
            out << cookies[i];
            if (i + 1 < cookies.size()) {
                out << "; ";
            }
            }
            out << "\r\n";
        }

        // End of headers
        out << "\r\n";
        return out.str();
    };

    // Build and send the DELETE request message
    std::string raw_request = build_delete_message(hostIp, path, admin_cookies);
    char *request_buf = strdup(raw_request.c_str());
    send_to_server(sockfd, request_buf);
    free(request_buf);

    // Get the response
    char *resp = receive_from_server(sockfd);
    close_connection(sockfd);

    // HTTP code check
    int code = 0;
    if (sscanf(resp, "HTTP/%*s %d", &code) != 1) {
        std::cout << "ERROR: Invalid response from server\n";
        free(resp);
        return;
    }

    if (code / 100 == 2) {
        std::cout << "SUCCESS: User deleted\n";
    } else {
        std::cout << "ERROR: User deletion failed (code " << code << ")\n";
    }

    free(resp);
}


void login(int sockfd,
                std::vector<char *> &admin_cookies,
                std::vector<char *> &user_cookies, char *hostIp) {
    std::string admin_username;
    std::string username;
    std::string passwd;

    // Read credentials
    std::cout << "admin_username=";
    std::getline(std::cin, admin_username);
    std::cout << "username=";
    std::getline(std::cin, username);
    std::cout << "password=";
    std::getline(std::cin, passwd);

    // Validate credentials
    auto invalid = [](const std::string &s) {
        return s.empty() || s.find(' ') != std::string::npos;
    };
    if (invalid(admin_username) || invalid(username) || invalid(passwd)) {
        std::cout << "ERROR: Invalid credentials format\n";
        return;
    }

    // Build the JSON payload
    nlohmann::json j = {
        {"admin_username", admin_username},
        {"username", username},
        {"password", passwd}
    };
    std::string payload = j.dump();

    // Prepare the request
    char *body    = strdup(payload.c_str());
    char *request = compute_post_request(
        hostIp,
        LOGIN_USER_URL,
        PAYLOAD_TYPE,
        &body, 1,
        admin_cookies, admin_cookies.size(),
        nullptr
    );

    // Send the request and receive the response
    send_to_server(sockfd, request);
    char *resp = receive_from_server(sockfd);
    close_connection(sockfd);

    // HTTP code check
    int code = 0;
    sscanf(resp, "HTTP/%*s %d", &code);
    if (code >= 200 && code < 300) {
        std::cout << "SUCCESS: Authentication successful\n";

        // Extract the JWT token
        char *cookies_buf[16];
        int    cookies_count = 0;
        extract_cookie(resp, cookies_buf, &cookies_count);
        for (int i = 0; i < cookies_count; ++i) {
            user_cookies.push_back(cookies_buf[i]);
        }
    } else {
        std::cout << "ERROR: Authentication failed\n";
    }

    free(request);
    free(resp);
    free(body);
}

void logout_admin(char *hostIp, std::vector<char *> &admin_cookies)
{
    // Check if admin is authenticated (has cookies)
    if (admin_cookies.empty()) {
        std::cout << "ERROR: Admin is not authenticated\n";
        return;
    }

    // Open a new connection to the server
    int sockfd = open_connection(hostIp, PORT, AF_INET, SOCK_STREAM, 0);

    // Prepare the logout endpoint path
    const char *logout_path = "/api/v1/tema/admin/logout";

    // Build the GET request for admin logout, including cookies
    char *request = compute_get_request(
        hostIp,
        (char *)logout_path,
        nullptr,
        admin_cookies,
        static_cast<int>(admin_cookies.size()),
        nullptr
    );
    // Send the logout request to the server
    send_to_server(sockfd, request);

    // Receive the server's response
    char *response = receive_from_server(sockfd);
    close_connection(sockfd);

    // Parse the HTTP status code from the response
    int status = 0;
    sscanf(response, "HTTP/%*s %d", &status);

    // If logout was successful, clear admin cookies
    if (status >= 200 && status < 300) {
        std::cout << "SUCCESS: Admin logged out\n";
        for (char *cookie : admin_cookies) {
            free(cookie);
        }
        admin_cookies.clear();
    } else {
        std::cout << "ERROR: Logout failed\n";
    }

    // Free allocated memory for request and response
    free(request);
    free(response);
}


void get_access(char *hostIp,
                std::vector<char *> &user_cookies,
                char **token) 
{
    // Verify if user is authenticated
    if (user_cookies.empty()) {
        std::cout << "ERROR: User is not authenticated\n";
        return;
    }

    // Open a new connection
    int sockfd = open_connection(hostIp, PORT, AF_INET, SOCK_STREAM, 0);

    // Send the GET request for library access
    char *request = compute_get_request(
        hostIp,
        LIB_ACCESS,
        nullptr,
        user_cookies,
        static_cast<int>(user_cookies.size()),
        nullptr
    );
    send_to_server(sockfd, request);

    // Get the response
    char *response = receive_from_server(sockfd);
    close_connection(sockfd);

    // HTTP code check
    int code = 0;
    sscanf(response, "HTTP/%*s %d", &code);

    if (code >= 200 && code < 300) {
        // Extract the JWT token
        char *body = strstr(response, "\r\n\r\n");
        if (body) {
            body += 4;
            auto j = json::parse(body, nullptr, false);
            if (!j.is_discarded()) {
                std::string tok = j.value("token", "");
                if (!tok.empty() && token) {
                    *token = strdup(tok.c_str());
                }
            }
        }
        std::cout << "SUCCESS: JWT token received\n";
    } else {
        std::cout << "ERROR: Authentication required\n";
    }

    free(request);
    free(response);
}


void add_movie(char *hostIp,
               int sockfd,
               char *token,
               std::vector<char *> &user_cookies) {

    // Verify if user is authenticated
    if (!token || !*token || user_cookies.empty()) {
        std::cout << "ERROR: No library access or invalid data\n";
        return;
    }

    // Read movie details
    std::string title, description, year_str, rating_str;
    std::cout << "title=";
    std::getline(std::cin, title);
    std::cout << "description=";
    std::getline(std::cin, description);
    std::cout << "year=";
    std::getline(std::cin, year_str);
    std::cout << "rating=";
    std::getline(std::cin, rating_str);

    // Validate input
    if (title.empty() || description.empty() ||
        year_str.empty() || rating_str.empty()) {
        std::cout << "ERROR: No library access or invalid data\n";
        return;
    }
    int year;
    double rating;
    char *endptr1 = nullptr, *endptr2 = nullptr;
    year = strtol(year_str.c_str(), &endptr1, 10);
    rating = strtod(rating_str.c_str(), &endptr2);

    if (!endptr1 || *endptr1 != '\0' || !endptr2 || *endptr2 != '\0') {
        std::cout << "ERROR: No library access or invalid data\n";
        return;
    }

    // Build the JSON payload
    json j = {
        {"title", title},
        {"year", year},
        {"description", description},
        {"rating", rating}
    };
    std::string payload = j.dump();
    char *body = strdup(payload.c_str());

    // Build the request
    char *request = compute_post_request(
        hostIp,
        MOVIES,
        (char*)PAYLOAD_TYPE,
        &body, 1,
        user_cookies,
        (int)user_cookies.size(),
        token
    );

    // Send the request and receive the response
    send_to_server(sockfd, request);
    char *resp = receive_from_server(sockfd);
    close_connection(sockfd);

    // Verify HTTP code
    int code = 0;
    sscanf(resp, "HTTP/%*s %d", &code);
    if (code >= 200 && code < 300) {
        std::cout << "SUCCESS: Movie added\n";
    } else {
        std::cout << "ERROR: No library access or invalid data\n";
    }

    free(request);
    free(resp);
    free(body);
}



void get_movies(int sockfd,
                std::vector<char *> &user_cookies,
                char *token, char *hostIp) 
{
    // Send GET request for movies
    char *req = compute_get_request(
        hostIp,
        MOVIES,
        nullptr,
        user_cookies,
        static_cast<int>(user_cookies.size()),
        token
    );
    send_to_server(sockfd, req);

    // Receive response
    char *resp = receive_from_server(sockfd);

    int status = 0;
    sscanf(resp, "HTTP/%*s %d", &status);

    if (status < 200 || status >= 300) {
        std::cout << "ERROR: No library access\n";
        free(req);
        free(resp);
        return;
    }

    // Extract JSON body
    char *json_body = basic_extract_json_response(resp);
    if (!json_body) {
        std::cout << "ERROR: No library access\n";
        free(req);
        free(resp);
        return;
    }

    // Keep the JSON body for parsing
    auto parsed = json::parse(json_body, nullptr, false);
    if (parsed.is_discarded()) {
        std::cout << "No library acces\n";
        free(req);
        free(resp);
        return;
    }

    // Determine where the movies array is in the parsed JSON
    const json *movie_list = nullptr;
    if (parsed.is_array()) {
        movie_list = &parsed;
    } else if (parsed.is_object() && parsed.contains("movies") && parsed["movies"].is_array()) {
        movie_list = &parsed.at("movies");
    }

    std::cout << "SUCCESS: Film list" << std::endl;
    if (movie_list) {
        for (auto it = movie_list->begin(); it != movie_list->end(); ++it) {
            int id = it->contains("id") ? (*it)["id"].get<int>() : -1;
            std::string title = it->contains("title") ? (*it)["title"].get<std::string>() : "";
            std::cout << "#" << id << " " << title << std::endl;
        }
    }

    free(req);
    free(resp);
}


void get_movie(int sockfd,
                std::vector<char *> &user_cookies,
                char *token, char *hostIp) 
{
    // Read movie ID
    std::cout << "id=";
    std::string id_str; 
    std::getline(std::cin, id_str);
    if (id_str.empty()) {
        std::cout << "ERROR: Invalid movie ID\n";
        return;
    }

    // Build the GET request
    std::string path = MOVIES + std::string("/") + id_str;
    char *req = compute_get_request(
        hostIp,
        (char *)path.c_str(),
        nullptr,
        user_cookies,
        static_cast<int>(user_cookies.size()),
        token
    );
    send_to_server(sockfd, req);

    // Receive the response
    char *resp = receive_from_server(sockfd);
    close_connection(sockfd);

    // Verify HTTP code
    int code = 0;
    sscanf(resp, "HTTP/%*s %d", &code);
    if (code >= 200 && code < 300) {
        // Extract JSON body
        char *json_body = basic_extract_json_response(resp);
        if (json_body) {
            auto parsed = json::parse(json_body, nullptr, false);
            if (!parsed.is_discarded()) {
                std::cout << "SUCCESS: Movie details\n";
                std::cout << parsed.dump(4) << "\n"; // Pretty print JSON
            } else {
                std::cout << "ERROR: Invalid JSON response\n";
            }
        } else {
            std::cout << "ERROR: Invalid JSON response\n";
        }
    } else {
        std::cout << "ERROR: Movie not found\n";
    }

    free(req);
    free(resp);
}

void update_movie(char *hostIp,
                  int sockfd,
                  char *token,
                  std::vector<char *> &user_cookies)
{
    // Verify if user is authenticated
    if (!token || !*token || user_cookies.empty()) {
        std::cout << "ERROR: No library access or invalid data\n";
        return;
    }

    // Read movie ID
    std::cout << "id=";
    std::string id_str;
    std::getline(std::cin, id_str);
    if (id_str.empty()) {
        std::cout << "ERROR: Invalid movie ID\n";
        return;
    }

    // Read movie details
    std::string title, description, year_str, rating_str;
    std::cout << "title=";
    std::getline(std::cin, title);
    std::cout << "description=";
    std::getline(std::cin, description);
    std::cout << "year=";
    std::getline(std::cin, year_str);
    std::cout << "rating=";
    std::getline(std::cin, rating_str);

    // Build the JSON payload
    json j;
    if (!title.empty())       j["title"] = title;
    if (!description.empty()) j["description"] = description;
    if (!year_str.empty()) {
        char *endptr = nullptr;
        int year = strtol(year_str.c_str(), &endptr, 10);
        if (!endptr || *endptr != '\0') {
            std::cout << "ERROR: Invalid year\n";
            return;
        }
        j["year"] = year;
    }
    // If the user provided a new rating, validate and add it to the JSON payload
    if (!rating_str.empty()) {
        char *endptr = nullptr;
        double rating = strtod(rating_str.c_str(), &endptr);
        // Check if the rating is a valid number
        if (!endptr || *endptr != '\0') {
            std::cout << "ERROR: Invalid rating\n";
            return;
        }
        j["rating"] = rating;
    }

    // If no fields were provided for update, show an error and abort
    if (j.empty()) {
        std::cout << "ERROR: No fields to update were provided\n";
        return;
    }

    std::string payload = j.dump();
    char *body = strdup(payload.c_str());

    std::string path = std::string(MOVIES) + "/" + id_str;

    // Build the PUT request
    char *request = compute_put_request(
        hostIp,
        (char *)path.c_str(),
        PAYLOAD_TYPE,
        payload,
        user_cookies,
        (int)user_cookies.size(),
        token
    );

    // Send the request and receive the response
    send_to_server(sockfd, request);
    char *resp = receive_from_server(sockfd);
    close_connection(sockfd);

    // Verify HTTP code
    int code = 0;
    sscanf(resp, "HTTP/%*s %d", &code);
    if (code >= 200 && code < 300) {
        std::cout << "SUCCESS: Movie updated\n";
    } else {
        std::cout << "ERROR: Update failed or no access\n";
    }

    free(request);
    free(resp);
    free(body);
}


void delete_movie(int sockfd,
                std::vector<char *> &user_cookies,
                char *token, char *hostIp) 
{
    // Read movie ID
    std::cout << "id=";
    std::string id_str;
    std::getline(std::cin, id_str);
    if (id_str.empty()) {
        std::cout << "ERROR: Invalid movie ID\n";
        return;
    }

    // Build the DELETE request
    std::string path = MOVIES + std::string("/") + id_str;
    char *req = compute_delete_request(
        hostIp,
        (char *)path.c_str(),
        user_cookies,
        static_cast<int>(user_cookies.size()),
        token
    );
    send_to_server(sockfd, req);

    // Get the response
    char *resp = receive_from_server(sockfd);
    close_connection(sockfd);

    // Verify HTTP code
    int code = 0;
    sscanf(resp, "HTTP/%*s %d", &code);
    if (code >= 200 && code < 300) {
        std::cout << "SUCCESS: Movie deleted\n";
    } else {
        std::cout << "ERROR: Deletion failed or no access\n";
    }

    free(req);
    free(resp);
}

void add_collection(char *hostIp,
                    int sockfd,
                    std::vector<char *> &user_cookies,
                    char *token) 
{
    // Verify if user is authenticated and has access
    if (!token || !*token || user_cookies.empty()) {
        std::cout << "ERROR: No library access or invalid data\n";
        return;
    }

    // Prompt for collection title
    std::cout << "title=";
    std::string title;
    std::getline(std::cin, title);
    if (title.empty()) {
        std::cout << "ERROR: Invalid collection title\n";
        return;
    }

    // Prompt for number of movies to add to the collection
    std::cout << "num_movies=";
    std::string num_str;
    std::getline(std::cin, num_str);
    int num = 0;
    char *endptr = nullptr;
    num = strtol(num_str.c_str(), &endptr, 10);
    if (!endptr || *endptr != '\0') {
        std::cout << "ERROR: num_movies invalid\n";
        return;
    }
    if (num <= 0) {
        std::cout << "ERROR: num_movies must be positive\n";
        return;
    }

    // Read each movie ID from user input
    std::vector<int> movie_ids;
    for (int i = 0; i < num; ++i) {
        std::cout << "movie_id["<<i<<"]=";
        std::string mid;
        std::getline(std::cin, mid);
        char *endptr = nullptr;
        int movie_id = strtol(mid.c_str(), &endptr, 10);
        if (!endptr || *endptr != '\0') {
            std::cout << "ERROR: movie_id invalid\n";
            return;
        }
        movie_ids.push_back(movie_id);
    }

    // Create the collection by sending a POST request with the title
    nlohmann::json create_j = {{"title", title}};
    std::string create_payload = create_j.dump();
    char *create_body = strdup(create_payload.c_str());

    char *create_req = compute_post_request(
        hostIp,
        (char*)COLLECTIONS,
        (char*)PAYLOAD_TYPE,
        &create_body, 1,
        user_cookies,
        (int)user_cookies.size(),
        token
    );
    send_to_server(sockfd, create_req);
    char *create_resp = receive_from_server(sockfd);
    close_connection(sockfd);

    // Extract HTTP code from the response
    int code = 0;
    sscanf(create_resp, "HTTP/%*s %d", &code);
    if (code < 200 || code >= 300) {
        std::cout << "ERROR: No library access or invalid data\n";
        free(create_req);
        free(create_resp);
        free(create_body);
        return;
    }
    
    // Parse the response body to get the new collection ID
    char *body = strstr(create_resp, "\r\n\r\n");
    if (!body) {
        std::cout << "ERROR: Invalid response\n";
        free(create_req);
        free(create_resp);
        free(create_body);
        return;
    }
    nlohmann::json resp_j = nlohmann::json::parse(body + 4);
    int coll_id = resp_j.value("id", -1);
    if (coll_id < 0) {
        std::cout << "ERROR: Invalid response\n";
        free(create_req);
        free(create_resp);
        free(create_body);
        return;
    }

    // Open a new connection for adding movies to the collection
    sockfd = open_connection(hostIp, PORT, AF_INET, SOCK_STREAM, 0);

    // For each movie ID, send a POST request to add it to the collection
    for (int mid : movie_ids) {
        nlohmann::json add_j = {{"id", mid}};
        std::string add_payload = add_j.dump();
        char *add_body = strdup(add_payload.c_str());
        // Build the path for adding a movie to the collection
        std::string path = std::string(COLLECTIONS) + "/" 
                         + std::to_string(coll_id) 
                         + "/movies";
        char *add_req = compute_post_request(
            hostIp,
            (char*)path.c_str(),
            (char*)PAYLOAD_TYPE,
            &add_body, 1,
            user_cookies,
            (int)user_cookies.size(),
            token
        );
        send_to_server(sockfd, add_req);
        char *add_resp = receive_from_server(sockfd);
        close_connection(sockfd);
        
        // Free memory for each request/response
        free(add_req);
        free(add_resp);
        free(add_body);

        // Reopen the connection for the next movie (if any)
        sockfd = open_connection(hostIp, PORT, AF_INET, SOCK_STREAM, 0);
    }

    // Print success message after all movies have been added
    std::cout << "SUCCESS: Collection added\n";

    // Free memory for the initial collection creation request/response
    free(create_req);
    free(create_resp);
    free(create_body);
}

// helper: print a parsed JSON “collections” array (or top-level array)
void print_collections_list(const nlohmann::json &json_obj) {
    const nlohmann::json *collections = nullptr;

    // Check if the top-level JSON is an array (list of collections)
    if (json_obj.type() == nlohmann::json::value_t::array) {
        collections = &json_obj;
    // Or if it's an object with a "collections" array field
    } else if (json_obj.type() == nlohmann::json::value_t::object &&
               json_obj.contains("collections") &&
               json_obj["collections"].is_array()) {
        collections = &json_obj.at("collections");
    }

    std::cout << "SUCCESS: Collection list\n";
    if (collections) {
        // Iterate through each collection in the array
        for (const auto &item : *collections) {
            // Extract id and title for each collection
            int id = item.value("id", -1);
            std::string title = item.value("title", "");
            // Print collection info in the required format
            std::cout << "#" << id << ": " << title << "\n";
        }
    }
}

void get_collections(char *hostIp,
                     int sockfd,
                     std::vector<char *> &user_cookies,
                     char *token)
{
    // Build the GET request for the collections endpoint, including cookies and token if present
    char *req  = compute_get_request(hostIp, COLLECTIONS, nullptr,
                                     user_cookies, user_cookies.size(), token);

    // Send the request to the server
    send_to_server(sockfd, req);

    // Receive the response from the server
    char *resp = receive_from_server(sockfd);

    // Close the socket connection after receiving the response
    close_connection(sockfd);

    // Parse the HTTP status code from the response
    int code = 0;
    sscanf(resp, "HTTP/%*s %d", &code);

    // Check if the response code indicates success (2xx)
    if (code >= 200 && code < 300) {
        // Find the start of the response body (after headers)
        char *body = strstr(resp, "\r\n\r\n");
        if (body) {
            body += 4; // Move pointer past the header delimiter

            // Parse the JSON body
            auto parsed = json::parse(body, nullptr, false);

            // If parsing was successful, print the collections list
            if (!parsed.is_discarded()) {
                print_collections_list(parsed);
            }
            // If parsing failed, print an error message
            else {
                std::cout << "ERROR: No library access\n";
            }
        }
        // If no body found, print an error message
        else {
            std::cout << "ERROR: No library access\n";
        }
    } else {
        // If HTTP code is not 2xx, print an error message
        std::cout << "ERROR: No library access\n";
    }

    // Free the allocated memory for the request and response
    free(req);
    free(resp);
}

// Retrieves and displays details for a specific collection by its ID.
void get_collection(char *hostIp,
                    int sockfd,
                    std::vector<char *> &user_cookies,
                    char *token)
{
    // Prompt the user for the collection ID
    std::cout << "id=" << std::flush;
    std::string id;
    std::getline(std::cin, id);

    // Build the endpoint URL for the GET request
    std::string endpoint = std::string(COLLECTIONS) + "/" + id;

    // Build and send the GET request to the server
    char *request = compute_get_request(
        hostIp,
        (char *)endpoint.c_str(),
        nullptr,
        user_cookies,
        static_cast<int>(user_cookies.size()),
        token
    );
    send_to_server(sockfd, request);

    // Receive the response from the server
    char *response = receive_from_server(sockfd);
    close_connection(sockfd);

    int status = 0;
    // Parse the HTTP status code from the response
    sscanf(response, "HTTP/%*s %d", &status);

    if (status >= 200 && status < 300) {
        // Find the start of the response body (after headers)
        char *body = strstr(response, "\r\n\r\n");
        if (body) {
            body += 4;
            // Find the first '{' to skip any extra text before JSON
            char *json_ptr = strchr(body, '{');
            if (!json_ptr) {
                std::cout << "ERROR: Invalid response\n";
            } else {
                // Parse the JSON body
                auto parsed = json::parse(json_ptr, nullptr, false);
                if (parsed.is_discarded()) {
                    std::cout << "ERROR: Invalid response\n";
                } else {
                    // Print collection details
                    std::cout << "SUCCESS: Collection details\n";
                    std::cout << "title: " << parsed.value("title", "") << "\n";
                    std::cout << "owner: " << parsed.value("owner", "") << "\n";
                    // Print movies in the collection, if any
                    if (parsed.contains("movies") && parsed["movies"].is_array()) {
                        for (const auto &movie : parsed["movies"]) {
                            int mid = movie.value("id", -1);
                            std::string mtitle = movie.value("title", "");
                            std::cout << "#" << mid << ": " << mtitle << "\n";
                        }
                    }
                }
            }
        } else {
            std::cout << "ERROR: Invalid response\n";
        }
    } else if (status == 404) {
        std::cout << "ERROR: Invalid ID\n";
    } else {
        std::cout << "ERROR: No library access\n";
    }

    // Free allocated memory for request and response
    free(request);
    free(response);
}


// Deletes a collection by its ID.
// Prompts the user for the collection ID, sends a DELETE request, and prints the result.
void delete_collection(char *hostIp,
                      int sockfd,
                      std::vector<char *> &user_cookies,
                      char *token)
{
    // Prompt for collection ID
    std::cout << "id=" << std::flush;
    std::string collection_id;
    std::getline(std::cin, collection_id);

    // Validate input
    if (collection_id.empty()) {
        std::cout << "ERROR: Invalid ID\n";
        return;
    }

    // Build endpoint for DELETE request
    std::string endpoint = std::string(COLLECTIONS) + "/" + collection_id;

    // Build and send DELETE request
    char *request = compute_delete_request(
        hostIp,
        (char *)endpoint.c_str(),
        user_cookies,
        static_cast<int>(user_cookies.size()),
        token
    );
    send_to_server(sockfd, request);

    // Receive and process response
    char *response = receive_from_server(sockfd);
    close_connection(sockfd);

    int status_code = 0;
    sscanf(response, "HTTP/%*s %d", &status_code);

    // Output result based on HTTP status code
    if (status_code >= 200 && status_code < 300) {
        std::cout << "SUCCESS: Deleted collection\n";
    } else if (status_code == 404) {
        std::cout << "ERROR: Invalid ID\n";
    } else {
        std::cout << "ERROR: No library access\n";
    }

    // Free allocated memory
    free(request);
    free(response);
}


void add_movie_to_collection(char *hostIp,
                             int sockfd,
                             std::vector<char *> &user_cookies,
                             char *token)
{
    std::string collection_id, movie_id;
    std::cout << "collection_id=";
    std::getline(std::cin, collection_id);
    std::cout << "movie_id=";
    std::getline(std::cin, movie_id);

    // Validate input: must be non-empty and numeric
    auto is_number = [](const std::string &s) {
        return !s.empty() && std::all_of(s.begin(), s.end(), ::isdigit);
    };
    if (!is_number(collection_id) || !is_number(movie_id)) {
        std::cout << "ERROR: Invalid/Incomplete data\n";
        return;
    }

    // Prepare endpoint and JSON payload for the movie to add
    std::ostringstream endpoint;
    endpoint << "/api/v1/tema/library/collections/" << collection_id << "/movies";
    json payload_json = { {"id", std::stoi(movie_id)} };
    std::string payload_str = payload_json.dump();
    char *payload_c = strdup(payload_str.c_str());

    // Build and send POST request to add the movie to the collection
    char *req = compute_post_request(
        hostIp,
        (char *)endpoint.str().c_str(),
        (char *)PAYLOAD_TYPE,
        &payload_c,
        1,
        user_cookies,
        static_cast<int>(user_cookies.size()),
        token
    );
    send_to_server(sockfd, req);

    // Receive and process response from the server
    char *resp = receive_from_server(sockfd);
    close_connection(sockfd);

    int status = 0;
    sscanf(resp, "HTTP/%*s %d", &status);

    // Output result based on HTTP status code
    if (status >= 200 && status < 300) {
        std::cout << "SUCCESS: Movie added to collection\n";
    } else if (status == 400) {
        std::cout << "ERROR: Invalid/Incomplete data\n";
    } else if (status == 403) {
        std::cout << "ERROR: You are not an owner\n";
    } else {
        std::cout << "ERROR: No library access\n";
    }

    // Free allocated memory
    free(req);
    free(resp);
    free(payload_c);
}

void delete_movie_from_collection(char *hostIp,
                                  int sockfd,
                                  std::vector<char *> &user_cookies,
                                  char *token)
{
    std::string collection_id, movie_id;
    std::cout << "collection_id=";
    std::getline(std::cin, collection_id);
    std::cout << "movie_id=";
    std::getline(std::cin, movie_id);

    // Validate input: must be non-empty and numeric
    auto is_number = [](const std::string &s) {
        return !s.empty() && std::all_of(s.begin(), s.end(), ::isdigit);
    };
    if (!is_number(collection_id) || !is_number(movie_id)) {
        std::cout << "ERROR: Invalid/Incomplete data\n";
        return;
    }

    // Build endpoint URL for DELETE request
    std::ostringstream endpoint;
    endpoint << "/api/v1/tema/library/collections/" << collection_id << "/movies/" << movie_id;

    // Build and send DELETE request to remove the movie from the collection
    char *req = compute_delete_request(
        hostIp,
        (char *)endpoint.str().c_str(),
        user_cookies,
        static_cast<int>(user_cookies.size()),
        token
    );
    send_to_server(sockfd, req);

    // Receive and process response from the server
    char *resp = receive_from_server(sockfd);
    close_connection(sockfd);

    int status = 0;
    sscanf(resp, "HTTP/%*s %d", &status);

    // Output result based on HTTP status code
    if (status >= 200 && status < 300) {
        std::cout << "SUCCESS: Deleted movie from collection\n";
    } else if (status == 400) {
        std::cout << "ERROR: Invalid/Incomplete data\n";
    } else if (status == 403) {
        std::cout << "ERROR: You are not an owner\n";
    } else {
        std::cout << "ERROR: No library access\n";
    }

    // Free allocated memory for request and response
    free(req);
    free(resp);
}

void logout(char *hostIp, int sockfd, std::vector<char *> &user_cookies, char *token)
{
    // If not logged in, treat as successful logout (stateless logout)
    if (user_cookies.empty()) {
        std::cout << "SUCCESS: User logged out" << std::endl;
        if (token) {
            free(token);
            token = nullptr;
        }
        return;
    }

    // Prepare and send logout request to the server
    char *request = compute_get_request(
        hostIp,
        LOGOUT_USER,
        nullptr,
        user_cookies,
        static_cast<int>(user_cookies.size()),
        nullptr
    );
    send_to_server(sockfd, request);

    // Receive response and close connection
    char *response = receive_from_server(sockfd);
    close_connection(sockfd);

    int status = 0;
    sscanf(response, "HTTP/%*s %d", &status);

    // Check HTTP status code for logout success
    if (status >= 200 && status < 300) {
        std::cout << "SUCCESS: User logged out" << std::endl;
        // Free all user cookies after successful logout
        for (char *cookie : user_cookies) {
            free(cookie);
        }
        user_cookies.clear();
    } else {
        std::cout << "ERROR: Logout failed" << std::endl;
    }

    free(request);
    free(response);
}


// Helper function to clear user session cookies and token
void clear_user_session(std::vector<char *> &user_cookies, char *&token)
{
    // Free all user cookies
    for (char *cookie : user_cookies) {
        free(cookie);
    }
    user_cookies.clear();

    // Free the JWT token if it exists
    if (token) {
        free(token);
        token = nullptr;
    }
}


int main(int argc, char *argv[])
{
    char *hostIp = (char *)"63.32.125.183";
    std::vector<char *> user_cookies;
    std::vector<char *> admin_cookies;
    char *token = nullptr;
    std::string command;
    int sockfd;

    while (true) {
        sockfd = open_connection(hostIp, PORT, AF_INET, SOCK_STREAM, 0);
        std::getline(std::cin, command);

        if (command == "exit") {
            close_connection(sockfd);
            break;
        } else if (command == "login_admin") {
            login_admin(sockfd, admin_cookies, hostIp);
        } else if (command == "add_user") {
            add_user(sockfd, admin_cookies, hostIp);
        } else if (command == "get_users") {
            get_users(sockfd, admin_cookies, hostIp);
        } else if (command == "delete_user") {
            delete_user(sockfd, admin_cookies, hostIp, token);
            clear_user_session(user_cookies, token);
        } else if (command == "logout_admin") {
            logout_admin(hostIp, admin_cookies);
        } else if (command == "login") {
            login(sockfd, admin_cookies, user_cookies, hostIp);
        } else if (command == "get_access") {
            get_access(hostIp, user_cookies, &token);
        } else if (command == "logout") {
            logout(hostIp, sockfd, user_cookies, token);
        } else if (command == "add_movie_to_collection") {
            add_movie_to_collection(hostIp, sockfd, user_cookies, token);
        } else if (command == "add_movie") {
            add_movie(hostIp, sockfd, token, user_cookies);
        } else if (command == "get_movies") {
            get_movies(sockfd, user_cookies, token, hostIp);
        } else if (command == "get_movie") {
            get_movie(sockfd, user_cookies, token, hostIp);
        } else if (command == "update_movie") {
            update_movie(hostIp, sockfd, token, user_cookies);
        } else if (command == "delete_movie_from_collection") {
            delete_movie_from_collection(hostIp, sockfd, user_cookies, token);
        } else if (command == "delete_movie") {
            delete_movie(sockfd, user_cookies, token, hostIp);
        } else if (command == "add_collection") {
            add_collection(hostIp, sockfd, user_cookies, token);
        } else if (command == "get_collections") {
            get_collections(hostIp, sockfd, user_cookies, token);
        } else if (command == "get_collection") {
            get_collection(hostIp, sockfd, user_cookies, token);
        } else if (command == "delete_collection") {
            delete_collection(hostIp, sockfd, user_cookies, token);
        }
    }
    // Free any remaining cookies and token
    for (auto c : user_cookies) free(c);
    for (auto c : admin_cookies) free(c);
    if (token) free(token);
    return 0;
}