#include <stdio.h>
#include <stdint.h>
#include <ctype.h>
#include <string.h>

static unsigned char g_bin_data[] = {
    #include "data.bin.h"
};

static unsigned char g_ico_data[] = {
    #include "xmake.ico.h"
};

static unsigned char g_asset_data[] = {
    #include "asset.bin.h"
};

static unsigned char g_asset2_data[] = {
    #include "asset2.bin.h"
};

static void hexdump(const char* name, const uint8_t* data, uint32_t size) {
    printf("%s: size: %u bytes\n", name, (unsigned int)size);
    if (size == 0) {
        return;
    }
    
    // if file is larger than 128 bytes, only dump first 64 and last 64 bytes
    uint32_t dump_size = size;
    uint32_t start_offset = 0;
    uint32_t end_offset = 0;
    uint32_t skip_size = 0;
    
    if (size > 128) {
        dump_size = 64;
        start_offset = 0;
        end_offset = size - 64;
        skip_size = end_offset - start_offset - dump_size;
    }
    
    // dump start
    for (uint32_t offset = start_offset; offset < start_offset + dump_size; offset += 16) {
        // print offset
        printf("%08x  ", (unsigned int)offset);
        
        // print hex bytes (8 bytes, space, 8 bytes)
        for (uint32_t i = 0; i < 16; i++) {
            if (offset + i < size) {
                printf("%02x ", data[offset + i]);
            } else {
                printf("   ");
            }
            if (i == 7) {
                printf(" ");
            }
        }
        
        // print ASCII representation
        printf(" |");
        for (uint32_t i = 0; i < 16 && offset + i < size; i++) {
            uint8_t c = data[offset + i];
            printf("%c", isprint(c) ? c : '.');
        }
        printf("|\n");
    }
    
    // print skip indicator if needed
    if (skip_size > 0) {
        printf("        ... (skipped %u bytes) ...\n", (unsigned int)skip_size);
    }
    
    // dump end if needed
    if (size > 128) {
        for (uint32_t offset = end_offset; offset < size; offset += 16) {
            // print offset
            printf("%08x  ", (unsigned int)offset);
            
            // print hex bytes (8 bytes, space, 8 bytes)
            for (uint32_t i = 0; i < 16; i++) {
                if (offset + i < size) {
                    printf("%02x ", data[offset + i]);
                } else {
                    printf("   ");
                }
                if (i == 7) {
                    printf(" ");
                }
            }
            
            // print ASCII representation
            printf(" |");
            for (uint32_t i = 0; i < 16 && offset + i < size; i++) {
                uint8_t c = data[offset + i];
                printf("%c", isprint(c) ? c : '.');
            }
            printf("|\n");
        }
    }
}

int main(int argc, char** argv)
{
    hexdump("data.bin", g_bin_data, (uint32_t)sizeof(g_bin_data));
    printf("\n");
    hexdump("xmake.ico", g_ico_data, (uint32_t)sizeof(g_ico_data));
    printf("\n");
    hexdump("asset.bin (transformed)", g_asset_data, (uint32_t)sizeof(g_asset_data));
    printf("\n");
    hexdump("asset2.bin (transformed by lua file)", g_asset2_data, (uint32_t)sizeof(g_asset2_data));

    // verify the function transform: asset.bin must be the reverse of "hello transform!" (+ zeroend '\0')
    const char* expected = "!mrofsnart olleh";
    if (sizeof(g_asset_data) != 17 || memcmp(g_asset_data, expected, 16) != 0) {
        printf("asset.bin: transform verification failed!\n");
        return 1;
    }
    printf("asset.bin: transform verification ok\n");

    // verify the lua-file transform: asset2.bin must be the reverse of "hello luafile!" (+ zeroend '\0')
    const char* expected2 = "!elifaul olleh";
    if (sizeof(g_asset2_data) != 15 || memcmp(g_asset2_data, expected2, 14) != 0) {
        printf("asset2.bin: transform verification failed!\n");
        return 1;
    }
    printf("asset2.bin: transform verification ok\n");
    return 0;
}