/*
 * CDE - Common Desktop Environment
 *
 * Copyright (c) 1993-2012, The Open Group. All rights reserved.
 *
 * These libraries and programs are free software; you can
 * redistribute them and/or modify them under the terms of the GNU
 * Lesser General Public License as published by the Free Software
 * Foundation; either version 2 of the License, or (at your option)
 * any later version.
 *
 * These libraries and programs are distributed in the hope that
 * they will be useful, but WITHOUT ANY WARRANTY; without even the
 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 * PURPOSE. See the GNU Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with these libraries and programs; if not, write
 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
 * Floor, Boston, MA 02110-1301 USA
 */
/* $TOG: DataBase.C /main/5 1998/04/17 11:43:17 mgreess $ 
 *
 * (c) Copyright 1996 Digital Equipment Corporation.
 * (c) Copyright 1996 Hewlett-Packard Company.
 * (c) Copyright 1996 International Business Machines Corp.
 * (c) Copyright 1996 Sun Microsystems, Inc.
 * (c) Copyright 1996 Novell, Inc. 
 * (c) Copyright 1996 FUJITSU LIMITED.
 * (c) Copyright 1996 Hitachi.
 */

/* imported interfaces... */
#include <string.h>
#include <stdarg.h>
#include <assert.h>
#include <unistd.h>
#include <errno.h>
#include <sys/stat.h>
#include <sys/types.h>
#include "StringList.h"
#include "Token.h"

/* exported interfaces... */
#include "DataBase.h"


#define FRIENDLY_ASSERT(e) \
  if(!(e)) Token::signalError(Token::Internal, Token::Fatal, \
			      __FILE__, __LINE__, \
			      "assertion failed: " #e);

DB::DB(const char *name)
{
  int len = strlen(name);
  f_name = new char[len + 1];
  *((char *) memcpy(f_name, name, len) + len) = '\0';
}


static int isdir(const char* filename)
{
  int ret = 0;
  struct stat sb;

  if(stat(filename, &sb) == 0){
    if(S_ISDIR(sb.st_mode)){
      ret = 1;
    }
  }

  return ret;
}


static void makedir(const char *path) /* throw(PosixError) */
{
  if(mkdir((char*)path, DATABASE_DIRECTORY_MODE) != 0){
    throw(PosixError(errno, path));
  }
}


DBTable *DB::table(const char *tname, int scode, int cols,
		   int access)
     /* throw(PosixError); */
{
  DBTable *ret = 0; /* keep compiler happy */

  switch(access){
  case CREATE:
    if(!isdir(f_name)){
      makedir(f_name);
    }

    ret = new DBTable(this, scode, cols, tname);
    break;

  case READ:
    ret = new DBTable(this, scode, cols, tname);
    ret->file(DB::READ);
    break;

  default:
    abort();
  }

  return ret;
}



DBTable::DBTable(DB *database, int schema_code, int cols, const char *name)
{
  f_database = database;
  f_schema_code = schema_code;
  f_cols = cols;

  int len = strlen(name);
  f_name = new char[len + 1];
  *((char *) memcpy(f_name, name, len) + len) = '\0';

  f_file = NULL;
  f_start = 0;
}


DBTable::~DBTable()
{
  if(f_file && strcmp(f_name, DATABASE_STDIO) != 0) fclose(f_file);
  delete f_name; 
}


FILE *
DBTable::file(DB::Access access)
{
  if(!f_file){
    if(strcmp(f_name, DATABASE_STDIO) == 0){

      f_file = access == DB::CREATE ? stdout : stdin;

    }else{

      const char *p = f_database->path();
      int pathlen = strlen(p) + 1 + strlen(f_name) + 1;
      char *path = new char[pathlen];
      snprintf(path, pathlen, "%s/%s", p, f_name);
      
      f_file = fopen(path, access == DB::CREATE ? "w" : "r");
      
      if(!f_file){
	throw(PosixError(errno, path));
      }

      delete [] path;
    }
  }

  return f_file;
}


//----------------------------------------------------------
void DBTable::insert(int typecode, ...)
{
  FILE *out = file(DB::CREATE);
  va_list ap;

  va_start(ap, typecode);

  fprintf(out, "%d\n%d\n", f_schema_code, f_cols);

  int cols_found = 0;
  
  while(typecode != 0){
    switch(typecode){
    case STRING_CODE:
      {
	const char *str = va_arg(ap, const char*);
	fprintf(out, "%d\n%ld\t%s\n", STRING_CODE, (long)strlen(str), str);
      }
      break;

    case -STRING_CODE:
      {
	const char *str = va_arg(ap, const char*);
	size_t len = va_arg(ap, size_t);
	fprintf(out, "%d\n%ld\t", STRING_CODE, (long)len );
	fwrite ( str, len, 1, out );
	fputc( '\n', out);
      }
      break;

    case COMPRESSED_STRING_CODE:
      {
	const char *comp_agent  = va_arg(ap, const char* );
	const char *str = va_arg(ap, const char* );

	fprintf(out, "%d\n%s\n%ld\t%s\n", COMPRESSED_STRING_CODE,comp_agent,
		(long)strlen(str), str );
      }
      break;

   case -COMPRESSED_STRING_CODE:
      {
	const char *comp_agent  = va_arg(ap, const char* );
	const char *str = va_arg(ap, const char* );

	size_t len = va_arg(ap, size_t );
	fprintf(out, "%d\n%s\n%ld\t", COMPRESSED_STRING_CODE,
		                     comp_agent,
		                     (long)len
		);

	fwrite( str, len, 1, out );
	fputc('\n', out);
      }
      break;
	

    case OID_CODE:
      {
	const char *oid = va_arg(ap, const char*);
	fprintf(out, "%d\n%s\n", OID_CODE, oid);
      }
      break;
      
    case INTEGER_CODE:
      {
	int x = va_arg(ap, int);
	fprintf(out, "%d\n%d\n", INTEGER_CODE, x);
      }
      break;

    case SHORT_LIST_CODE:
      {
	int qty = va_arg(ap, int);
	int code = va_arg(ap, int);

	fprintf(out, "%d\n#\n", SHORT_LIST_CODE);
	
	switch(code){
	case INTEGER_CODE:
	  {
	    int *items = va_arg(ap, int*);

	    for(int i = 0; i < qty; i++){
	      fprintf(out, "%d\n%d\n", code, items[i]);
	    }
	  }
	  break;

	case STRING_CODE:
	  {
	    const char **items = va_arg(ap, const char**);

	    for(int i = 0; i < qty; i++){
	      fprintf(out, "%d\n%ld\t%s\n",
		      code, (long)strlen(items[i]), items[i]);
	    }
	  }
	  break;
	  
	case OID_CODE:
	  {
	    const char **items = va_arg(ap, const char**);

	    for(int i = 0; i < qty; i++){
	      fprintf(out, "%d\n%s\n",
		      code, items[i]);
	    }
	  }
	  break;
	  
	default:
	  fprintf(stderr, "Internal error: unknown database type code: %d\n",
		  code);
	  abort();
	}

	fprintf(out, "#\n");

	break;
      }
      
    case OID_LIST_CODE:
      {
	int qty = va_arg(ap, int);

	fprintf(out, "%d\n#\n", OID_LIST_CODE);
	
	const char **items = va_arg(ap, const char**);

	for(int i = 0; i < qty; i++){
	  fprintf(out, "%s\n", items[i]);
	}

	fprintf(out, "#\n");

	break;
      }
      
    default:
      fprintf(stderr, "Internal error: unknown database type code: %d\n",
	      typecode);
      abort();
    }

    cols_found++;
    
    typecode = va_arg(ap, int);
  }

  va_end(ap);
  
  fflush(out); /* @# some routines are sloppy and don't
		* close their tables!
		*/
  
  assert(cols_found == f_cols);
}



//----------------------------------------------------------
void DBTable::insert_untagged(int typecode, ...)
{
  FILE *out = file(DB::CREATE);
  va_list ap;

  va_start(ap, typecode);

  fprintf(out, "%d\n", f_schema_code);

  if(f_start){
    fprintf(out, "+");
    f_start = 0;
  }

  int cols_found = 0;
  
  while(typecode != 0){
    switch(typecode){
    case STRING_CODE:
      {
	const char *str = va_arg(ap, const char*);
	fprintf(out, "%ld\t%s\n", (long)strlen(str), str);
      }
      break;

    case -STRING_CODE:
      {
	const char *str = va_arg(ap, const char*);
	size_t len = va_arg(ap, size_t);
	fprintf(out, "%ld\t", (long)len );
	fwrite ( str, len, 1, out );
	fputc( '\n', out);
      }
      break;

    case OID_CODE:
      {
	const char *oid = va_arg(ap, const char*);
	fprintf(out, "%s\n", oid);
      }
      break;
      
    case INTEGER_CODE:
      {
	int x = va_arg(ap, int);
	fprintf(out, "%d\n", x);
      }
      break;

    default:
      fprintf(stderr, "Internal error: unknown database type code: %d\n",
	      typecode);
      abort();
    }

    cols_found++;
    
    typecode = va_arg(ap, int);
  }

  va_end(ap);
  
  fflush(out); /* @# some routines are sloppy and don't
		* close their tables!
		*/
  
  assert(cols_found == f_cols);
}



//----------------------------------------------------------
void DBTable::start_list()
{
  this->f_start = 1;
}


//----------------------------------------------------------
void DBTable::end_list()
{
  fprintf(file(DB::CREATE), "-\n");
  f_start = 0;
}


//----------------------------------------------------------
DBCursor::DBCursor(DBTable &t)
{
  f_table = &t;
  f_start = -1;
  
  f_fields = new StringList();
  f_list = NULL;
}


//----------------------------------------------------------
DBCursor::~DBCursor()
{

  // this is for the last record
  delete f_fields;
  if ( f_list ) delete f_list;
}


//----------------------------------------------------------

void DBCursor::string_field(FILE *fp, char **out, size_t *lenOut)
{
  size_t len = 0;
  int io;

  /* fscanf is weird, so we do it ourselves... */
  while(isdigit(io = fgetc(fp))){
    len = len * 10 + (io - '0');
  }
  FRIENDLY_ASSERT(io == '\t');
  
  char *str = new char[len + 1];
  io = fread(str, sizeof(str[0]), len+1, fp); /* read \n also */

  FRIENDLY_ASSERT(io == len+1);

  str[len] = 0; /* replace \n with 0 (just in case...) */

  if(out){
    f_fields->add(str);
    *out = str;

    if(lenOut) *lenOut = len;
  }else{
    delete [] str;
  }
}



void DBCursor::int_field(FILE *fp, int *out)
{
  int an_int;
  int io;
  
  io = fscanf(fp, "%d\n", &an_int);

  FRIENDLY_ASSERT(io == 1);
	  
  if(out) *out = an_int;
}


void DBCursor::short_list(FILE *fp, int *qout, int ltype, void *out)
{
  int c;
  int ret;
      
  c = fgetc(fp);
  FRIENDLY_ASSERT(c == '#');

  c = fgetc(fp);
  FRIENDLY_ASSERT(c == '\n');
      
  switch(ltype){
  case STRING_CODE:
    {
      typedef const char** ccpp;
      ccpp *cpout = (ccpp*)out;
	  
      assert(f_list == NULL); /* only one SHORT_LIST per record supported */
      f_list = new StringList;

      while((c = fgetc(fp)) != '#'){
	char *item;
	int ftype;
	
	ungetc(c, fp);
	ret = fscanf(fp, "%d\n", &ftype);
	if(ret == 0) throw(PosixError(errno, "Unable to fscanf\n"));
	FRIENDLY_ASSERT(ftype == STRING_CODE);
	
	string_field(fp, &item, NULL);
	f_list->append(item);
      }

      *cpout = f_list->array();
      *qout = f_list->qty();
    }
    break;
	
  default:
    abort(); /* only strings supported */
  }

  c = fgetc(fp);

  FRIENDLY_ASSERT(c == '\n');
}


int DBCursor::next(int typeCode, ...)
{
  int ret = 1;
  FILE *fp = f_table->file(DB::READ);
  int io;
  int recordClass;
    
  if(f_start < 0){ /* on first call to next(), reset the file */
    rewind(fp);
  }
  
  f_start = ftell(fp);
  io = fscanf(fp, "%d\n", &recordClass); /* get record code */

  if(io != EOF){ /* got any data? */
    
    FRIENDLY_ASSERT(io == 1);

    // clean up previous fields first if they exist
    f_fields->reset();
    delete f_list; f_list = NULL;

    va_list ap;
    va_start(ap, typeCode);

    int fieldQty;

    io = fscanf(fp, "%d\n", &fieldQty); /* get field count */
    FRIENDLY_ASSERT(io == 1);

    /* iterate over fields in the input stream... */
    while(fieldQty--){
      int fieldCode;
  
      io = fscanf(fp, "%d\n", &fieldCode); /* get field type */
      FRIENDLY_ASSERT(io == 1);
      
      assert(typeCode); /* make sure caller didn't give too few args */
      
      switch(fieldCode){
      case STRING_CODE:
	{
	  char **data = NULL;
	  size_t *len = NULL;

	  if (fieldCode == typeCode || (fieldCode + typeCode) == 0) {
	    data = va_arg(ap, char**);

	    if (fieldCode != typeCode) {
	      len = va_arg(ap, size_t*);
	    }
	  }
	  
	  string_field(fp, data, len);
	}
	break;

      case INTEGER_CODE:
	int_field(fp, fieldCode == typeCode ? va_arg(ap, int*) : 0);
	break;

      case SHORT_LIST_CODE:
	{
	  int *qout = va_arg(ap, int *);
	  int ltype = va_arg(ap, int);
	  void *out = va_arg(ap, void*);
	  short_list(fp, qout, ltype, out);
	}
	break;
    
      default:
	abort();
      }

      typeCode = va_arg(ap, int);
    }

    assert(typeCode == 0); /* check for end marker */
    
    va_end(ap);
    
  }else{
    ret = 0; /* EOF found... no record */
  }

  return ret;
}


void DBCursor::undoNext()
{
  FILE *fp = f_table->file(DB::READ);

  if(f_start >= 0){
    if(fseek(fp, f_start, 0) < 0){
      throw(PosixError(errno, f_table->name()));
    }
  }else{
    abort(); /* @# throw("no next to undo!") */
  }
}

//----------------------------------------------------------------
void DBCursor::local_rewind()
{
  f_start = -1;
}

//----------------------------------------------------------------
int DBCursor::tell()
{
  if ( f_start == -1 ) {
    return(0);
  }
  else {
    return f_start;
  }
}

//----------------------------------------------------------------
void DBCursor::seekToRec( int pos )
{
  FILE *fp = f_table->file(DB::READ);
  if ( pos >= 0 ){
    if (fseek(fp, pos, 0) < 0 ) {
      throw(PosixError(errno, f_table->name()));
    }
  }
  else{
    abort();
  }
}