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

#define MIN_MATCH 3
#define MAX_MATCH 258   
#define WS_SMALL 511    
#define WS_LARGE 16383  

#define HASH_SIZE 65536
#define HASH_MASK (HASH_SIZE - 1)

// v1.4 Block Segmentation Threshold
#define BLOCK_SIZE 65536 // 64 KB Block Chunks

// ============================================================================
// INTEGRITY ANCHOR (HONORING MARK ADLER)
// ============================================================================
uint32_t calcular_adler32(const uint8_t *data, size_t len) {
    uint32_t a = 1, b = 0;
    for (size_t i = 0; i < len; i++) {
        a = (a + data[i]) % 65521;
        b = (b + a) % 65521;
    }
    return (b << 16) | a;
}

// ============================================================================
// IN-MEMORY BIT-STREAM ENGINE (REFRACTORED FOR BLOCK BUFFERING)
// ============================================================================
typedef struct {
    uint8_t *buf;
    size_t cap;
    size_t bit_pos; 
} MemBitStream;

void mbs_init(MemBitStream *stream, uint8_t *buffer, size_t capacity) {
    stream->buf = buffer;
    stream->cap = capacity;
    stream->bit_pos = 0;
    memset(buffer, 0, capacity);
}

void mbs_write_bit(MemBitStream *stream, int bit) {
    size_t byte_idx = stream->bit_pos / 8;
    int bit_idx = 7 - (int)(stream->bit_pos % 8);
    if (byte_idx >= stream->cap) return; 
    
    if (bit) {
        stream->buf[byte_idx] |= (1 << bit_idx);
    } else {
        stream->buf[byte_idx] &= ~(1 << bit_idx);
    }
    stream->bit_pos++;
}

void mbs_write_bits(MemBitStream *stream, uint32_t value, int n) {
    for (int i = n - 1; i >= 0; i--) {
        mbs_write_bit(stream, (value >> i) & 1);
    }
}

// Global File Bit Readers
uint8_t file_bit_buf;
int file_bit_cnt = 0;

void fbr_init() { file_bit_buf = 0; file_bit_cnt = 0; }

int fbr_read_bit(FILE *f) {
    if (file_bit_cnt == 0) {
        int c = fgetc(f);
        if (c == EOF) return 0;
        file_bit_buf = (uint8_t)c;
        file_bit_cnt = 8;
    }
    file_bit_cnt--;
    return (file_bit_buf >> file_bit_cnt) & 1;
}

uint32_t fbr_read_bits(FILE *f, int n) {
    uint32_t v = 0;
    for (int i = 0; i < n; i++) { v = (v << 1) | fbr_read_bit(f); }
    return v;
}

// ============================================================================
// GAILLY-BASED HASH ENGINE
// ============================================================================
static inline uint32_t quick_hash(const uint8_t *ptr) {
    return ((ptr[0] << 8) ^ (ptr[1] << 4) ^ ptr[2]) & HASH_MASK;
}

int find_match_v14(uint8_t *in, uint64_t global_pos, uint64_t block_start, uint64_t block_end, 
                   int *head, int *prev, int *best_off, int *use_large) {
    int best_len_s = 0, best_off_s = 0;
    int best_len_l = 0, best_off_l = 0;
    
    uint64_t max = block_end - global_pos > MAX_MATCH ? MAX_MATCH : block_end - global_pos; 
    if (max < MIN_MATCH) return 0;

    uint32_t h = quick_hash(&in[global_pos]);
    int i = head[h];
    
    int chain_count = 0;
    while (i != -1 && chain_count++ < 256) {
        uint64_t match_pos = (uint64_t)i;
        uint64_t distance = global_pos - match_pos;
        
        if (distance > WS_LARGE) break; 
        
        if (in[match_pos + best_len_s] == in[global_pos + best_len_s] || 
            in[match_pos + best_len_l] == in[global_pos + best_len_l]) {
            
            int l = 0;
            while (l < (int)max && in[match_pos + l] == in[global_pos + l]) { l++; }
            
            if (distance <= WS_SMALL && l >= MIN_MATCH && l > best_len_s) {
                best_len_s = l;
                best_off_s = (int)distance;
            }
            if (l >= MIN_MATCH && l > best_len_l) {
                best_len_l = l;
                best_off_l = (int)distance;
            }
        }
        i = prev[match_pos & WS_LARGE]; 
    }

    if (best_len_s < MIN_MATCH && best_len_l < MIN_MATCH) return 0;

    if (best_len_s < MIN_MATCH) {
        *best_off = best_off_l; *use_large = 1; return best_len_l;
    }
    if (best_len_l < MIN_MATCH) {
        *best_off = best_off_s; *use_large = 0; return best_len_s;
    }

    if (((best_len_l - best_len_s) * 9) > 5) { 
        *best_off = best_off_l; *use_large = 1; return best_len_l;
    } else {
        *best_off = best_off_s; *use_large = 0; return best_len_s;
    }
}

// ============================================================================
// COMPRESSION ROUTINE WITH STORED BLOCK ESCAPE
// ============================================================================
int executar_compressao(const char* entrada, const char* saida) {
    FILE *fin = fopen(entrada, "rb"); 
    if (!fin) { printf("Error opening input payload.\n"); return 1; }
    
    fseek(fin, 0, SEEK_END); 
    uint64_t total_len = ftell(fin); 
    fseek(fin, 0, SEEK_SET); 
    
    uint8_t *buf = malloc(total_len); 
    if (!buf && total_len > 0) { printf("Memory allocation failure.\n"); fclose(fin); return 1; }
    fread(buf, 1, total_len, fin); 
    fclose(fin);

    uint32_t checksum = calcular_adler32(buf, total_len);

    FILE *fout = fopen(saida, "wb"); 
    if (!fout) { printf("Error creating compressed file.\n"); free(buf); return 1; }
    
    // Write Global 12-Byte Header
    fwrite(&total_len, sizeof(uint64_t), 1, fout);       
    fwrite(&checksum, sizeof(uint32_t), 1, fout);  

    int *head = malloc(HASH_SIZE * sizeof(int));
    int *prev = malloc((WS_LARGE + 1) * sizeof(int));
    uint8_t *comp_block_buf = malloc(BLOCK_SIZE * 3); 
    
    for (int i = 0; i < HASH_SIZE; i++) head[i] = -1;
    for (int i = 0; i <= WS_LARGE; i++) prev[i] = -1;

    uint64_t global_p = 0;
    uint8_t current_out_byte = 0;
    int current_out_bits = 0;
    
    void write_file_bit(int bit) {
        current_out_byte = (current_out_byte << 1) | (bit & 1);
        if (++current_out_bits == 8) {
            fputc(current_out_byte, fout);
            current_out_byte = 0;
            current_out_bits = 0;
        }
    }

    while (global_p < total_len) {
        uint64_t block_start = global_p;
        uint64_t block_end = block_start + BLOCK_SIZE;
        if (block_end > total_len) block_end = total_len;
        uint16_t block_raw_len = (uint16_t)(block_end - block_start);

        MemBitStream mbs;
        mbs_init(&mbs, comp_block_buf, BLOCK_SIZE * 3);

        uint64_t internal_p = block_start;
        while (internal_p < block_end) {
            int off = 0, use_large = 0, ml = 0;
            if (internal_p + MIN_MATCH <= block_end) {
                ml = find_match_v14(buf, internal_p, block_start, block_end, head, prev, &off, &use_large);
            }

            if (ml >= MIN_MATCH) {
                int bits_offset = use_large ? 14 : 9;
                int custo_token = (ml >= 10) ? (1 + 1 + 3 + bits_offset + 8) : (1 + 1 + 3 + bits_offset);
                if (custo_token < (ml * 9)) {
                    mbs_write_bit(&mbs, 1);
                    mbs_write_bit(&mbs, use_large);
                    if (ml < 10) mbs_write_bits(&mbs, ml - 3, 3);
                    else mbs_write_bits(&mbs, 7, 3);
                    
                    mbs_write_bits(&mbs, off, bits_offset);
                    if (ml >= 10) mbs_write_bits(&mbs, ml - 3, 8);

                    for (int k = 0; k < ml; k++) {
                        if (internal_p + MIN_MATCH <= total_len) {
                            uint32_t h = quick_hash(&buf[internal_p]);
                            prev[internal_p & WS_LARGE] = head[h];
                            head[h] = (int)internal_p;
                        }
                        internal_p++;
                    }
                    continue;
                }
            }
            mbs_write_bit(&mbs, 0);
            mbs_write_bits(&mbs, buf[internal_p], 8);
            if (internal_p + MIN_MATCH <= total_len) {
                uint32_t h = quick_hash(&buf[internal_p]);
                prev[internal_p & WS_LARGE] = head[h];
                head[h] = (int)internal_p;
            }
            internal_p++;
        }

        size_t total_bits_used = mbs.bit_pos;
        size_t total_bytes_used = (total_bits_used + 7) / 8;

        if (total_bytes_used < block_raw_len) {
            write_file_bit(1);
            for (int b = 15; b >= 0; b--) write_file_bit((total_bytes_used >> b) & 1);
            
            for (size_t bit_idx = 0; bit_idx < total_bits_used; bit_idx++) {
                size_t byte_pos = bit_idx / 8;
                int bit_pos = 7 - (int)(bit_idx % 8);
                write_file_bit((comp_block_buf[byte_pos] >> bit_pos) & 1);
            }
        } else {
            write_file_bit(0);
            for (int b = 15; b >= 0; b--) write_file_bit((block_raw_len >> b) & 1);
            
            if (current_out_bits > 0) {
                current_out_byte <<= (8 - current_out_bits);
                fputc(current_out_byte, fout);
                current_out_byte = 0;
                current_out_bits = 0;
            }
            fwrite(&buf[block_start], 1, block_raw_len, fout);
        }
        global_p = block_end;
    }

    if (current_out_bits > 0) {
        current_out_byte <<= (8 - current_out_bits);
        fputc(current_out_byte, fout);
    }

    fclose(fout); free(buf); free(head); free(prev); free(comp_block_buf);
    printf("LZSS v1.4 Failsafe Block Segmentation engine complete.\n");
    return 0;
}

// ============================================================================
// DECOMPRESSION ROUTINE WITH BLOCK PARSING
// ============================================================================
int executar_descompressao(const char* entrada, const char* saida) {
    FILE *fin = fopen(entrada, "rb");
    if (!fin) { printf("Error opening compressed file.\n"); return 1; }

    uint64_t total_original_len = 0;
    uint32_t checksum_original = 0;
    
    if (fread(&total_original_len, sizeof(uint64_t), 1, fin) != 1 ||
        fread(&checksum_original, sizeof(uint32_t), 1, fin) != 1) {
        printf("Header processing fault.\n"); fclose(fin); return 1;
    }

    uint8_t *out_buf = malloc(total_original_len);
    if (!out_buf && total_original_len > 0) { printf("Memory bounds allocation fault.\n"); fclose(fin); return 1; }

    fbr_init();
    uint64_t global_p = 0;

    while (global_p < total_original_len) {
        int block_type = fbr_read_bit(fin); 
        uint16_t block_size_marker = (uint16_t)fbr_read_bits(fin, 16);

        if (block_type == 1) {
            uint64_t bits_end_pos = (ftell(fin) * 8) - file_bit_cnt + (block_size_marker * 8);
            
            while (global_p < total_original_len) {
                uint64_t current_bit_pos = (ftell(fin) * 8) - file_bit_cnt;
                if (current_bit_pos >= bits_end_pos) break;

                int flag = fbr_read_bit(fin);
                if (flag == 0) {
                    out_buf[global_p++] = (uint8_t)fbr_read_bits(fin, 8);
                } else {
                    int use_large = fbr_read_bit(fin);
                    int bits_offset = use_large ? 14 : 9;
                    uint32_t len_code = fbr_read_bits(fin, 3);
                    uint32_t offset = fbr_read_bits(fin, bits_offset);

                    // Underflow prevention guard [📑]
                    if (offset > global_p) {
                        printf("CRITICAL DECOMPRESSION GUARD: Pointer underflow blocked!\n");
                        free(out_buf);
                        fclose(fin);
                        return 1;
                    }

                    uint32_t ml = (len_code < 7) ? (len_code + 3) : (fbr_read_bits(fin, 8) + 3);
                    uint64_t start_pos = global_p - offset;
                    for (uint32_t i = 0; i < ml; i++) {
                        if (global_p >= total_original_len) break;
                        out_buf[global_p] = out_buf[start_pos + i];
                        global_p++;
                    }
                }
            }
            fbr_init();
        } else {
            fbr_init(); 
            if (global_p + block_size_marker <= total_original_len) {
                fread(&out_buf[global_p], 1, block_size_marker, fin);
                global_p += block_size_marker;
            } else {
                break;
            }
        }
    }
    fclose(fin);

    uint32_t checksum_calculado = calcular_adler32(out_buf, total_original_len);
    int sucesso = (checksum_original == checksum_calculado);

    if (sucesso) {
        FILE *fout = fopen(saida, "wb");
        if (!fout) { printf("Output execution crash.\n"); free(out_buf); return 1; }
        fwrite(out_buf, 1, total_original_len, fout);
        fclose(fout);
        printf("Decompression Complete. Status: 100%% INTEGRAL (Adler-32 Checked).\n");
    } else {
        printf("CRITICAL VALIDATION ERROR: Output payload is corrupted.\n");
    }

    free(out_buf);
    return sucesso ? 0 : 2;
}

int main(int argc, char** argv) {
    if (argc != 4) {
        printf("Usage:\n  Compress:   %s -c <input> <output>\n  Decompress: %s -d <input> <output>\n", argv[0], argv[0]);
        return 1;
    }
    if (strcmp(argv[1], "-c") == 0) return executar_compressao(argv[2], argv[3]);
    if (strcmp(argv[1], "-d") == 0) return executar_descompressao(argv[2], argv[3]);
    printf("Invalid layout mode.\n");
    return 1;
}