#include "list_ops.h"           
#include <stdlib.h>            
#include <stdbool.h>       

// Vytvorenie nového zoznamu s danou dĺžkou a počiatočnými prvkami
list_t *new_list(size_t length, list_element_t elements[]) {
    // Alokuje pamäť pre štruktúru list a všetky jej prvky
    list_t *list = malloc(sizeof(list_t) + length * sizeof(list_element_t));
    if (list) {
        // Uloží dĺžku zoznamu na začiatok alokovaného bloku
        *((size_t *)&list[0]) = length;
        // Skopíruje prvky do nového zoznamu
        for (size_t i = 0; i < length; ++i) {
            list->elements[i] = elements[i];
        }
    }
    return list; // Vráti ukazovateľ na nový zoznam
}


list_t *append_list(list_t *list1, list_t *list2) {
    // Spočíta celkovú dĺžku oboch zoznamov
    size_t total_length = *((size_t *)&list1[0]) + *((size_t *)&list2[0]);
    // Alokuje pamäť pre nový spojený zoznam
    list_t *result = malloc(sizeof(list_t) + total_length * sizeof(list_element_t));
    if (result) {
        // Nastaví dĺžku výsledného zoznamu
        *((size_t *)&result[0]) = total_length;
        // Skopíruje prvky z prvého zoznamu
        for (size_t i = 0; i < *((size_t *)&list1[0]); ++i) {
            result->elements[i] = list1->elements[i];
        }
        // Skopíruje prvky z druhého zoznamu
        for (size_t i = 0; i < *((size_t *)&list2[0]); ++i) {
            result->elements[*((size_t *)&list1[0]) + i] = list2->elements[i];
        }
    }
    return result; // Vráti spojený zoznam
}


list_t *filter_list(list_t *list, bool (*filter)(list_element_t)) {
    size_t count = 0;
    // Spočíta, koľko prvkov prejde filtrom
    for (size_t i = 0; i < *((size_t *)&list[0]); ++i) {
        if (filter(list->elements[i])) {
            ++count;
        }
    }
    // Alokuje pamäť pre výsledný zoznam s filtrovanými prvkami
    list_t *result = malloc(sizeof(list_t) + count * sizeof(list_element_t));
    if (result) {
        *((size_t *)&result[0]) = count;
        size_t j = 0;
        // Skopíruje iba tie prvky, ktoré prešli filtrom
        for (size_t i = 0; i < *((size_t *)&list[0]); ++i) {
            if (filter(list->elements[i])) {
                result->elements[j++] = list->elements[i];
            }
        }
    }
    return result; 
}


size_t length_list(list_t *list) {
    return *((size_t *)&list[0]); // Na začiatku štruktúry je uložená dĺžka
}


list_t *map_list(list_t *list, list_element_t (*map)(list_element_t)) {
    // Alokuje pamäť pre nový zoznam s rovnakou dĺžkou
    list_t *result = malloc(sizeof(list_t) + *((size_t *)&list[0]) * sizeof(list_element_t));
    if (result) {
        *((size_t *)&result[0]) = *((size_t *)&list[0]);
        // Aplikuje mapovaciu funkciu na každý prvok
        for (size_t i = 0; i < *((size_t *)&list[0]); ++i) {
            result->elements[i] = map(list->elements[i]);
        }
    }
    return result; 
}


list_element_t foldl_list(list_t *list, list_element_t initial, list_element_t (*foldl)(list_element_t, list_element_t)) {
    list_element_t accumulator = initial;
    // Prechádza zoznam zľava doprava
    for (size_t i = 0; i < *((size_t *)&list[0]); ++i) {
        accumulator = foldl(list->elements[i], accumulator);
    }
    return accumulator; // Vráti výsledok foldl operácie
}


list_element_t foldr_list(list_t *list, list_element_t initial, list_element_t (*foldr)(list_element_t, list_element_t)) {
    list_element_t accumulator = initial;
    // Prechádza zoznam sprava doľava
    for (size_t i = *((size_t *)&list[0]); i > 0; --i) {
        accumulator = foldr(list->elements[i - 1], accumulator);
    }
    return accumulator; // Vráti výsledok foldr operácie
}


list_t *reverse_list(list_t *list) {
    // Alokuje pamäť pre nový zoznam
    list_t *result = malloc(sizeof(list_t) + *((size_t *)&list[0]) * sizeof(list_element_t));
    if (result) {
        *((size_t *)&result[0]) = *((size_t *)&list[0]);
        // Skopíruje prvky v opačnom poradí
        for (size_t i = 0; i < *((size_t *)&list[0]); ++i) {
            result->elements[i] = list->elements[*((size_t *)&list[0]) - i - 1];
        }
    }
    return result; 
}


void delete_list(list_t *list) {
    free(list);
}