f1_driver_analyzer.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <curl/curl.h>
#include "cJSON.h"

typedef struct {
    char *data;
    size_t size;
} Memory;

typedef struct {
    int session_key;
    char country_name[64];
    char date_start[64];
} SessionInfo;

typedef struct {
    char race_name[64];
    int position;
} RaceResult;

size_t write_callback(void *contents, size_t size, size_t nmemb, void *userp) {
    size_t real_size = size * nmemb;
    Memory *mem = (Memory *)userp;

    char *ptr = realloc(mem->data, mem->size + real_size + 1);
    if (!ptr) {
        return 0;
    }

    mem->data = ptr;
    memcpy(mem->data + mem->size, contents, real_size);
    mem->size += real_size;
    mem->data[mem->size] = '\0';

    return real_size;
}

int fetch_api(const char *url, Memory *chunk) {
    CURL *curl = curl_easy_init();
    if (!curl) {
        printf("Curl init failed.\n");
        return 0;
    }

    chunk->data = malloc(1);
    chunk->size = 0;

    if (!chunk->data) {
        curl_easy_cleanup(curl);
        return 0;
    }

    chunk->data[0] = '\0';

    curl_easy_setopt(curl, CURLOPT_URL, url);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)chunk);

    CURLcode res = curl_easy_perform(curl);
    curl_easy_cleanup(curl);

    if (res != CURLE_OK) {
        printf("Request failed: %s\n", curl_easy_strerror(res));
        free(chunk->data);
        return 0;
    }

    return 1;
}

void print_bar(int position) {
    int bar_length = 21 - position;   // P1 longest, P20 shortestt
    if (bar_length < 1) bar_length = 1;

    for (int i = 0; i < bar_length; i++) {
        printf("#");
    }
}

void run_driver_analyzer(void) {
    int driver_number, year;
    char url[256];
    Memory chunk;

    printf("Enter driver number: ");
    scanf("%d", &driver_number);

    printf("Enter year (2023+): ");
    scanf("%d", &year);

    if (year < 2023) {
        printf("OpenF1 historical data is available from 2023 onwards only.\n");
        return;
    }

    // gets all race sessions for the selected year
    snprintf(url, sizeof(url),
             "https://api.openf1.org/v1/sessions?year=%d&session_name=Race",
             year);

    if (!fetch_api(url, &chunk)) {
        return;
    }

    cJSON *root = cJSON_Parse(chunk.data);
    if (!root || !cJSON_IsArray(root)) {
        printf("Invalid sessions JSON.\n");
        printf("Raw response:\n%s\n", chunk.data);
        free(chunk.data);
        cJSON_Delete(root);
        return;
    }

    SessionInfo sessions[64];
    int session_count = 0;
    int count = cJSON_GetArraySize(root);

    for (int i = 0; i < count && session_count < 64; i++) {
        cJSON *item = cJSON_GetArrayItem(root, i);
        if (!cJSON_IsObject(item)) continue;

        cJSON *session_key = cJSON_GetObjectItemCaseSensitive(item, "session_key");
        cJSON *country_name = cJSON_GetObjectItemCaseSensitive(item, "country_name");
        cJSON *date_start = cJSON_GetObjectItemCaseSensitive(item, "date_start");

        if (cJSON_IsNumber(session_key) &&
            cJSON_IsString(country_name) &&
            cJSON_IsString(date_start)) {

            sessions[session_count].session_key = session_key->valueint;

            strncpy(sessions[session_count].country_name,
                    country_name->valuestring, 63);
            sessions[session_count].country_name[63] = '\0';

            strncpy(sessions[session_count].date_start,
                    date_start->valuestring, 63);
            sessions[session_count].date_start[63] = '\0';

            session_count++;
        }
    }

    cJSON_Delete(root);
    free(chunk.data);

    if (session_count == 0) {
        printf("No race sessions found for %d.\n", year);
        return;
    }

    // for each race session, get final classification
    RaceResult results[64];
    int result_count = 0;

    for (int i = 0; i < session_count && result_count < 64; i++) {
        snprintf(url, sizeof(url),
                 "https://api.openf1.org/v1/session_result?session_key=%d",
                 sessions[i].session_key);

        if (!fetch_api(url, &chunk)) {
            continue;
        }

        root = cJSON_Parse(chunk.data);
        if (!root || !cJSON_IsArray(root)) {
            free(chunk.data);
            cJSON_Delete(root);
            continue;
        }

        int item_count = cJSON_GetArraySize(root);

        for (int j = 0; j < item_count; j++) {
            cJSON *item = cJSON_GetArrayItem(root, j);
            if (!cJSON_IsObject(item)) continue;

            cJSON *num = cJSON_GetObjectItemCaseSensitive(item, "driver_number");
            cJSON *pos = cJSON_GetObjectItemCaseSensitive(item, "position");

            if (cJSON_IsNumber(num) && cJSON_IsNumber(pos) &&
                num->valueint == driver_number) {

                strncpy(results[result_count].race_name,
                        sessions[i].country_name, 63);
                results[result_count].race_name[63] = '\0';

                results[result_count].position = pos->valueint;
                result_count++;
                break;
            }
        }

        cJSON_Delete(root);
        free(chunk.data);
    }

    if (result_count == 0) {
        printf("No race result data found for driver #%d in %d.\n",
               driver_number, year);
        return;
    }

    // print ascii analysis
    printf("\nDriver Analyzer - Final Race Results\n");
    printf("------------------------------------\n");

    for (int i = 0; i < result_count; i++) {
        printf("%-15s | P%-2d | ", results[i].race_name, results[i].position);
        print_bar(results[i].position);
        printf("\n");
    }
}

int main(void) {
    run_driver_analyzer();
    return 0;
}