#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MIN(X, Y) (((X) < (Y)) ? (X) : (Y))
#define MAX(X, Y) (((X) > (Y)) ? (X) : (Y))
typedef struct {
    long long min;
    long long max;
} tuple;


tuple* remove_element(tuple* arr,int i,int* len) {
    for (int j = i; j<*len; j++) {
        arr[j] = arr[j+1];

    }
    arr = realloc(arr, (*len-1)*sizeof(tuple));
    (*len)--;
    return arr;

}



int main(int argc, char* argv[]) {

    tuple* limits_arr = NULL;
    int limits_arr_len = 0;

    FILE* f = NULL;
    ssize_t nread = 0;
    size_t size = 0;
    char* line = NULL;
    long long start;
    long long end;
    long long ingridient;
    int fresh_ingridients = 0;
    int fresh = 0;
    unsigned long long total_fresh_num = 0;

    f = fopen(argv[1], "r");

    while ((nread = getline(&line, &size, f)) > 1) {
        printf("%s",line);

        // add to the list of min and max values in typle format
        //
        start = atoll(strsep(&line, "-"));
        end = atoll(strsep(&line, "-"));
        int add_new_entry = 1;

        //check overlaps ~ish~ if new range is bridging two other ranges it still results in overlaps.
        //however reduces the original amount of ranges.
        if (limits_arr_len>0) {
            for (int i = 0; i<limits_arr_len; i++) {
                if (start<=limits_arr[i].max && start >= limits_arr[i].min) {
                    //[a,start,b],end
                    // if
                    if (end >= limits_arr[i].max) {
                        limits_arr[i].max = end;
                        add_new_entry = 0;
                        break;
                    } else {
                        add_new_entry = 0;
                        break;
                    }

                } else if (start < limits_arr[i].min) {
                    if (end > limits_arr[i].max) {
                        limits_arr[i].max = end;
                        limits_arr[i].min = start;
                        add_new_entry = 0;
                        break;
                    } else if (end<=limits_arr[i].max && end >= limits_arr[i].min) {
                        limits_arr[i].min = start;
                        add_new_entry = 0;
                        break;
                    } 
                }
            }
        }
        if (add_new_entry) {
            limits_arr_len++;
            limits_arr = realloc(limits_arr, limits_arr_len*sizeof(tuple));

            limits_arr[limits_arr_len-1].min = start;
            limits_arr[limits_arr_len-1].max = end;
        }
    }


    // behold, as i am about to write the worst overlap search algorithm known to humankind.
    int large_repeat = 0;

    do {

        large_repeat = 0;
        // as long as we do mergets, we run the whole thing again.

        for (int i = 0; i<limits_arr_len; i++) { // limit_arr_len will be changing as this goes i have no idea if this is optimal
            start = limits_arr[i].min;
            end = limits_arr[i].max;
            int repeat = 0; // if a merge happened, we will set repeat to true, and so will run the cycle again to check for new overlaps
            do {
                repeat = 0;
                for (int j = i+1; j<limits_arr_len; j++) {
                    //this is horrible
                    // we go over every entry in limit_arr.
                    // if another entry has one of the ends inside, we set the other end equal to the appropriate value, whichever gives the largest range. 
                    // then delete it. 
                    if (limits_arr[j].min >= start && limits_arr[j].min <= end) {
                        limits_arr[i].max = MAX(end, limits_arr[j].max);
                        limits_arr = remove_element(limits_arr, j, &limits_arr_len);
                        repeat = 1;
                        large_repeat = 1;
                        j--;
                    }
                    else if (limits_arr[j].max >= start && limits_arr[j].max <= end) {
                        limits_arr[i].min = MIN(start, limits_arr[j].min);
                        limits_arr = remove_element(limits_arr, j, &limits_arr_len);
                        repeat = 1;
                        large_repeat = 1;
                        j--;
                    }
                    else if (limits_arr[j].min <= start && limits_arr[j].max >= end) {
                        limits_arr[i] = limits_arr[j];
                        limits_arr = remove_element(limits_arr, j, &limits_arr_len);
                        repeat = 1;
                        large_repeat = 1;
                        j--;
                    }
                }
            }while (repeat);
        }


    }while(large_repeat);






    for (int i = 0; i<limits_arr_len; i++) {
        total_fresh_num += limits_arr[i].max - limits_arr[i].min +1;
        printf("min %lld, max %lld, num: %lld\n",limits_arr[i].min,limits_arr[i].max,(limits_arr[i].max - limits_arr[i].min +1));
    }

    //not we go through ingridients

    while ((nread = getline(&line, &size, f)) != -1) {
        printf("%s",line);
        fresh = 0;
        ingridient = atoll(line);
        for (int i = 0; i<limits_arr_len; i++) {
            if (ingridient >= limits_arr[i].min && ingridient <= limits_arr[i].max) {
                fresh= 1; 
                fresh_ingridients++;
                //               printf("ingridient %lld is fresh in range %lld-%lld\n", ingridient,limits_arr[i].min,limits_arr[i].max);
                break;
            }
        }

    }



    printf("total %d fresh ingridients",fresh_ingridients);
    printf("total fresh ingridients possible: %lld\n",total_fresh_num);

    free(limits_arr);

    free(f);
    free(line);


    return 0;
}