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

#define STB_IMAGE_IMPLEMENTATION
#define STBI_FAILURE_USERMSG
#include "stb_image.h"

struct image {
    char* filename;
    unsigned char* image_data;
    int width;
    int height;
    int channels;
};

int main(int argc, char* argv[]) {
    if (argc == 1) {
        fprintf(stderr, "Must provide image files to pack");
        exit(-1);
    }
    if (argc == 2) {
        fprintf(stderr, "Please provide at least 2 images to pack");
        exit(-1);
    }
    struct image* images = calloc(argc - 1, sizeof(struct image));
    if (images == NULL) {
        fprintf(stderr, "Failed to alloc image data array");
        exit(-1);
    }
    //-------------------------------------
    // First get the image info, make sure the file is an image and it exists
    //-------------------------------------
    int image_count = argc - 1;
    for (int i = 0; i < argc - 1; i++) {
        struct image* img = &images[i];
        img->filename = argv[i+1];

        int result = stbi_info(img->filename, &img->width, &img->height, &img->channels);
        if (result != 1) {
            char *errorMsg = "Cannot load image '%s': %s\n";
            fprintf(stderr, errorMsg, img->filename, stbi_failure_reason());
            exit(-1);
        }
    }
    //-------------------------------------
    // Now run the packing algorithm
    // Note: How to get the minimum power of 2 texture size. Note that this is still
    // very inefficient because we're just naively putting them all at 0
    // x = log2(max(width, height)) 
    // width or height = 2 ** (x + 1)
    // This is super inefficient texture packing but I just want to get it working first
    //-------------------------------------

    int totalh = 0, maxw = 0;
    for (int i = 0; i < image_count; i++) {
        totalh += images[i].height;
        if (images[i].width > maxw) {
            maxw = images[i].width;
        }
    }
    int max = totalh > maxw ? totalh : maxw;
    int exp = (int)log2(max) + 1;
    int size = (int)pow(2, exp);
    unsigned char* buf = calloc(size*size, sizeof(char));
    (void)buf;

    //-------------------------------------
    // Now load each texture one by one, write to the new image buffer, and free, before
    // loading the next one
    //-------------------------------------
    for (int i = 0; i < argc - 1; i++) {
        images[i].filename = argv[i+1];

        // int width, height, channels;
        // images[i].image_data = (unsigned char*)stbi_load(images[i].filename,
        //                               &width,
        //                               &height,
        //                               &channels,
        //                               4);

        // images[i].width = (short)width;
        // images[i].height = (short)height;
        // images[i].channels = (char)channels;
        images[i].image_data = (unsigned char*)stbi_load(images[i].filename,
                                      &images[i].width,
                                      &images[i].height,
                                      &images[i].channels,
                                      4);
        if (images[i].image_data == NULL) {
            char *errorMsg = "Could not load data for image '%s': %s";
            fprintf(stderr, errorMsg, images[i].filename, stbi_failure_reason());
            // QUESTION: Should we clean up here?
            exit(-1);
        }
    }
    // unsigned char* image_bytes = images[0].image_data;
    // int b = 0;
    // while (image_bytes) {
    //     if (image_bytes[b]) {
    //         printf("R:%u G:%u B:%u A:%u\n", image_bytes[b], image_bytes[b+1], image_bytes[b+2], image_bytes[b+3]);
    //     }
    //     b += 4;
    //     image_bytes += 4;
    // }
    for (int i = 0; i < image_count; i++) {
        stbi_image_free(images[i].image_data);
    }
    // for (int i = )
    return 0;
}