aoc day11

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

size_t file_size(FILE *f) {
    size_t curr_pos = ftell(f);
    fseek(f, 0, SEEK_END);
    size_t size = ftell(f);
    fseek(f, curr_pos, SEEK_SET);

    return size;
}

size_t read_file(const char *filepath, char **buf) {
    size_t fsize = 0;

    FILE *f = fopen(filepath, "r");
    if (f) {
        fsize = file_size(f);

        *buf = malloc(fsize + 1);
        if (!buf) return fsize;

        fread(*buf, fsize, 1, f);
        fclose(f);
    }

    return fsize;
}

typedef struct Octos {
    size_t rows;
    size_t cols;
    int *energy;
} Octos;

int* octos_energy(const Octos *octos, size_t row, size_t col) {
    return &octos->energy[row * octos->cols + col];
}

void octos_print(const Octos *octos) {
    for (int row = 0; row < octos->rows; ++row) {
        for (int col = 0; col < octos->cols; ++col) {
            int *value = octos_energy(octos, row, col);
            printf("%d", *value);
        }

        printf("\n");
    }
}

void octos_update_energy(Octos *octos, size_t col, size_t row) {
    for (int drow = -1; drow <= 1; ++drow) {
        for (int dcol = -1; dcol <= 1; ++dcol) {
            if (dcol == 0 && drow == 0) continue;

            int nrow = row + drow;
            int ncol = col + dcol;

            if (0 < nrow < octos->rows && 0 < ncol < octos->cols) {
                int *value = octos_energy(octos, nrow, ncol);
                (*value)++;

                if (*value == 10) octos_update_energy(octos, ncol, nrow);
            }
        }
    }
}

size_t octos_next_step(Octos *octos) {
    size_t flashes = 0;

    for (int row = 0; row < octos->rows; ++row) {
        for (int col = 0; col < octos->cols; ++col) {
            int *value = octos_energy(octos, row, col);
            (*value)++;
            if (*value == 10) octos_update_energy(octos, col, row);
        }
    }


    for (int i = 0; i < (octos->rows * octos->cols); ++i) {
        if (octos->energy[i] > 9) {
            octos->energy[i] = 0;
            flashes++;
        }
    }

    return flashes;
}

int main(int argc, char* argv[argc+1]) {
    if (argc < 2) return 1;

    char *inputfile = argv[1];

    char *data;
    size_t data_len = read_file(inputfile, &data);
    if (data_len == 0) return 1;

    size_t cols = strchr(data, '\n') - data;
    size_t rows = data_len / (cols + 1);

    int array[rows][cols];
    for (int row = 0; row < rows; ++row)
        for (int col = 0; col < cols; ++col)
            array[row][col] = data[row * (cols + 1) + col] - '0';

    free(data);

    Octos octos = {
        .rows = rows,
        .cols = cols,
        .energy = (int *)array,
    };

    octos_print(&octos);

    size_t flashes = 0;
    for (int i = 1; i < 10; ++i) {
        printf("\nStep %d:\n", i);
        flashes += octos_next_step(&octos);
        octos_print(&octos);
    }

    printf("\n%lu\n", flashes);


    return 0;
}