/* Append-only, little-endian binary64 blocks. No output evaluation during solve.
 * Each block: SIMBLK01, u64 sequence/rows/columns/crc32, column-major payload,
 * COMMIT01. A truncated/uncommitted tail is never a valid block.
 * Synchronous buffered writes provide backpressure without a producer queue. */
#include "runtime.h"
#include "json_numbers.h"
#include <stdlib.h>
#include <string.h>
#include <float.h>
#include <limits.h>
#include <sys/types.h>
#ifndef NATIVE_SAMPLE_BUFFER_BYTES
#define NATIVE_SAMPLE_BUFFER_BYTES 1048576u
#endif

_Static_assert(sizeof(double)==8 && DBL_MANT_DIG==53 && DBL_MAX_EXP==1024,
               "Result blocks require IEEE-754 binary64");

int64_t native_file_tell(FILE *f) {
    /* MinGW/MSVCRT can overcount a buffered final newline in _ftelli64 even
       for a binary FILE. Query the committed byte position instead. */
    if(fflush(f)) return -1;
#ifdef _WIN32
    return _ftelli64(f);
#else
    return (int64_t)ftello(f);
#endif
}
static int seek_file(FILE *f, uint64_t offset) {
    if(offset>INT64_MAX) return 0;
#ifdef _WIN32
    return _fseeki64(f,(int64_t)offset,SEEK_SET)==0;
#else
    return fseeko(f,(off_t)offset,SEEK_SET)==0;
#endif
}
static void put64(unsigned char *p,uint64_t n) {
    for(int i=0;i<8;i++) {p[i]=(unsigned char)n;n>>=8;}
}
static uint64_t get64(const unsigned char *p) {
    uint64_t n=0;for(int i=7;i>=0;i--) n=(n<<8)|p[i];return n;
}
static void little_endian(double *values,size_t count) {
    const uint16_t one=1;
    if(*(const unsigned char *)&one) return;
    unsigned char *p=(unsigned char *)values;
    for(size_t i=0;i<count;i++,p+=8) for(int j=0;j<4;j++) {
        unsigned char v=p[j];p[j]=p[7-j];p[7-j]=v;
    }
}
static uint32_t checksum(const void *data,size_t length) {
    uint32_t table[256];
    for(unsigned i=0;i<256;i++) {
        uint32_t c=i;
        for(int j=0;j<8;j++) c=(c>>1)^((c&1)?UINT32_C(0xedb88320):0);
        table[i]=c;
    }
    uint32_t c=UINT32_MAX;const unsigned char *p=data;
    for(size_t i=0;i<length;i++) c=table[(c^p[i])&255]^(c>>8);
    return c^UINT32_MAX;
}
static int storage_error(NativeRun *r,const char *reason,const char *message) {
    r->storage_failed=1;
    /* Storage failure must also be visible when flushing a cancelled run. */
    r->status=2;r->failure_reason=reason;r->failure_operation="sample-storage";
    snprintf(r->message_buffer,sizeof(r->message_buffer),"%s",message);
    r->message=r->message_buffer;
    r->count=r->committed;r->buffered=0;
    return 0;
}
static int write_block(FILE *f,uint64_t sequence,size_t rows,size_t columns,double *data) {
    size_t length=rows*columns*sizeof(double);
    unsigned char header[40];memcpy(header,"SIMBLK01",8);
    put64(header+8,sequence);put64(header+16,rows);put64(header+24,columns);
    little_endian(data,rows*columns);
    put64(header+32,checksum(data,length));
    int ok=fwrite(header,1,sizeof(header),f)==sizeof(header) &&
           fwrite(data,1,length,f)==length && fwrite("COMMIT01",1,8,f)==8 &&
           fflush(f)==0 && !ferror(f);
    little_endian(data,rows*columns);
    return ok;
}
static int read_block(FILE *f,uint64_t sequence,size_t rows,size_t columns,double *data) {
    unsigned char header[40],tail[8];size_t length=rows*columns*sizeof(double);
    if(fread(header,1,40,f)!=40 || memcmp(header,"SIMBLK01",8) ||
       get64(header+8)!=sequence || get64(header+16)!=rows || get64(header+24)!=columns ||
       fread(data,1,length,f)!=length || fread(tail,1,8,f)!=8 || memcmp(tail,"COMMIT01",8) ||
       get64(header+32)!=checksum(data,length)) return 0;
    little_endian(data,rows*columns);return 1;
}
int native_samples_flush(NativeRun *r) {
    if(r->storage_failed) return 0;
    if(!r->buffered) return 1;
    size_t rows=r->buffered;
    /* Reserve both this state block and its future output block before writing.
       The parent serializes quota grants across concurrent simulations. */
    uint64_t bytes=96+(uint64_t)rows*(NSTATES+NOUTPUTS+2)*8;
    if(r->storage_control) {
        char reply[16];
        fprintf(stderr,"{\"phase\":\"storage-reserve\",\"bytes\":%llu}\n",(unsigned long long)bytes);
        fflush(stderr);
        if(!fgets(reply,sizeof(reply),stdin))
            return storage_error(r,"storage-control","Result storage controller disconnected; complete blocks were retained.");
        if(!strcmp(reply,"full\n"))
            return storage_error(r,"storage-quota","Result storage quota exhausted; complete blocks were retained.");
        if(strcmp(reply,"ok\n"))
            return storage_error(r,"storage-io","Result storage I/O failed; complete blocks were retained.");
    }
    double *data=malloc(rows*(NSTATES+1)*sizeof(double));
    if(!data) return storage_error(r,"storage-memory","Cannot allocate result block.");
    memcpy(data,r->times,rows*sizeof(double));
    for(int j=0;j<NSTATES;j++) for(size_t i=0;i<rows;i++)
        data[(j+1)*rows+i]=r->states[i*NSTATES+j];
    int ok=write_block(r->sample_file,r->committed/r->capacity,rows,NSTATES+1,data);
    free(data);
    if(!ok) return storage_error(r,"storage-io","Cannot write result block; complete blocks were retained.");
    r->committed+=rows;r->buffered=0;return 1;
}
int native_samples_append(NativeRun *r,double t,const double *state) {
    if(r->storage_failed) return 0;
    if(!r->capacity) {
        size_t columns=NSTATES>NOUTPUTS?NSTATES+1:NOUTPUTS+1;
        r->capacity=NATIVE_SAMPLE_BUFFER_BYTES/(columns*sizeof(double));
        if(!r->capacity) r->capacity=1;
        if(r->capacity>1024) r->capacity=1024;
        r->times=malloc(r->capacity*sizeof(double));
        r->states=malloc(r->capacity*NSTATES*sizeof(double));
        r->sample_file=r->sample_path?fopen(r->sample_path,"w+b"):tmpfile();
        if(!r->times || !r->states || !r->sample_file)
            return storage_error(r,"storage-io","Cannot initialize result storage.");
        setvbuf(r->sample_file,NULL,_IOFBF,65536);
    }
    /* Hold the newest sample until a distinct time arrives, preserving the
       pre-existing same-time replacement policy even at block boundaries. */
    if(r->buffered && r->times[r->buffered-1]==t) {r->buffered--;r->count--;}
    if(r->buffered==r->capacity && !native_samples_flush(r)) return 0;
    r->times[r->buffered]=t;
    memcpy(r->states+r->buffered*NSTATES,state,NSTATES*sizeof(double));
    r->buffered++;r->count++;return 1;
}
int native_samples_outputs(NativeRun *r) {
    if(!r->committed) return 1;
    r->output_file=r->output_blocks_path?fopen(r->output_blocks_path,"w+b"):tmpfile();
    if(!r->output_file || !seek_file(r->sample_file,0)) return 0;
    setvbuf(r->output_file,NULL,_IOFBF,65536);
    double *states=malloc(r->capacity*(NSTATES+1)*sizeof(double));
    double *outputs=malloc(r->capacity*(NOUTPUTS+1)*sizeof(double));
    int ok=states && outputs;
    for(size_t start=0;ok && start<r->committed;start+=r->capacity) {
        size_t rows=r->committed-start;if(rows>r->capacity) rows=r->capacity;
        ok=read_block(r->sample_file,start/r->capacity,rows,NSTATES+1,states);
        for(size_t i=0;ok && i<rows;i++) {
            double y[NSTATES],dy[NSTATES],w[NOUTPUTS];
            for(int j=0;j<NSTATES;j++) y[j]=states[(j+1)*rows+i];
            ok=model_eval(states[i],y,dy,w);
            outputs[i]=states[i];
            if(ok) for(int j=0;j<NOUTPUTS;j++) outputs[(j+1)*rows+i]=w[j];
        }
        if(ok) ok=write_block(r->output_file,start/r->capacity,rows,NOUTPUTS+1,outputs);
        if(ok) r->output_count+=rows;
    }
    free(states);free(outputs);return ok;
}
int native_samples_json(NativeRun *r,FILE *f,size_t column) {
    if(column>NOUTPUTS || r->output_count!=r->count || fputc('[',f)==EOF) return 0;
    double *values=malloc((r->capacity?r->capacity:1)*sizeof(double));
    if(!values) return 0;
    int ok=1;
    for(size_t start=0;ok && start<r->count;start+=r->capacity) {
        size_t rows=r->count-start;if(rows>r->capacity) rows=r->capacity;
        uint64_t offset=(uint64_t)(start/r->capacity)*(48+(uint64_t)r->capacity*(NOUTPUTS+1)*8);
        ok=seek_file(r->output_file,offset+40+(uint64_t)column*rows*8) &&
           fread(values,sizeof(double),rows,r->output_file)==rows;
        if(ok) {little_endian(values,rows);ok=native_json_write_values(f,values,rows,1,start!=0);}
    }
    free(values);return ok && fputc(']',f)!=EOF;
}