#include "a_station.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/**
 * Vytvori prazdnu stanicu.
 * Alokuje pole smernikov tracks a inicializuje ich na NULL.
 */
struct station* create_station() {
    struct station* s = malloc(sizeof(struct station));
    if (!s) return NULL;

    s->track_count = STATION_SIZE;
    s->tracks = calloc(s->track_count, sizeof(struct car*)); // všetky položky na NULL
    if (!s->tracks) {
        free(s);
        return NULL;
    }

    return s;
}

/**
 * Uvolni pamat celej databazy (vratane vsetkych spojkovych zoznamov).
 */
void destroy_station(struct station* s) {
    if (!s) return;

    for (int i = 0; i < s->track_count; i++) {
        struct car* current = s->tracks[i];
        while (current) {
            struct car* next = current->next;
            free(current);
            current = next;
        }
    }

    free(s->tracks);
    free(s);
}

/**
 * Jednoducha hash funkcia pre rozdelenie zaznamov do trati.
 * Pouziva variant DJB2 hash algoritmu.
 */
int select_track(struct station* s, const char* target) {
    if (!s || !target) return 0;

    unsigned long hash = 5381;
    int c;
    while ((c = *target++))
        hash = ((hash << 5) + hash) + c; // hash * 33 + c

    return (int)(hash % s->track_count);
}

/**
 * Prida alebo aktualizuje zaznam pre danu cielovu stanicu.
 */
void add_target_capacity(struct station* s, const char* target, int capacity) {
    if (!s || !target || capacity <= 0) return;

    int index = select_track(s, target);
    struct car* current = s->tracks[index];
    struct car* prev = NULL;

    // Skontroluj, ci uz existuje
    while (current) {
        if (strcmp(current->value, target) == 0) {
            current->capacity += capacity;
            return;
        }
        prev = current;
        current = current->next;
    }

    // Ak neexistuje, vytvor novy zaznam
    struct car* new_car = malloc(sizeof(struct car));
    if (!new_car) return;

    strncpy(new_car->value, target, TARGET_SIZE - 1);
    new_car->value[TARGET_SIZE - 1] = '\0';
    new_car->capacity = capacity;
    new_car->next = NULL;

    if (prev)
        prev->next = new_car;
    else
        s->tracks[index] = new_car;
}

/**
 * Ziska kapacitu pre danu stanicu.
 */
int get_target_capacity(struct station* s, const char* target) {
    if (!s || !target) return 0;

    int index = select_track(s, target);
    struct car* current = s->tracks[index];

    while (current) {
        if (strcmp(current->value, target) == 0)
            return current->capacity;
        current = current->next;
    }

    return 0;
}

/**
 * Spocita pocet cielovych stanic (vsetky uzly vo vsetkych tratiach).
 */
int count_targets(struct station* s) {
    if (!s) return 0;

    int count = 0;
    for (int i = 0; i < s->track_count; i++) {
        struct car* current = s->tracks[i];
        while (current) {
            count++;
            current = current->next;
        }
    }

    return count;
}

/**
 * Spocita celkovu kapacitu vsetkych zaznamov.
 */
int count_capacity(struct station* s) {
    if (!s) return 0;

    int sum = 0;
    for (int i = 0; i < s->track_count; i++) {
        struct car* current = s->tracks[i];
        while (current) {
            sum += current->capacity;
            current = current->next;
        }
    }

    return sum;
}