/*

  Class Cdreader 2002 Anton Kulchitsky implementation

  ver. 1.01

  see file dreader.h for details

 */

#include <string>
#include <fstream>
#include <iostream>

#include <stdlib.h>
#include <stdio.h> 

using namespace std;

#include "dreader.h"

//local function to define size of file. Return 0 for mistake
int filesize(const char* name)
{
  FILE* F = fopen(name,"r");

  if(F==NULL) return 0;

  fseek(F,0,SEEK_END); //set position to the end of file
  int length = ftell(F);   //define number of position=> this is its length
  fclose(F);  //close file

  return length; //we found it
}

Cdreader::Cdreader()
{
  //file must be opened by Cdreader.open() if you use this constructor
}

Cdreader::Cdreader(const char* filename)
{
  open(filename);
}

Cdreader::~Cdreader()
{
  delete []buffer;  //never forget?
  delete []group;
}

//open and reading file
void Cdreader::open(const char* filename)
{
  //creating and reading buffer for file content
  int length = filesize(filename);  //filesize (already checked for overflow)

  if(length==0){
    ErrorMsg(BAD_FILE,filename);
    exit(1);
  }

  //allocate memory for the buffer;
  buffer = new char[length+1];
  group = new char[length+1];

  //reading file in buffer (skip all 0 characters)
  ifstream In(filename);
  char ch;
  for(int i=0;i<length;++i){
    In.get(ch); 
    if(ch!=char(0)) buffer[i]=ch;
    else buffer[i]=char(1);
  }
  buffer[length]=char(0); //last character means the end of string
}

//read integer number after string str in the current file
int Cdreader::iread(const char* FieldName, const char* GroupName)
{
  int n=0;  //result

  //Locate a group for work
  switch(LocateGroup(GroupName)){  //locate group
  case 0: break; //everything is fine
  case NO_GROUP_START: 
    ErrorMsg(NO_GROUP_START,FieldName,GroupName);
    return n;
  case NO_GROUP_END: 
    ErrorMsg(NO_GROUP_END,FieldName,GroupName);
    return n;
  }

  char *p = strstr(group,FieldName);
  if(p==NULL) ErrorMsg(NOT_FOUND, FieldName, GroupName);
  else  n = atoi(p+strlen(FieldName));

  return n;
}

//read float (double) number after string str in the current file
double Cdreader::fread(const char* FieldName, const char* GroupName)
{
  double f=0; //result, default=0

  //Locate a group for work
  switch(LocateGroup(GroupName)){  //locate group
  case 0: break; //everything is fine
  case NO_GROUP_START: 
    ErrorMsg(NO_GROUP_START,FieldName,GroupName);
    return f;
  case NO_GROUP_END: 
    ErrorMsg(NO_GROUP_END,FieldName,GroupName);
    return f;
  }

  char *p = strstr(group,FieldName);
  if(p==NULL) ErrorMsg(NOT_FOUND, FieldName, GroupName);
  else  f = atof(p+strlen(FieldName));

  return f;
}

//read string outstr after string str in the current file
//(between ""), not more than maxlength simbols
//do not check if outstr has enough length!!! must be at least maxlength+1 !!!
void Cdreader::strread(char* outstr, int maxlength,
	       const char* FieldName, const char* GroupName)
{
  outstr[0]=char(0); //initial meaning

  //Locate a group for work
  switch(LocateGroup(GroupName)){  //locate group
  case 0: break; //everything is fine
  case NO_GROUP_START: 
    ErrorMsg(NO_GROUP_START,FieldName,GroupName);
    return;
  case NO_GROUP_END: 
    ErrorMsg(NO_GROUP_END,FieldName,GroupName);
    return;
  }

  char *p = strstr(group,FieldName);
  if(p==NULL){
    ErrorMsg(NOT_FOUND, FieldName, GroupName);
    return;  //immidiate exit
  }
  p = p+strlen(FieldName); //shift to the end of str

  //seeking for "
  char* quat1 = strchr(p,'\"');
  if(quat1==NULL){
    ErrorMsg(NO_LEFT_QUAT,FieldName,GroupName);
    return; //immidiate exit
  }
  //seeking for closed "
  char* quat2 = strchr(quat1+1,'\"');
  if(quat2==NULL){
    ErrorMsg(NO_RIGHT_QUAT,FieldName,GroupName);
    return;  //immidiate exit
  }

  int length = (int)quat2-(int)quat1 -1;
  if(maxlength<length){
    ErrorMsg(TOO_LONG_STRING, FieldName, GroupName);
    length = maxlength;
  }

  //we have now the location of the string
  //end write this string into the output string
  for(int i=0;i<length;++i){
    outstr[i] = quat1[i+1];
  }

  outstr[length] = char(0);  //end of string!
}

//Group definition and locator!!! Group format is defined here
int Cdreader::LocateGroup(const char* GroupName)
{
  //trivial case
  if(GroupName==NULL){
    strcpy(group,buffer);  //whole buffer is a group
    return 0;  //no error return
  }

  /*
    I have tried to avoid allocation memory for the group,
    but it was not convenient and worked bad.
    Current solution takes twice memory but works
    very clear and simple 
  */

  //start to seek a group location
  char* GStartWord = new char[strlen(GroupName)+4];
  char* GEndWord = new char[strlen(GroupName)+4];

  (void)sprintf(GStartWord,"[%s::",GroupName);  //begin of group
  (void)sprintf(GEndWord,"::%s]",GroupName);  //end of group

  char* GStart=strstr(buffer,GStartWord);  //real start
  if(GStart==NULL) return NO_GROUP_START; //no group start
  else{
    GStart+=(strlen(GStartWord)); //shift to the start of group content
  }

  char* GEnd=strstr(GStart,GEndWord);  //real end: seek after beginning
  if(GEnd==NULL) return NO_GROUP_END; //no group start

  //now the only copy grooup from buffer to group
  int length = int(GEnd)-int(GStart);
  strncpy(group,GStart,length);
  group[length]=char(0);

  //time to release the memory
  delete [] GStartWord;
  delete [] GEndWord;

  return 0;
}

//Error Messages all located in the function ErrorMsg:
void Cdreader::ErrorMsg(int nError, const char* FieldName, const char* GroupName)
{
  switch(nError){

  case NOT_FOUND:
    cerr << "Warning (dreader): substring \"" << FieldName 
	 << "\" is not found in data file";
    if(GroupName!=NULL) cerr << " in its group \"" << GroupName << "\"" << endl;
    else cerr << endl;
    cerr << "Accordance variable will be set at 0" << endl;
    break;

  case NO_GROUP_START:
    cerr << "Warning (dreader): Group name \"" << GroupName 
	 << "\" is not found in data file" << endl;
    cerr << "Accordance variable will be set at 0" << endl;
    break;

  case NO_GROUP_END:
    cerr << "Warning (dreader): Group \"" << GroupName 
	 << "\" has no end operator: group is not recognized" << endl;
    cerr << "Accordance variable will be set at 0" << endl;
    break;

  case NO_LEFT_QUAT:
    cerr << "Warning (dreader): open \" sign was not found after string " 
	 << FieldName;
    if(GroupName!=NULL) cerr << " in its group \"" << GroupName << "\"" << endl;
    else cerr << endl;
    cerr << "Accordance string will be set at 0" << endl;
    break;

  case NO_RIGHT_QUAT:
    cerr << "Warning (dreader): close \" sign was not found for the string field " 
	 << FieldName;
    if(GroupName!=NULL) cerr << " in its group \"" << GroupName << "\"" << endl;
    else cerr << endl;
    cerr << "Accordance string will be set at 0" << endl;
    break;

  case TOO_LONG_STRING:
    cerr << "Warning (dreader): the string placed after " << FieldName;
    if(GroupName!=NULL) cerr << "in its group \"" << GroupName << "\"" << endl;
    cerr << "is longer than supposed in program" << endl;
    cerr << "Only part of the string will be read" << endl;
    break;

  case BAD_FILE:
    cerr << "Error (dreader): \"" << FieldName 
	 << "\" empty or not-existing file" << endl;
    break;

  default:
    cerr << "Unrecognized error (dreader)" << endl;
    break;
  }
}