#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "myc_mem.h"
#include "myc_err.h"
#include "myc_str.h"
#include "myc_time.h"
#include "sys_util.h"
#include "coc_util.h"
#include "tecs_cli.h"
#include "tecs_data.h"

static char response[COC_RES_LEN];
static char *rwCode="rwacs";
static char *rdCode="rdacs";

pTecsClient TeccInit(char *startcmd, int port) {
  CocConn *conn;

  NEW(conn, CocConn);
  if (startcmd[0]=='#') {
    ERR_I(CocInitClient(conn, startcmd+1, port, rdCode, 0, ""));
  } else {
    ERR_I(CocInitClient(conn, "", port, rwCode, 0, startcmd));
  }
  return((pTecsClient)conn);
  OnError: return(NULL);
}

int TeccGet3(pTecsClient conn, float *tC, float *tX, float *tP) {
  int iret;

  CocReset(conn);
  ERR_I(CocGetFloat(conn, "set", tC));
  ERR_I(CocGetFloat(conn, "tempX", tX));
  ERR_I(CocGetFloat(conn, "tempP", tP));
  ERR_I(CocPutInt(conn, "readTemp", 1));
  ERR_I(iret=CocDoIt(conn, response, sizeof(response)));
  if (iret) ERR_MSG(response);
  return(0);
  OnError: return(-1);
}

int TeccGet(pTecsClient conn, float *temp) {
  int iret;

  CocReset(conn);
  ERR_I(CocGetFloat(conn, "tempP", temp));
  ERR_I(CocPutInt(conn, "readTemp", 1));
  ERR_I(iret=CocDoIt(conn, response, sizeof(response)));
  if (iret) ERR_MSG(response);
  return(0);
  OnError: return(-1);
}

int TeccSet(pTecsClient conn, float temp) {
  int iret;

  CocReset(conn);
  ERR_I(CocPutFloat(conn, "set", temp));
  ERR_I(iret=CocDoIt(conn, response, sizeof(response)));
  if (iret) ERR_MSG(response);
  return(0);
  OnError: return(-1);
}

int TeccQuitServer(pTecsClient conn, int kill) {
  int iret, cnt;

  ERR_I(iret=CocCheck(conn));
  if (iret>0) return iret;
  CocReset(conn);
  ERR_I(CocPutInt(conn, "quit", 1+kill));
  ERR_I(iret=CocDoIt(conn, response, sizeof(response)));
  if (iret) ERR_MSG(response);
  cnt=50;
  while (iret==0 && cnt>0) {
    CocDelay(100);
    ERR_I(iret=CocCheck(conn));
    cnt--;
  }
  if (iret==0) ERR_MSG("Does not quit within 5 seconds");
  return 0;
  OnError:
    return(-1);
}

int TeccSend(pTecsClient conn, char *cmd, char *reply, int replyLen) {
  return(CocSetGetN(conn, "send", cmd, reply, replyLen));
}

void TeccClose(pTecsClient conn) {
  if (conn!=NULL) {
    CocCloseClient(conn);
    FREE(conn);
  }
}

/* fortran wrappers --------------------------------------------------

  reduced functionality:
  connection is static, so only one connection at a time may be opened 

*/

#ifdef F_CHAR
/* compile only when fortran c interface stuff is defined */


#ifdef __VMS
#define tecs_get_par_ tecs_get_par
#define tecs_get_mult_ tecs_get_mult
#define tecs_set_par_ tecs_set_par
#define tecs_init_ tecs_init
#define tecs_get3_ tecs_get3
#define tecs_get_ tecs_get
#define tecs_set_ tecs_set
#define tecs_is_open_ tecs_is_open
#define tecs_close_ tecs_close
#define tecs_quit_server_ tecs_quit_server
#define tecs_watch_log_ tecs_watch_log
#define tecs_get_data_ tecs_get_data
#define tecs_date_ tecs_date
#define tecs_time_ tecs_time
#define tecs_rights_ tecs_rights
#elif defined __linux
#define tecs_get_par_ tecs_get_par__
#define tecs_get_mult_ tecs_get_mult__
#define tecs_set_par_ tecs_set_par__
#define tecs_init_ tecs_init__
#define tecs_get3_ tecs_get3__
#define tecs_get_ tecs_get__
#define tecs_set_ tecs_set__
#define tecs_is_open_ tecs_is_open__
#define tecs_close_ tecs_close__
#define tecs_quit_server_ tecs_quit_server__
#define tecs_watch_log_ tecs_watch_log__
#define tecs_get_data_ tecs_get_data__
#define tecs_date_ tecs_date__
#define tecs_time_ tecs_time__
#define tecs_rights_ tecs_rights__
#endif

static pTecsClient conn=NULL;

int tecs_set_par_(F_CHAR(name), F_CHAR(par), int *show, int name_len, int par_len) {
  char nbuf[64], pbuf[COC_CMD_LEN];
  int iret=-1;

  STR_TO_C(nbuf, name);
  STR_TO_C(pbuf, par);

  CocReset(conn);
  ERR_I(CocPutStr(conn, nbuf, pbuf));
  ERR_I(CocDoIt(conn, response, sizeof(response)));
  if (*show) {
    printf("%s", response);
  }
  return(0);
  OnError: return(-1);
}

int tecs_get_par_(F_CHAR(name), F_CHAR(par), int *show, int name_len, int par_len) {
  char *b, nbuf[64], pbuf[COC_RES_LEN];
  int iret=-1;

  STR_TO_C(nbuf, name);
  CocReset(conn);
  ERR_I(CocGetStr(conn, nbuf, pbuf, sizeof(pbuf)));
  ERR_I(CocDoIt(conn, response, sizeof(response)));
  if (*show==2) {
    b=response;
  } else {
    b=strchr(response,'=');
    if (b==NULL) {
      b=response;
    } else {
      b++;
    }
  }
  if (*show) {
    printf("%s", b);
  }
  return(STR_TO_F(par, pbuf));
  OnError: return(-1);
}

int tecs_get_mult_(F_CHAR(names), int *time, int *nvalues, float values[], int names_len) {
  char *b, nbuf[64], pbuf[COC_RES_LEN];
  char *nams, nam[32];
  int i;

  STR_TO_C(nbuf, names);
  CocReset(conn);

  ERR_I(CocGetInt(conn, "rdTim", time));
  i=0;
  nams=nbuf;
  while (nams!=NULL && i < *nvalues) {
    nams=str_split(nam, nams, ' ');
    if (nam[0]!='\0') {
      ERR_I(CocGetFloat(conn, nam, values+i));
      i++;
    }
  }

  ERR_I(CocDoIt(conn, response, sizeof(response)));
  return(0);
  OnError: return(-1);
}

int tecs_init_(F_CHAR(startcmd), int *port, int startcmd_len) {
  char sbuf[132];

  STR_TO_C(sbuf, startcmd);
  ERR_P(conn=TeccInit(sbuf, *port));
  return(0);
  OnError: return(-1);  
}

int tecs_rights_(int write) {
  if (write) {
    ERR_I(CocSendMagic(conn, rwCode));
  } else {
    ERR_I(CocSendMagic(conn, rdCode));
  }
  return(0);
  OnError: return(-1);  
}

int tecs_get_(float *temp) {
  ERR_I(TeccGet(conn, temp));
  return(0);
  OnError: return(-1);  
}

int tecs_get3_(float *t1, float *t2, float *t3) {
  ERR_I(TeccGet3(conn, t1, t2, t3));
  return(0);
  OnError: return(-1);  
}

int tecs_set_(float *temp) {
  ERR_I(TeccSet(conn, *temp));
  return(0);
  OnError: return(-1);  
}

int tecs_is_open_() {
  return(conn!=NULL);
}

void tecs_close_(void) {
  TeccClose(conn);
  conn=NULL;
}

int tecs_quit_server_(int *kill) {
  int iret;

  ERR_I(iret=TeccQuitServer(conn, *kill));
  return(iret);
  OnError: return(-1);  
}

int tecs_watch_log_(F_CHAR(list), int list_len) {
  char buf[16];
  STR_TO_C(buf, list);
  ERR_I(CocWatchLog(conn, buf));
  return(0);
  OnError: return(-1);  
}

static char *encode=DATA_CODE;

int DataDecode(float *data, int dataSize, char *coded, int *retSize) {
  int i, p, gap, dig1, dig2;
  float minD, range;
  char ch, *q;
  static int decode[256];
  static int init=1;

  if (coded[0] == '\0') {
    *retSize=0;
    return 0;
  }
  if (init) {
    init=0;
    for (i=0; i<256; i++) {
      decode[i]=-1;
    }
    i=0;
    while (encode[i]!=0) {
      decode[encode[i]]=i;
      i++;
    }
  }
  p=0;
  ERR_SI(sscanf(coded, "%d %e %e %n", retSize, &minD, &range, &p)-3);
  if (*retSize < dataSize) dataSize = *retSize;
  i=0;
  while (i < dataSize) {
    ch=coded[p++];
    dig1=decode[ch];
    if (dig1 < 0) { /* code is no 64-digit */
      if (ch=='\0' || ch==',') break;
      if (ch=='/') {
        data[i++] = DATA_UNDEF;
      } else if (ch=='.') {
        data[i++] = DATA_GAP;
      }
    } else {
      ch=coded[p++];
      dig2=decode[ch];
      while (dig2<0) {
        if (ch=='\0' || ch==',') break;
        ch=coded[p++];
        dig2=decode[ch];
      }
      if (ch=='\0' || ch==',') break;
      data[i++] = (dig1 + dig2 * 64) / 4095.0 * range + minD;
    }
  }
  while (i < dataSize) {
    data[i++] = DATA_UNDEF;
  }
  if (ch=='\0') {
    return p-1;
  } else if (ch!=',') {
    q=strchr(coded+p, ',');
    if (q==NULL) return strlen(coded);
    return q-coded+1;
  }
  return p;
  OnError:
    *retSize=0;
    return -1;
}


int tecs_get_data_(F_CHAR(names), int *startTime, int *endTime, int *step, int *tbase
                  , float xdata[], float ydata[], int *maxLen, int *width
                  , int retLen[], int names_len) {
  char nam[64];
  char str[128];
  char res[COC_RES_LEN];
  char *cod;
  float offset, fact, *py;
  int i, j, k, l, iret, retSize;

  if (*endTime - *startTime > *step * (*maxLen-1)) {
    printf("maxLen too small\n");
  }
  STR_TO_C(nam, names);
  if (*step <= 0) {
    *step = 60;
  }
  sprintf(str, "%d %d %d %s", *startTime, *endTime, *step, nam);
  
  CocReset(conn);
  ERR_I(CocPutStr(conn, "pltdata", str));
  ERR_I(CocGetStr(conn, "pltdata", res, sizeof(res)));
  ERR_I(iret=CocDoIt(conn, response, sizeof(response)));
  if (iret) ERR_MSG(response);
  cod=res;
  for (i=0; i < *width; i++) {
    py = ydata + i * *maxLen;
    ERR_I(l=DataDecode(py, *maxLen, cod, retLen+i));
    if (retLen[i]>0) {
      fact = (float)(*endTime - *startTime) / retLen[i];
    }
    offset = *startTime - *tbase;
    k = i * *maxLen;
    for (j=0; j<retLen[i]; j++) {
      if (py[j] != DATA_GAP) {
        ydata[k] = py[j];
        xdata[k] = offset + j * fact;
        k++;
      }
    }
    retLen[i] = k - i * *maxLen;
    cod+=l;
  }
  return 0;
  OnError:
    return -1;
}

/*
float tecs_date_(time_t *time) {
  struct tm tim;

  tim=*localtime(time);
  return(tim.tm_mday+(tim.tm_mon+1)*0.01);
}

time_t tecs_time_(float *date) {
  struct tm tim;
  time_t t, now;
  int m;

  time(&now);
  tim=*localtime(&now);
  tim.tm_hour=0;
  tim.tm_min=0;
  tim.tm_sec=0;
  tim.tm_mday=(int)*date;
  m=(int)(*date*100+0.1) % 100;
  if (m > 0) tim.tm_mon=m-1;
  t=mktime(&tim);
  if (t > now) {
    tim.tm_year--;
    t=mktime(&tim);
  }
  return t;
}
*/
#endif