/*************************/
/*                       */
/*      ko_io.c          */
/*                       */
/*      Alan Dix         */
/*                       */
/*      February 1993    */
/*                       */
/*************************/

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include "kohonen.h"
#include "my_rand.h"

#ifndef SEEK_SET
#define SEEK_SET 0
#endif

data_p read_data_file(mess,name)
    char *mess,*name;
{
    FILE *fp = fopen(name,"r");
    data_p data;
    if ( fp == NULL ) {
        fprintf(stderr,"couldn't open %s: %s\n",mess,name);
        exit(1);
        }
    data = read_data(fp);
    if ( data == NULL ) {
        fprintf(stderr,"failure whilest reading %s: %s\n",mess,name);
        exit(1);
        }
    return data;
}

int write_data_file(mess,name,data)
    char *mess,*name;
    data_p data;
{
    FILE *fp = fopen(name,"w");
    if ( fp == NULL ) {
        fprintf(stderr,"couldn't open %s: %s\n",mess,name);
        exit(1);
        }
    if ( ! write_data(fp,data) ) {
        fprintf(stderr,"failure whilest reading %s: %s\n",mess,name);
        exit(1);
        }
    return 1;
}

code_p read_code_file(mess,name)
    char *mess,*name;
{
    FILE *fp = fopen(name,"r");
    code_p code;
    if ( fp == NULL ) {
        fprintf(stderr,"couldn't open %s: %s\n",mess,name);
        exit(1);
        }
    code = read_code(fp);
    if ( code == NULL ) {
        fprintf(stderr,"failure whilest reading %s: %s\n",mess,name);
        exit(1);
        }
    return code;
}

int write_code_file(mess,name,code)
    char *mess,*name;
    code_p code;
{
    FILE *fp = fopen(name,"w");
    if ( fp == NULL ) {
        fprintf(stderr,"couldn't open %s: %s\n",mess,name);
        exit(1);
        }
    if ( ! write_code(fp,code) ) {
        fprintf(stderr,"failure whilest reading %s: %s\n",mess,name);
        exit(1);
        }
    return 1;
}

int skip_to_end_line(fp)
    FILE *fp;
{
    int c;
    for ( c=getc(fp); c!=EOF && c!='\n'; c=getc(fp) ) /* do nout */;
    return c;
}

int skip_space(fp)
    FILE *fp;
{
    int c;
    for ( c=getc(fp); c!=EOF && isspace(c); c=getc(fp) ) /* do nout */;
    if ( c != EOF ) ungetc(c,fp);
    return c;
}

#define LINE_SIZE 255

int write_vec(fp,vec,wid)
    FILE *fp;
    Ds vec;
    int wid;
{
    int i;
    for ( i=0; i<wid; i++ ) {
        fprintf(fp,"% 8.3lf ",vec[i]);
        }
    return 1;
}

char *read_label(fp)
    FILE *fp;
{
    int len;
    char *lp;
static char line_buff[LINE_SIZE+1];

    if ( ! fgets(line_buff,LINE_SIZE,fp) ) return 0;
    len = strlen(line_buff);
    if ( line_buff[len-1] != '\n' ) {
        fprintf(stderr,"very long input line, contains: \"%0.30s\"\n",line_buff);
        if ( skip_to_end_line(fp) == EOF ) return 0;
        }
    else {
        len--;
        line_buff[len] = '\0';
        }
    lp=line_buff;
    if ( isspace(*lp) ) {
        char *sp = line_buff;
        while ( isspace(*lp) ) lp++;
        for ( sp=line_buff; *lp; sp++, *lp++ ) *sp = *lp;
        *sp = '\0';
        }
    lp = &line_buff[len-1];
    while ( lp>=line_buff && isspace(*lp) ) lp--;
    lp++;
    *lp = '\0';
    return strdup(line_buff);
}

data_p alloc_data(wid,len)
    int wid, len;
{
    int j;
    data_p result = (data_p)malloc(sizeof(data_t));
    result->wid = wid;
    result->len = len;
    result->val    = (Dss)malloc(sizeof(Ds)*len);
    result->labels = (Css)malloc(sizeof(Cs)*len);
    for ( j=0; j<len; j++ ) {
        result->val[j] = (Ds)malloc(sizeof(double)*wid);
        result->labels[j] = NULL;
        }
    return result;
}

data_p read_data(fp)
    FILE *fp;
{
    int i, j;
    int data_len = 0;
    int data_wid;
    data_p result;
    fscanf(fp,"%d",&data_wid);
    if ( data_wid <=0 || data_wid > 100 ) return 0;
    if ( skip_to_end_line(fp) == EOF ) return 0;
    while ( skip_space(fp) != EOF ) {
        for ( i=0; i<data_wid; i++ ) {
            double rubbish;
            if ( fscanf(fp,"%lf",&rubbish) != 1 ) return 0;
            }
        if ( skip_to_end_line(fp) == EOF ) return 0;
        data_len++;
        }
    fseek(fp,0L,SEEK_SET);
    result = alloc_data(data_wid,data_len);
    fscanf(fp,"%d",&data_wid);
    for ( j=0; j<data_len; j++ ) {
        for ( i=0; i<data_wid; i++ ) {
            if ( fscanf(fp,"%lf",&result->val[j][i]) != 1 ) return 0;
            }
        result->labels[j] = read_label(fp);
        if ( result->labels[j] == NULL ) return 0;
        }
    return result;
}

int write_data(fp,data)
    FILE  *fp;
    data_p data;
{
    int j;
    fprintf(fp,"%d\n",data->wid);
    for ( j=0; j<data->len; j++ ) {
        write_vec(fp,data->val[j],data->wid);
        if ( data->labels[j] ) fputs(data->labels[j],fp);
        fputc('\n',fp);
        }
    return 1;
}

            
code_p alloc_code(wid, X, Y)
    int wid, X, Y;
{
    int x, y;
    code_p result = (code_p)malloc(sizeof(code_t));
    Dsss code = (Dsss)malloc(sizeof(Dss)*X);
    Csss labels = (Csss)malloc(sizeof(Css)*X);
    for ( x=0; x<X; x++ ) {
        code[x] = (Dss)malloc(sizeof(Ds)*Y);
        labels[x] = (Css)malloc(sizeof(Cs)*Y);
        for ( y=0; y<Y; y++ ) {
            code[x][y] = (Ds)malloc(sizeof(double)*wid);
            labels[x][y] = NULL;
            }
        }
    result->wid = wid;
    result->X   = X;
    result->Y   = Y;
    result->val = code;
    result->labels = labels;
    return result;
}


code_p read_code(fp)
    FILE *fp;
{
    int i, x, y;
    int code_wid, code_X, code_Y;
    code_p code;
    fscanf(fp,"%d %d %d",&code_wid, &code_X, &code_Y);
    if ( code_wid <=0 || code_wid > 100 ) return 0;
    if ( code_X <=0 || code_X > 100 ) return 0;
    if ( code_Y <=0 || code_Y > 100 ) return 0;
    if ( skip_to_end_line(fp) == EOF ) return 0;
    code = alloc_code(code_wid, code_X, code_Y);
    if ( ! code ) return 0;
    for ( x=0; x<code_X; x++ ) {
        for ( y=0; y<code_Y; y++ ) {
            for ( i=0; i<code_wid; i++ ) {
                if ( fscanf(fp,"%lf",&code->val[x][y][i]) != 1 ) return 0;
                }
            code->labels[x][y] = read_label(fp);
            if ( code->labels[x][y] == NULL ) return 0;
            }
        }
    return code;
}

int write_code(fp,code)
    FILE  *fp;
    code_p code;
{
    int x, y;
    fprintf(fp,"%d %d %d\n",code->wid, code->X, code->Y);
    for ( x=0; x<code->X; x++ ) {
        for ( y=0; y<code->Y; y++ ) {
            write_vec(fp,code->val[x][y],code->wid);
            if ( code->labels[x][y] ) fputs(code->labels[x][y],fp);
            fputc('\n',fp);
            }
        }
    return 1;
}

code_p gen_code(wid, X, Y, lo, hi)
    int wid, X, Y;
    double lo, hi;
{
    int i, x, y;
    code_p code = alloc_code(wid, X, Y);

    if ( ! code ) return 0;

    for ( x=0; x<code->X; x++ ) {
        for ( y=0; y<code->Y; y++ ) {
            for ( i=0; i<code->wid; i++ ) {
                code->val[x][y][i] = drand_range(lo,hi);
                }
            }
        }
    return code;
}


int fill_code_labels(label,code)
    char *label;
    code_p code;
{
    int x, y;

    if ( code==NULL || label==NULL ) return 0;

    for ( x=0; x<code->X; x++ ) {
        for ( y=0; y<code->Y; y++ ) {
            code->labels[x][y] = strdup(label);;
            }
        }
    return 1;
}