#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <unistd.h>
#include <fcntl.h>
#include <time.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <ctype.h>
#include <signal.h>
#include <setjmp.h>

static sigjmp_buf jbuf;
static void sigill_handler(int sig){ (void)sig; siglongjmp(jbuf,1); }

static double now_sec(void){
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC,&ts);
    return ts.tv_sec+ts.tv_nsec/1e9;
}

static uint32_t crc32_tab[256];
static void crc32_init(void){
    for(uint32_t i=0;i<256;i++){
        uint32_t c=i;
        for(int j=0;j<8;j++) c = (c&1)?(0xEDB88320^(c>>1)):(c>>1);
        crc32_tab[i]=c;
    }
}
static uint32_t crc32_calc(uint8_t *buf,size_t len){
    uint32_t c=0xFFFFFFFF;
    for(size_t i=0;i<len;i++) c = crc32_tab[(c^buf[i])&0xFF]^(c>>8);
    return c^0xFFFFFFFF;
}

static void analyze_header(uint8_t *data,size_t sz){
    printf("=== Magic Header / Instruction Analysis ===\n");
    if(sz<4){ printf("File too small\n"); return; }
    printf("First 16 bytes: ");
    for(int i=0;i<16 && i<(int)sz;i++) printf("%02X ",data[i]);
    printf("\n");

    if(sz>4 && data[0]==0x7F && data[1]=='E' && data[2]=='L' && data[3]=='F'){
        int ei_class=data[4];
        int ei_data=data[5];
        printf("Format: ELF\n");
        printf("Class: %s\n", ei_class==1?"32-bit":ei_class==2?"64-bit":"Unknown");
        printf("Endianness: %s\n", ei_data==1?"Little Endian":ei_data==2?"Big Endian":"Unknown");
        uint16_t machine;
        memcpy(&machine,data+18,2);
        printf("Machine field: 0x%04X\n", machine);
    } else {
        uint32_t magic_le, magic_be;
        memcpy(&magic_le,data,4);
        magic_be = __builtin_bswap32(magic_le);
        printf("Raw magic LE: 0x%08X\n", magic_le);
        printf("Raw magic BE: 0x%08X\n", magic_be);
        if(magic_be==0x27051956) printf("Detected: Legacy U-Boot image header\n");
        else printf("Format: Raw binary (no standard header detected)\n");

        int lecount=0, becount=0;
        for(size_t i=0;i+4<=sz && i<4096;i+=4){
            uint32_t w; memcpy(&w,data+i,4);
            if((w & 0xFF000000)==0 && (w&0xFF)!=0) lecount++;
            else if((w & 0xFF)==0 && (w&0xFF000000)!=0) becount++;
        }
        printf("Heuristic endianness guess: %s\n", lecount>=becount?"Little Endian likely":"Big Endian likely");
    }
    printf("\n");
}

static void analyze_cache(void){
    printf("=== Cache Availability ===\n");
    long l1d = sysconf(_SC_LEVEL1_DCACHE_SIZE);
    long l1i = sysconf(_SC_LEVEL1_ICACHE_SIZE);
    long l2  = sysconf(_SC_LEVEL2_CACHE_SIZE);
    long l3  = sysconf(_SC_LEVEL3_CACHE_SIZE);
    printf("L1D: %ld bytes\n", l1d>0?l1d:0);
    printf("L1I: %ld bytes\n", l1i>0?l1i:0);
    printf("L2 : %ld bytes\n", l2>0?l2:0);
    printf("L3 : %ld bytes\n", l3>0?l3:0);

    size_t bufsz = 1<<20;
    uint8_t *buf = malloc(bufsz);
    memset(buf,0xAA,bufsz);
    volatile uint64_t sum=0;
    double t0=now_sec();
    for(int r=0;r<50;r++)
        for(size_t i=0;i<bufsz;i+=64) sum+=buf[i];
    double t1=now_sec();
    double mb = (double)bufsz*50/1e6;
    printf("Measured cache/memory touch speed: %.2f MB/s\n", mb/(t1-t0));
    free(buf);
    printf("\n");
}

static void analyze_ram(void){
    printf("=== RAM Speed ===\n");
    size_t sz = 64*1024*1024;
    uint8_t *a = malloc(sz);
    uint8_t *b = malloc(sz);
    memset(a,1,sz);

    double t0=now_sec();
    memcpy(b,a,sz);
    double t1=now_sec();
    printf("Sequential copy (dynamic alloc): %.2f MB/s\n", (sz/1e6)/(t1-t0));

    t0=now_sec();
    for(size_t i=0;i<sz;i++) a[i]=a[i]+1;
    t1=now_sec();
    printf("Sequential R/W (static pattern): %.2f MB/s\n", (sz*2/1e6)/(t1-t0));

    volatile uint8_t x=0;
    t0=now_sec();
    srand(1234);
    size_t iters = 2000000;
    for(size_t i=0;i<iters;i++){
        size_t idx = ((size_t)rand()*rand())%sz;
        x += a[idx];
    }
    t1=now_sec();
    printf("Random access state (RAM latency): %.2f Mops/s\n", (iters/1e6)/(t1-t0));

    free(a); free(b);
    printf("\n");
}

static void analyze_disk(const char *path,size_t filesz){
    (void)path; (void)filesz;
    printf("=== Disk I/O Benchmarks ===\n");
    char tmp[] = "/tmp/profile_disk_XXXXXX";
    int fd = mkstemp(tmp);
    if(fd<0){ perror("mkstemp"); return; }

    size_t block=4096;
    uint8_t *buf = malloc(block);
    memset(buf,0x5A,block);
    size_t iterations = 2000;

    double t0=now_sec();
    for(size_t i=0;i<iterations;i++) write(fd,buf,block);
    fsync(fd);
    double t1=now_sec();
    printf("4K Write: %.2f MB/s\n", (block*iterations/1e6)/(t1-t0));

    lseek(fd,0,SEEK_SET);
    t0=now_sec();
    for(size_t i=0;i<iterations;i++) read(fd,buf,block);
    t1=now_sec();
    printf("4K Read : %.2f MB/s\n", (block*iterations/1e6)/(t1-t0));

    size_t bigblock = 1<<20;
    uint8_t *bigbuf = malloc(bigblock);
    memset(bigbuf,0x3C,bigblock);
    lseek(fd,0,SEEK_SET);
    t0=now_sec();
    for(int i=0;i<50;i++) write(fd,bigbuf,bigblock);
    fsync(fd);
    t1=now_sec();
    printf("Sequential IO Write: %.2f MB/s\n", (bigblock*50/1e6)/(t1-t0));

    lseek(fd,0,SEEK_SET);
    t0=now_sec();
    for(int i=0;i<50;i++) read(fd,bigbuf,bigblock);
    t1=now_sec();
    printf("Sequential IO Read : %.2f MB/s\n", (bigblock*50/1e6)/(t1-t0));

    off_t filelen = (off_t)iterations*block;
    srand(99);
    t0=now_sec();
    for(size_t i=0;i<iterations;i++){
        off_t off = (rand()%(filelen/block))*block;
        lseek(fd,off,SEEK_SET);
        write(fd,buf,block);
    }
    fsync(fd);
    t1=now_sec();
    printf("Random Write: %.2f MB/s\n", (block*iterations/1e6)/(t1-t0));

    t0=now_sec();
    for(size_t i=0;i<iterations;i++){
        off_t off = (rand()%(filelen/block))*block;
        lseek(fd,off,SEEK_SET);
        read(fd,buf,block);
    }
    t1=now_sec();
    printf("Random Read : %.2f MB/s\n", (block*iterations/1e6)/(t1-t0));

    close(fd);
    unlink(tmp);
    free(buf);
    free(bigbuf);
    printf("\n");
}

static unsigned long safe_read_sysreg(const char *name){
    unsigned long val = 0;
    struct sigaction sa, old;
    memset(&sa,0,sizeof(sa));
    sa.sa_handler = sigill_handler;
    sigemptyset(&sa.sa_mask);
    sigaction(SIGILL,&sa,&old);

    if(sigsetjmp(jbuf,1)==0){
#if defined(__aarch64__)
        if(strcmp(name,"tcr_el1")==0){
            __asm__ volatile("mrs %0, tcr_el1" : "=r"(val));
        } else if(strcmp(name,"id_aa64pfr1_el1")==0){
            __asm__ volatile("mrs %0, id_aa64pfr1_el1" : "=r"(val));
        } else if(strcmp(name,"currentel")==0){
            __asm__ volatile("mrs %0, CurrentEL" : "=r"(val));
        }
#else
        (void)name;
#endif
    } else {
        val = (unsigned long)-1;
    }
    sigaction(SIGILL,&old,NULL);
    return val;
}

static void analyze_security(void){
    printf("=== Pointer Tagging / MTE / Exception Levels ===\n");
    FILE *f = fopen("/proc/cpuinfo","r");
    char line[256];
    if(f){
        while(fgets(line,sizeof(line),f)){
            if(strstr(line,"CPU architecture") || strstr(line,"model name"))
                printf("%s", line);
        }
        fclose(f);
    }
#if defined(__aarch64__)
    printf("Architecture: AArch64 detected at compile time\n");
    printf("EL0: User mode (application)\n");
    printf("EL1: OS kernel mode\n");
    printf("EL2: Hypervisor mode\n");
    printf("EL3: Secure monitor mode\n");

    unsigned long el = safe_read_sysreg("currentel");
    if(el==(unsigned long)-1) printf("CurrentEL: unreadable from EL0 (trapped)\n");
    else printf("CurrentEL raw: 0x%lx (EL%lu)\n", el, (el>>2)&3);

    unsigned long tcr = safe_read_sysreg("tcr_el1");
    if(tcr==(unsigned long)-1) printf("TCR_EL1: unreadable from EL0 (trapped, expected in userspace)\n");
    else{
        printf("TCR_EL1 raw value: 0x%lx\n", tcr);
        int tbi_enabled = (tcr>>37)&1;
        printf("Top-Byte-Ignore (pointer tagging) TBI0: %s\n", tbi_enabled?"Enabled":"Disabled/Unknown");
    }

    unsigned long id_aa64pfr1 = safe_read_sysreg("id_aa64pfr1_el1");
    if(id_aa64pfr1==(unsigned long)-1) printf("ID_AA64PFR1_EL1: unreadable from EL0 (trapped)\n");
    else{
        int mte = (id_aa64pfr1>>8)&0xF;
        printf("MTE support level: %d (%s)\n", mte, mte>0?"Supported":"Not supported");
    }
#else
    printf("Non-AArch64 host: pointer tagging/MTE/EL registers not applicable\n");
#endif
    printf("\n");
}

static void analyze_eof(uint8_t *data,size_t sz){
    printf("=== End of File Signature ===\n");
    if(sz<16){ printf("File too small\n\n"); return; }
    printf("Last 16 bytes: ");
    for(size_t i=sz-16;i<sz;i++) printf("%02X ",data[i]);
    printf("\n\n");
}

static double bench_network(void){
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if(sockfd<0) return -1;
    struct sockaddr_in addr;
    memset(&addr,0,sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(0);
    addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
    if(bind(sockfd,(struct sockaddr*)&addr,sizeof(addr))<0){
        close(sockfd);
        return -1;
    }
    socklen_t len=sizeof(addr);
    getsockname(sockfd,(struct sockaddr*)&addr,&len);

    int sender = socket(AF_INET, SOCK_DGRAM, 0);
    size_t pktsize = 1400;
    uint8_t *pkt = malloc(pktsize);
    memset(pkt,0x11,pktsize);
    int count = 5000;

    double t0=now_sec();
    for(int i=0;i<count;i++)
        sendto(sender,pkt,pktsize,0,(struct sockaddr*)&addr,sizeof(addr));
    double t1=now_sec();

    free(pkt);
    close(sender);
    close(sockfd);
    double mb = (double)pktsize*count/1e6;
    return mb/(t1-t0);
}

static void analyze_network(void){
    printf("=== Network Interface (loopback TX to host) ===\n");
    double speed = bench_network();
    if(speed<0) printf("Network benchmark unavailable (socket error)\n");
    else{
        printf("TX throughput: %.2f MB/s\n", speed);
        printf("RX throughput (approx, same channel): %.2f MB/s\n", speed);
    }
    printf("\n");
}

static void analyze_strings(uint8_t *data,size_t sz){
    printf("=== Interpretable Strings ===\n");
    size_t minlen=4;
    size_t i=0;
    int count=0;
    while(i<sz && count<100){
        size_t start=i;
        while(i<sz && isprint(data[i])) i++;
        size_t len=i-start;
        if(len>=minlen){
            printf("0x%08zx: %.*s\n", start,(int)len,data+start);
            count++;
        }
        i++;
    }
    printf("\n");
}

static void analyze_size(const char *path){
    printf("=== File Size ===\n");
    struct stat st;
    if(stat(path,&st)==0){
        printf("Physical size: %lld bytes\n",(long long)st.st_size);
        printf("Size on disk : %lld bytes (blocks: %lld x 512)\n",
            (long long)st.st_blocks*512,(long long)st.st_blocks);
    }
    printf("\n");
}

static void analyze_integrity(uint8_t *data,size_t sz){
    printf("=== Integrity Checksum (CRC32) ===\n");
    crc32_init();
    uint32_t c = crc32_calc(data,sz);
    printf("CRC32: 0x%08X\n", c);
    printf("\n");
}

int main(int argc,char **argv){
    if(argc<2){
        fprintf(stderr,"Usage: %s <file>\n",argv[0]);
        return 1;
    }
    const char *path = argv[1];
    int fd = open(path,O_RDONLY);
    if(fd<0){ perror("open"); return 1; }
    struct stat st;
    fstat(fd,&st);
    size_t sz = st.st_size;
    uint8_t *data = mmap(NULL,sz,PROT_READ,MAP_PRIVATE,fd,0);
    if(data==MAP_FAILED){ perror("mmap"); close(fd); return 1; }

    printf("Baremetal Profile Report: %s\n\n", path);

    analyze_header(data,sz);
    analyze_cache();
    analyze_ram();
    analyze_disk(path,sz);
    analyze_security();
    analyze_eof(data,sz);
    analyze_network();
    analyze_strings(data,sz);
    analyze_size(path);
    analyze_integrity(data,sz);

    munmap(data,sz);
    close(fd);
    return 0;
}