//
//  Dataset.m
//  DaMaT
//
//  Created by Simon Urbanek on Fri Aug 30 2002.
//  Copyright (c) 2001 __MyCompanyName__. All rights reserved.
//

#import "Dataset.h"

#define dataIncrement 512
#define msgIncrement 64
/* read chunk must be equal or less initBufSize and bufsizeIncrement */
#define readChunk 32768
#define initBufSize 65536
#define bufSizeIncrement 32768


@implementation Dataset
- (id) init
{
    [super init];
    rs=cols=0;
    ars=dataIncrement;
    data=(char***)malloc(sizeof(char**)*ars);
    rlen=(int*)malloc(sizeof(int)*ars);
    memset(rlen,0,sizeof(int)*ars);
    amsgs=msgIncrement;
    msg=(struct msgInfo*)malloc(sizeof(struct msgInfo)*amsgs);
    msgs=0;
    printf("Dataset.init\n");
    return self;
}

- (void) dealloc {
    printf("Dataset.dealloc\n");
    if (data) {
        int i=0;
        while (i<rs) {
            int j=0;
            while (j<rlen[i]) free(data[i][j++]);
            free(data[i++]);
        };
        free(data);
        free(rlen);
    };
    if (msg) {
        int i=0;
        while (i<msgs) {
            if (msg[i].atc!=nil) [msg[i].atc release];
            i++;
        };
        free(msg);
    };
    if (fields) {
        int i=0;
        while(i<fs) {
            free(fields[i].name);
            i++;
        };
        free(fields);
    };
    [super dealloc];
}

- (int) rows
{
    return rs;
}

- (int) fieldCount
{
    return fs;
}

- (int) addFlatRow: (const char*) newrow ofLength: (int) ln
{
    int i,j,k,cr;
    const char *c;
    
    if (!newrow) return 0;
    i=j=0;
    while(j<ln) {
        if (!newrow[j]) i++;
        j++;
    }
    cr=[self allocRowOfLength:i];
    i=j=k=0;
    c=newrow;
    while (j<ln) {
        if (!newrow[j]) {
            data[cr][i]=(char*)malloc(k+1);
            strcpy(data[cr][i],c);
            c=newrow+(j+1); k=0;
            i++;
        }
        j++; k++;
    }
    return cr;
}

- (int) allocRowOfLength: (int) len
{
    if (ars<=rs) {
        while(ars<=rs) ars+=dataIncrement;
        data=(char***)realloc(data,ars*sizeof(char**));
        rlen=(int*)realloc(rlen,ars*sizeof(int));
        memset(rlen+rs,0,sizeof(int)*(ars-rs));
    }
    rlen[rs]=len;
    data[rs]=(char**)malloc(sizeof(char*)*len);
    return rs++;
}

- (int) length: (int) rnr
{
    return (rnr<0 || rnr>=rs)?0:rlen[rnr];
}

- (char*) entryAtRow: (int) rnr andColumn: (int) cnr
{
    return (rnr<0 || cnr<0 || rnr>=rs || cnr>=rlen[rnr])?0:data[rnr][cnr];
}

- (char*) replaceEntryAtRow: (int) rnr andColumn: (int) cnr withEntry: (const char*) net
{
    if (rnr<0 || cnr<0 || rnr>=rs || cnr>=rlen[rnr]) return 0;
    if (data[rnr][cnr]) free(data[rnr][cnr]);
    data[rnr][cnr]=(net)?(char*)malloc(strlen(net)+1):0;
    if (net) strcpy(data[rnr][cnr],net);
    return data[rnr][cnr];
}

- (char**) getRow: (int) rnr
{
    return (rnr<0 || rnr>=rs)?0:data[rnr];
}

- (struct fieldInfo*) getFieldAt: (int) fix
{
    return ((fix<0) || (fix>=fs))?0:fields+fix;
}

- (struct fieldInfo*) allocFields: (int) fis
{
    fields=(struct fieldInfo*)malloc(sizeof(struct fieldInfo)*fis);
    memset(fields,0,sizeof(struct fieldInfo)*fis);
    afs=fs=fis;
    return fields;
}

/* BEWARE! message text uses SHALLOW copy, since the set of message texts is usually fixed,
   hence it's much more useful to use just one copy no matter for how many cells */
- (void) addMessage: (const char*) m withId: (int) mid forRow: (int) rnr andColumn: (int) cnr
{
    if (msgs>=amsgs) {
        while (msgs>=amsgs) amsgs+=msgIncrement;
        msg=(struct msgInfo*)realloc(msg,sizeof(struct msgInfo)*amsgs);
    }
    msg[msgs].msg=m;
    msg[msgs].mid=mid;
    msg[msgs].row=rnr;
    msg[msgs++].col=cnr;
    //printf("Line %d, column %d: [%d] %s\n",rnr+1,cnr+1,mid,m);
}

- (struct msgInfo*) getMessages
{
    return msg;
}

- (int) getMessagesCount
{
    return msgs;
}

- (int) srcEncoding
{
    return srcEncoding;
}

- (void) processLine: (char*) lc asLine: (int) ln
{
    int i,j,len=0,n;
    char *c,*d;

    if (!*lc) {
        if (ln==0)
            [self addMessage:"First line is empty. Assuming headers are to be found at first non-empty line" withId:2 forRow:ln andColumn:-1];
        return;
    };

    c=lc;
    n=1;
    while(*c) {
        if (*c=='\t') {
            n++;
            *c=0;
        };
        c++; len++;
    };
    //printf("Line %d: has %d columns\n",ln,n);
    if (!fields && ln>0)
        [self addMessage:"First non-empty line, treating as header" withId:3 forRow:ln andColumn:-1];

    if (!fields) {
        printf("alloc fields\n");
        [self allocFields:n];
        c=d=lc;
        i=0;
        while(i<n) {
            if (!*c) {
                if (!c) j=1;
                *c=0;
                //printf("adding column [%d] \"%s\"",i,d);
                fields[i].name=(char*)malloc(c-d+1);
                strcpy(fields[i].name,d);
                d=c+1;
                i++;
            };
            c++;
        };
        //printf("fields loaded (%d/%d)\n",n,i);
    } else {
        int k=0;
        i=[self addFlatRow:lc ofLength:len+1];
        //printf("Row %d has length %d\n",i,[self length:i]);
        j=[self length:i];
        if (j<fs)
            [self addMessage:"The row has less columns that the header" withId:4 forRow:ln andColumn:-1];
        if (j>fs)
            [self addMessage:"The row has more columns that the header" withId:5 forRow:ln andColumn:-1];
        if (j<=fs) {
            while (k<j) {
                c=[self entryAtRow:i andColumn:k];
                // ToDo: record each NA style separately
                if (!c || *c==0 ||
                    ((unsigned char)*c==0xa5 && c[1]==0) ||
                    (*c=='?' && c[1]==0) ||
                    (*c=='N' && c[1]=='A' && c[2]==0)) {
                    fields[k].nas++;
                } else {
                    if (*c=='+' || *c==' ' || *c=='-' ||
                        (*c>='0' && *c<='9')) { /* could be a number - parse */
                         strtod(c,&d);
                         if (*d)
                         fields[k].strs++;
                         else
                         fields[k].nums++;
                    } else {
                        fields[k].strs++;
                    };
                };
                k++;
            }
        };
    }
}

- (id) loadFromFile: (const char*) fname
{
    FILE *f;
    char *buf, *c,*d;
    int blen=initBufSize;
    int tlen, readLen,pls,i,lpp;
    int nrs, nns;
    int lnrs=-1, lnns;
    int ln=0;

    if (fields) free(fields);
    afs=fs=0;
    
    f=fopen(fname,"rb");
    if (!f) return nil;
    pls=tlen=0;
    buf=(char*)malloc(blen);
    
    while(!feof(f)) {
        readLen=fread(buf+tlen,1,readChunk,f);
        //printf("read %d bytes\n",readLen);
        if (readLen>0) {
            tlen+=readLen;
            c=buf; pls=lpp=0;
            i=0;
            while(i<tlen) {
                if (buf[i]=='\n' || buf[i]=='\r')  {
                    //printf("found a line %d-%d\n",lpp,i);
                    nrs=0; nns=0;
                    d=buf+i;
                    while(i<tlen && (buf[i]=='\n' || buf[i]=='\r')) {
                        if (buf[i]=='\n') nns++;
                        if (buf[i]=='\r') nrs++;
                        i++;
                    }
                    if (i==tlen) /* read might have splitted the EOL chars, so don't use it yet */
                        break;
                    if (lnrs!=-1) {
                        if (lnrs!=nrs || lnrs!=nrs)
                            [self addMessage:"Different EOL sequence than previous line" withId:1 forRow:ln andColumn:-1];
                    };
                    if (ln==0) {
                        if (nrs==1 && nns==0) srcEncoding=SE_mac;
                        if (nrs==0 && nns==1) srcEncoding=SE_unix;
                        if (nrs==1 && nns==1) srcEncoding=SE_pc;
                    };
                    lnrs=nrs; lnns=nns;
                    *d=0;
                    pls++;
                    //printf("EOL is inside (%dx\\n, %dx\\r), all ok. Resulting line:\n\"%s\"\nCalling process line\n",nns,nrs,c);
                    [self processLine:c asLine:ln];
                    ln++;
                    c=buf+i; lpp=i;
                    //printf("OK, going for next one, beginning at %d\n",lpp);
                } else
                    i++;
            }
            //printf("Buffer processed, %d bytes left.\n",tlen-lpp);
            if (lpp) { /* move down to reuse processed space */
                tlen-=lpp;
                memmove(buf,c,tlen);
            };
            //printf("tlen=%d, blen=%d; required=%d\n",tlen,blen,tlen+readChunk);
            if (tlen+readChunk>blen) { /* allocate enough space for next read */
                while (tlen+readChunk>blen) blen+=bufSizeIncrement;
                //printf("reallocating buffer to size %d.\n",blen);
                buf=(char*)realloc(buf,blen);
            }
        }
    }
    printf("Lines: %d\n",ln);
    formInfo[1023]=0;
    snprintf(formInfo,1023,"Tab-separated values with header\nTotal %d variables and %d cases.\nEOL encoding: %s\n",
           fs,rs,
           (srcEncoding==SE_mac)?"Mac":((srcEncoding==SE_unix)?"unix":((srcEncoding==SE_pc)?"PC":"other")));
    fclose(f);

    return self;
}

- (NSString*) getFormatInfoString
{
    return [NSString stringWithCString:formInfo];
}

@end