// This sourcefile is created by Peter Jodda / peter@jodda.de
// It is under the Peter Jodda license:
// Everyboy may use it on his own risk. This header must stay in the file!
// If you expand this file, please contact me, that I can integrate the
// enhancemants in the original file.
//
//
// basisdaten.c
//
// log 
// 04.10.98 - initial module

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include "text_util.h"

#include "basisdaten.h"

static char * StrNCopy(char *Ziel, char *Quelle,int Maximal)
{
   char *in_ziel;
   int   i;

   if(Ziel==NULL)    /* leerer zielzeiger ?? */
      return NULL;

   if(Quelle==NULL)   /* quelle leer, dann ziel nur loeschen */
   {
      *Ziel='\0';
      return Ziel;
   } /* if leere quelle */

   i=0;
   in_ziel = Ziel;

   // jetzt so lange kopieren bis maximal zeichen erreicht, oder 
   // quelle zu ende.
   //
   while( (i<Maximal) && (*Quelle!='\0') )
   {
      *in_ziel++ = *Quelle++;
      i++;
   } /* while zeichen da und kleiner als maximal */

   *in_ziel='\0';  /* ziel auf jeden fall terminieren */
   return Ziel;    /* zeiger auf ziel zurueck */
} /* StrNCopy */


static bool StringCompareUpper (char *string1, char *string2)
{
   int Laenge, i;

   Laenge = strlen (string1);
   if ( Laenge != strlen (string2) )
      return false;

   for (i = 0; i < Laenge; i++)
   {
      if ( toupper (string1[i]) != toupper (string2[i]) )
         return false;
   }

   return true;
}


/*============================================================*/
/* basisdaten struktur besorgen und initialisieren.
 * dabei werden noch keine daten gelesen 
 */
BasisDatenType::BasisDatenType()
{

   // initialisieren
   veraendert    = false;
   datei_gelesen = false;
   strcpy(name,"");


} // basisdaten konstruktor 



/*============================================================*/
/* basisdaten aus eine datei einlesen 
 */

bool BasisDatenType::BasisDatenLesen(char *dateiname)
{
   bool gelesen;

   datei_gelesen = false;
   veraendert = false;


  /* parameter auf die gueltigkeit testen */

   if(dateiname ==NULL)
      return false;
  
   if(strlen(dateiname)<=0)
      return false;

   /* eventuell alte daten loschen */
   TextRemoveAlleZeilen();
 

  /* dateinamen speichern */
  strncpy(name,dateiname,299);

  /* hier jetzt die datei lesen */
  gelesen = TextLoadText(dateiname); 
  if(!gelesen)
   {
    return false;
   } /* if fehler beim lesen */


  /* merken, das gelesen */
  datei_gelesen = true;

  
  return true;
 } /* BasisDatenLesen */


/*============================================================*/
/* basisdaten wieder schreiben.
 * wenn als dateiname NULL uebergeben wird, dann wird
 * der dateiname vom lesen genommen.
 */

bool BasisDatenType::BasisDatenSchreiben(char *dateiname)
{
   char localname[300];
   bool geschrieben;

   /* daten nicht veraendert, dann braucht man nicht schreiben */
   if(!veraendert)
      return true;

   if(dateiname ==NULL)
   {
      /* dateinamen aus der struktur nehmen */
      if(strlen(name)<1)
      {
         /* kein name in der struktur ?? */
         return false;
      }
      strncpy(localname,name,299);
   }
   else /* uebergebenen namen nehmen */
   {
      strncpy(localname,dateiname,299);
   }  

   /* datei jetzt schreiben */
   geschrieben = TextSaveText(localname);
   if(!geschrieben)
      return false;

   veraendert = false;

   return true;
} /* BasisDatenSchreiben */


/*============================================================*/
/* basis daten verlassen.
 * es wird nichts gesichert, sondern nur die
 * datenstrukturen abgebaut.
 */

BasisDatenType::~BasisDatenType()
{

} /* BasisDatenExit */

/*============================================================*/
/* datenzeile mit der id suchen. wenn gefunden, dann wird die
 * zeile zurueckgegeben. in nummer wird die zeilennummer fuer
 * eventuell aenderungen zurueckgegeben.
 */
char *BasisDatenType::locate_zeile(char *id,int *nummer)
{
   char *zeile;
   char vorne[400];  
   int  anzahl,i,id_laenge,zeile_laenge;

   /* nummer ersteinmal auf nicht gefunden setzen */
   if(nummer != NULL)
      *nummer = -1;
   if(id==NULL)
      return NULL;

   id_laenge= strlen(id);
   if(id_laenge<1)	/* id sollte schon da sein */
      return NULL;

   anzahl = TextGetZeilenAnzahl();
   if(anzahl<1)		/* text sollte auch da sein */
      return NULL;

   /* schleife ueber alle zeilen */
   for(i=0;i<anzahl;i++)
   {
      char *in_zeile;
      zeile = TextGetZeile(i);
      if(zeile ==NULL)
         continue;
      /* fprintf(stderr,"die zeile ist <%s>\n",zeile); */
      zeile_laenge = strlen(zeile);
      if(zeile_laenge < id_laenge)
         continue;

      if(*zeile <'A') /* beginnt nicht mit buchstaben, dann auslassen */
         continue;
    
      StrNCopy(vorne,zeile,id_laenge);
      /* fprintf(stderr,"<%s>|<%s>\n",vorne,id); */

      if(StringCompareUpper(vorne,id)==true)
      {
         /* fprintf(stderr,"Id stimmt\n"); */
         /* id string stimmt schon, nach der id muss noch ein 
          * gleichheitszeichen kommen 
          */
         in_zeile = &zeile[id_laenge];

         /* blanks danach ueberspringen */
         while(*in_zeile ==' ' || 
               *in_zeile ==0x08 /* TAB*/ )
            in_zeile ++;

         if(! (*in_zeile =='='))
            continue;		/* kein gleichheitszeichen */

         /* richtige zeile gefunden */
         if(nummer != NULL)
            *nummer =i;
         return zeile;

      } /* if strings gleich */

   } /* for i // alle zeilen durch */

   /* nicht gefunden, null zurueck */
   return NULL;
} /* locate_zeile */


/*============================================================*/


bool BasisDatenType::BasisDatenReadInt(char *id,
		int *wert)
{
   char *zeile,*in_zeile;
   int  zahl,gescannt;


   /* zeile aus der textbasis holen */
   zeile = locate_zeile(id,NULL);
   if(zeile ==NULL)
   {
      /* fprintf(stderr,"fehler bei locate zeile\n"); */
      return false;
   }

   /* nach dem gleichheitszeichen gehen */
   in_zeile = strchr(zeile,'=');
   if(in_zeile ==NULL)
      return false;
   in_zeile ++;

   /* zahl einlesen */
   gescannt = sscanf(in_zeile,"%d",&zahl);
   if(gescannt ==0)
      return false;
   *wert = zahl;    
  
   /* alles ok */
   return true;
} /* BasisDatenReadInt */

/*============================================================*/


bool BasisDatenType::BasisDatenReadFloat(char *id,
		float *wert)
{
    float zahl;
    char  *zeile,*in_zeile;
    int   gescannt;


   /* zeile aus der textbasis holen */
   zeile = locate_zeile(id,NULL);
   if(zeile ==NULL)
   {
      return false;
   }

   /* nach dem gleichheitszeichen gehen */
   in_zeile = strchr(zeile,'=');
   if(in_zeile ==NULL)
      return false;
   in_zeile ++;

   /* zahl einlesen */
   gescannt = sscanf(in_zeile,"%f",&zahl);
   if(gescannt ==0)
      return false;
   *wert = zahl;    
  
   /* alles ok */
   return true;
} /* BasisDatenReadFloat */

/*============================================================*/


bool BasisDatenType::BasisDatenReadBool(char *id,
		bool *wert)
{
   char *zeile,*in_zeile;


   /* zeile aus der textbasis holen */
   zeile = locate_zeile(id,NULL);
   if(zeile ==NULL)
   {
      return false;
   }

   /* nach dem gleichheitszeichen gehen */
   in_zeile = strchr(zeile,'=');
   if(in_zeile ==NULL)
      return false;
   in_zeile ++;

   while(*in_zeile== ' ' || 
        *in_zeile ==0x08 /* TAB*/ ) 
      in_zeile++;
   if(*in_zeile =='T' || *in_zeile =='t')
   { 
      *wert = true;
      return true;
   } 
   if(*in_zeile =='F' || *in_zeile =='f')
   { 
      *wert = false;
      return true;
   } 
   if(*in_zeile =='0')
   { 
      *wert = false;
      return true;
   } 
   if(*in_zeile =='1')
   { 
      *wert = true;
      return true;
   } 


   /* nicht ok */
   return false;
} /* BasisDatenReadBool */

/*============================================================*/


bool BasisDatenType::BasisDatenReadString(char *id,
		char *wert)
{
   char *zeile,*in_zeile;

   /* zeile aus der textbasis holen */
   zeile = locate_zeile(id,NULL);
   if(zeile ==NULL)
   {
      return false;
   }

   /* nach dem gleichheitszeichen gehen */
   in_zeile = strchr(zeile,'=');
   if(in_zeile ==NULL)
      return false;
   in_zeile ++;

   /* daten zurueckkopieren */
   strcpy(wert,in_zeile);

   /* alles ok */
   return true;
} /* BasisDatenReadString */


/*============================================================*/

bool BasisDatenType::BasisDatenWriteInt(char *id,
		int wert)
{
   char *zeile;
   char neue_zeile[500];
   int  alte_zeile;

   if( id == NULL)
      return false;

   /* zeile aus der textbasis holen */
   zeile = locate_zeile(id,&alte_zeile);
 
   sprintf(neue_zeile,"%s=%d",id,wert);
   if(zeile ==NULL)
   {
      TextAddTextZeile(neue_zeile);
   }
   else  /* originalzeile war da */
   {
      /* wenn original == neue zeile, dann nicht ersetzen */
      if(strcmp(zeile,neue_zeile)==0)
      {
         return true;
      }
      TextReplaceZeile(alte_zeile,neue_zeile);
   } /* else mit original */

   veraendert = true;
   return true;
} /* BasisDatenWriteInt */

/*============================================================*/


bool BasisDatenType::BasisDatenWriteFloat(char *id,
		float wert)
{
   char *zeile;
   char neue_zeile[500];
   int  alte_zeile;

   if( id == NULL)
      return false;

   /* zeile aus der textbasis holen */
   zeile = locate_zeile(id,&alte_zeile);
 
   sprintf(neue_zeile,"%s=%f",id,wert);
   if(zeile ==NULL)
   {
      TextAddTextZeile(neue_zeile);
   }
   else /* originalzeile war da */
   {
      /* wenn original == neue zeile, dann nicht ersetzen */
      if(strcmp(zeile,neue_zeile)==0)
      {
         return true;
      }
      TextReplaceZeile(alte_zeile,neue_zeile);
   } /* else mit original */

   veraendert = true;
   return true;
} /* BasisDatenWriteFloat */

/*============================================================*/

bool BasisDatenType::BasisDatenWriteBool(char *id,
		bool wert)
{
   char *zeile;
   char neue_zeile[500];
   int  alte_zeile;

   if( id == NULL)
      return false;

    /* zeile aus der textbasis holen */
    zeile = locate_zeile(id,&alte_zeile);
 
   if(wert)
   {
      sprintf(neue_zeile,"%s=true",id);
   }
   else /* ! wert */
   {
      sprintf(neue_zeile,"%s=false",id);
   }

   if(zeile ==NULL)
   {
      TextAddTextZeile(neue_zeile);
   }
   else /* originalzeile war da */
   {
      /* wenn original == neue zeile, dann nicht ersetzen */
      if(strcmp(zeile,neue_zeile)==0)
      {
         return true;
      }
      TextReplaceZeile(alte_zeile,neue_zeile);
   }  /* else mit original */

   veraendert = true;
   return true;
} /* BasisDatenWriteBool */

/*============================================================*/

bool BasisDatenType::BasisDatenWriteString(char *id,
		char *wert)
{
   char *zeile;
   char neue_zeile[500];
   int  alte_zeile;

   if(id == NULL)
      return false;

    /* zeile aus der textbasis holen */
    zeile = locate_zeile(id,&alte_zeile);
 
   sprintf(neue_zeile,"%s=%s",id,wert);
   if(zeile ==NULL)
   {
      TextAddTextZeile(neue_zeile);
   }
   else /* originalzeile war da */
   {
      /* wenn original == neue zeile, dann nicht ersetzen */
      if(strcmp(zeile,neue_zeile)==0)
      {
         return true;
      }

      TextReplaceZeile(alte_zeile,neue_zeile);
   }  /* else mit original */

   veraendert = true;
   return true;
} /* BasisDatenWriteString */

/*============================================================*/


