#include <iostream.h>
#include <fstream.h>
#include <strstrea.h>
#include <iomanip.h>
#include <string.h>
#include <stdlib.h>


// Coduri returnate de program:
// -0  - iesire normala
// -1 - banca.dat nu poate fi gasit
// -2 - inregistrarea nu poate fi gasita in fisier.
// -3 - fatal error for file operations


#define NMAX_CONT             100
// Numarul maxim admix de cifre pentru un cont
#define NMAX_NUME_TITULAR     100
// Numarul maxim de caractere ce poate fi stocat in campul corespunzator
// numelui titularului. Numarul maxim admis de caractere pentru numele 
// titularului contului respectiv.
#define NMAX_VALUTE           2
// Numarul maxim admis de valute
#define NMAX_PAROLA           100
// Numarul maxim admis de caractere pentru parola
#define DOBANDA               (14/100)


typedef struct 
{
  char titular[NMAX_NUME_TITULAR], numar[NMAX_CONT];
  // Nu se folosesc pointeri in acest caz pentru ca atunci cand se face
  // copierea unui obiect pe stiva s-ar copia numai
  // pointeri. In momentul in care se iese dintr-o procedura
  //  se va apela un destructor care ar distruge
  // datele obiectului original (mai precis continutul variabilelor titular si
  // numar). Ori este posibil ca in aceste zone de memorie (cele indicate de
  // "titular" si "nume" - ca pointeri)  sa fie inca date utile.
  unsigned long int sold;
  unsigned valuta;
} Inregistrare;



class ContBancar
{
// Datele trebuie protejate de accesul direct din exterior
// Accesul la date se va face controlat, numai prin metodele
// membre ale clasei.
private:
  Inregistrare Continut;
// Datele nucleu continute de obiect
  void InitializareMemorieObiect();
// Se ocupa de alocarea variabilelor continute in obiect
// Completed
  void StergereMemorieObiect();
// Se ocupa de dealocarea variabilelor continute in obiect
// Completed

public:   
  ContBancar();
// Constructor simplu (vid) folosit pentru obiectele temporare (de exemplu la 
// operatorii supraincarcati).
  ContBancar(const char *, const char *, const unsigned long int, 
const unsigned);
  // Constructor din date elementare
  // Completed
  ContBancar(const int);
  // Constructor care foloseste intrarea de la consola
  ContBancar(const char *);
  // Parametrul constructorului are in aceaste situatii si rolul
  // de a selecta varianta dorita de constructor (cu intrare de la consola, 
  // respectiv cu intrare din fisier).
  ContBancar operator =(ContBancar);
  ContBancar operator +=(ContBancar);
  ContBancar operator +=(unsigned long int);
  ContBancar operator -=(unsigned long int);
  friend ostream &operator << (ostream &, ContBancar &);
  // Completed
  friend istream &operator >> (istream &stream, ContBancar &);
  // Completed
  // Ultimii doi operatori (cei de instrare/iesire, "<<" si ">>" care sunt
  // supraincarcati) trebuie declarati ca "friend" pentru a avea acces la 
  // datele instantei acestei clase (date care sunt private).
  // Acesta este modul tipic de supraincarcare a operatorilor "<<" si ">>" 
  // in C++.
  void depun(unsigned long int);
  void retrag(unsigned long int);
  unsigned long int spune_total();
  ~ContBancar();
};

void ContBancar::depun(unsigned long int x)
{
  Continut.sold+=x;
}

void ContBancar::retrag(unsigned long int x)
{
  Continut.sold-=x;
  if (Continut.sold<0)
    Continut.sold=0;
}

unsigned long int ContBancar::spune_total()
{
  unsigned long int total=0;
  ifstream banca("banca.dat", ios::binary | ios::in);
  while (!banca.eof())
    {
      ContBancar tmp;
      banca.read((unsigned char *)&tmp, sizeof(Inregistrare));
      total+=tmp.Continut.sold;
    }
  banca.close();
  return total;
}

ContBancar::ContBancar()
{
  this->InitializareMemorieObiect();
}

ContBancar::ContBancar(const char *titular, const char *numar, 
		       const unsigned long int sold, const unsigned valuta)
  // Constructorul din date elementare
  // Completed
{
  this->InitializareMemorieObiect();
  ostrstream iesire_titular(Continut.titular, NMAX_NUME_TITULAR);
  ostrstream iesire_numar(Continut.numar, NMAX_CONT);
  // Se utilizeaza acestea pentru a evita folosirea unor apeluri specifice
  // pentru limbajul C (cum ar fi de exemplu strcpy(), memcpy(), malloc(),
  // calloc(), free() etc.
  // In intregul program se va evita folosirea unor functii specifice 
  // limbajului C.
  Continut.sold=sold;
  Continut.valuta=valuta;
  iesire_titular<<titular<<ends;
  iesire_numar<<numar<<ends; 
  // ends (manipulator) <=> end string (null char) i. e. '\0'
}

ContBancar::ContBancar(const int i)
  // Constructor folosind intrarea de la consola
  // Password reading without echo remained.
{
//   char parola[NMAX_PAROLA];
  this->InitializareMemorieObiect();
  cout<<"Numele este: ";
  cin.get(Continut.titular, NMAX_NUME_TITULAR+1);
  cout<<"Numarul contului este: ";
  cin>>Continut.numar;
//   cout<<"Parola este: ";
//   cin.get(parola, NMAX_PAROLA+1);
  cout<<"Soldul este: ";
  cin>>Continut.sold;
  cout<<"Valuta folosita (0-"<<NMAX_VALUTE<<"): ";
  cin>>Continut.valuta;
}

ContBancar::ContBancar(const char *numar)
  // Completed
{
  register int gasit=0;
  Inregistrare tmp;
  ifstream banca("banca.dat", ios::in | ios::binary);
  if (!banca)
    {
      cerr<<"Fisierul \"banca.dat\" nu exista... Voi parasi aplicatia acum..."
<<endl;
      cerr<<"(Mesaj din ContBancar::ContBancar(char *) ---> constructor"<<endl;
      exit(-1);
    }
  while (!banca.eof())
    {
      banca.read((unsigned char *)&tmp, sizeof(Inregistrare));
      if (!strcmp(numar, tmp.numar))
	{
	  gasit=1;
	  break;
	}
    }
  banca.close();
  if (!gasit)
    {
      cerr<<"Nu pot gasi respectivul cont in fisierul banca.dat"<<endl;
      cerr<<"Prin urmare obiectul nu poate fi initializat cu acest constructor"<<endl;
      cerr<<"Parasesc aplicatia..."<<endl;
      exit(-2);
    }
  else
    {
      banca.seekg((-1)*sizeof(Inregistrare), ios::cur);
      this->InitializareMemorieObiect();
      Continut.valuta=tmp.valuta;
      Continut.sold=tmp.sold;
      ostrstream iesire_titular(Continut.titular, NMAX_NUME_TITULAR);
      ostrstream iesire_numar(Continut.numar, NMAX_CONT);
      iesire_titular<<tmp.titular<<ends;
      iesire_numar<<tmp.numar<<ends; 
    }
}

void ContBancar::InitializareMemorieObiect()
  // Completed
{
  ostrstream iesire_titular(Continut.titular, NMAX_NUME_TITULAR);
  ostrstream iesire_numar(Continut.numar, NMAX_CONT);
  // Asocierea celor doua siruri cu stream-uri de iesire
  // Se putea scrie si:
  // ostrstream iesire_titular(Continut.titular, NMAX_NUME_TITULAR, ios::app);
  // ostrstream iesire_numar(Continut.numar, NMAX_CONT, ios::app);
  // dar aceasta inseamna ca daca dupa alocarea memoriei un sir indica spre
  // o zona de memorie in care nu se poate preciza ce se afla, atunci nu vom 
  // face altceva decat sa adaugam (ios::app - append) un caracter null intr-un
  // sir despre care nu stim unde se termina.
  // Deci vom initializa sirurile:
  iesire_titular<<ends;  // Sirurile sunt pentru inceput vide.
  iesire_numar<<ends;
  // Se suprescrie fiecare sir astfel: se pune cate un caracter '\0' pe prima
  // pozitie in sir.
  // Lipsa lui (ios::app) in declaratia cu "ostrstream" inseamna ca sirul
  // va fi suprascris la prima scriere (deci nu se va adauga in el la 
  // prima scriere).
}

void ContBancar::StergereMemorieObiect()  
  // Completed
{
  // In anumite situatii este util (din motive de securitate) ca anumite
  // variabile sa fie reinitializate cu valori nule.
  register int i;
  for (i=0; i<NMAX_CONT; i++)
    Continut.numar[i]='\0';
  for (i=0; i<NMAX_NUME_TITULAR; i++)
    Continut.titular[i]='\0';
}

ContBancar ContBancar::operator =(ContBancar operand2)
{
  Continut.sold+=operand2.Continut.sold;
  operand2.Continut.sold=0;
  return *this;
}

ContBancar ContBancar::operator +=(ContBancar operand2)
{
  Continut.sold+=operand2.Continut.sold;
  //  operand2.Continut.sold=0;
  return *this;
}

ContBancar ContBancar::operator +=(unsigned long int operand2)
{
  Continut.sold+=operand2;
  return *this;
}

ContBancar ContBancar::operator -=(unsigned long int operand2)
{
  if (operand2>Continut.sold)
    {
      cerr<<"Eroare in operatorul \"-=\""<<endl;
      exit(-5);
    }
  Continut.sold-=operand2;
  return *this;
}

ostream &operator << (ostream &stream, ContBancar &cont)
  // Completed
{
  // Se foloseste transmiterea prin referinta pentru a se evita 
  // apelarea destructorului pentru variabila instanta temporara copiata pe
  // stiva. Trebuie evitata modificarea instantei pe care am transmis-o
  // prin referinta aici.
  stream<<"Numele titularului: "<<cont.Continut.titular<<endl;
  stream<<"Numarul contului: "<<cont.Continut.numar<<endl;
  stream<<"Soldul: "<<cont.Continut.sold<<endl;
  stream<<"Valuta folosita: "<<cont.Continut.valuta<<endl;
  return stream;
}

istream &operator >> (istream &stream, ContBancar &cont)
  // Completed
{
  cout<<"Numele este: ";
  stream.get(cont.Continut.titular, NMAX_NUME_TITULAR+1);
  cout<<"Numarul contului este: ";
  stream>>cont.Continut.numar;
  cout<<"Soldul este: ";
  stream>>cont.Continut.sold;
  cout<<"Valuta folosita (0-"<<NMAX_VALUTE<<"): ";
  stream>>cont.Continut.valuta;
  return stream;
}

ContBancar::~ContBancar()
  // Completed
{
  // Intai salvarea continutului obiectului in fisier.
  // Daca "banca.dat" nu exista atunci va fi creata daca este posibil.
  // Daca nu este gasita o inregistrare cu acelasi numar de cont atunci
  // se adauga o noua inregistrare la sfarsitul fisierului. Daca este gasita
  // o inregistrare cu acelasi numar de cont atunci programil se pozitioneaza
  // pe acea inregistrare si o actualizeaza.
  register int gasit=0, count=0, stare_fisier=0;
  Inregistrare tmp;
  fstream banca("banca.dat", ios::binary | ios::in | ios::out);
  if (!banca)
    {
      cerr<<"Fisierul \"banca.dat\" nu exista si nu il pot genera... \
Voi parasi aplicatia acum..."<<endl;
      cerr<<"(Mesaj din ContBancar::~ContBancar() ---> destructor"<<endl;
      exit(-1);
    }
  while (!banca.eof() && !gasit)
    {
      banca.read((unsigned char *)&tmp, sizeof(Inregistrare));
      if (!strcmp(Continut.numar, tmp.numar))
	gasit=1;
      else
	if (!banca.eof())
	  count++;
    }
  stare_fisier=banca.rdstate();
  if ((stare_fisier & ios::eofbit) || (stare_fisier & ios::failbit))
    banca.clear();
  // Sterge toate erorile aparute la citire (daca acestea exista). Singurele
  // erori pe care le vom trata sunt cele referitoare la sfarsitul fisierului.
  // Nu vom trata ios::badbit. Fara aceasta stergere a erorilor
  // programul nu poate scrie datele in fisier. Erorile la care ne referim 
  // sunt: s-a atins EOF sau fisierul este gol.
  if (stare_fisier & ios::badbit)
    {
      cerr<<"Eroare fatala legata de operatiile cu fisierul \"banca.dat\"...\
Programul se va inchide..."<<endl;
      exit(-3);
    }
  banca.seekp(count*sizeof(Inregistrare), ios::beg);
  banca.write((unsigned char *)&Continut, sizeof(Inregistrare));
  banca.flush();
  banca.close();
  this->StergereMemorieObiect();
  cout<<"Destructorul a fost apelat."<<endl;
}


int main()
{
  // Liniile comentate contin un exemplu aidtional
//   cout<<"-------------------------------------------------------------------"<<
//     endl;
//   ContBancar *oInstanta1=new ContBancar();
//   // Se foloseste un constructor simplu cu care vom produce o instanta cu
//   // ajutorul careia vom exemplifica utilizarea operatorilor "<<" si ">>".
//   cout<<"Obiectul *oInstanta1 -----> Introduceti datele: "<<endl;
//   cin>>*oInstanta1; 
//   // Atentie: nu se foloseste pointer-ul, ci instanta spre care indica acesta
//   cout<<"Continutul obiectului *oInstanta1 este: "<<endl;
//   cout<<*oInstanta1;
//   delete oInstanta1;
//   // Aceeasi observatie ca si la (*).
  cout<<"-------------------------------------------------------------------"<<
    endl;
  ContBancar *oInstanta=new ContBancar("Mircea Stancu", "4",
				       10, 0);
  cout<<*oInstanta<<endl<<"Se scrie in fisier..."<<endl;
  delete oInstanta;
  cout<<"-------------------------------------------------------------------"<<
    endl;
  ContBancar *oInstanta2=new ContBancar("4");
  // S-a folosit constructorul care citeste din fisier.
  cout<<"La contul 4 avem: "<<*oInstanta2;
  cout<<"Acum veti modifica acest cont: "<<endl;
  // Pot fi adaugate si liniile de mai jos
//   cout<<"Va rugam nu modificati numarul contului, altfel se va genera un\
//  nou cont."<<endl;
//   cin>>*oInstanta2;
//   cout<<"Contul modificat este: "<<*oInstanta2<<endl;
  cout<<"Acest cont va fi scris acum in \"banca.dat\""<<endl;
  delete oInstanta2;
  // A fost apelat destructorul care a scris continutul obiectului inapoi in
  // fisier si apoi a distrus datele din memorie. (*)
  cout<<"-------------------------------------------------------------------"<<
    endl;
  cout<<"Introduceti datele pentru un nou cont:"<<endl;
  ContBancar *oInstanta3=new ContBancar(1);
  // Constructorul care citeste de la consola datele pentru obiect
  cout<<"Datele introduse sunt: "<<endl<<*oInstanta3<<endl;
  cout<<"Acest cont va fi scris acum in \"banca.dat\""<<endl;
  delete oInstanta3;
  // Aceeasi observatie ca si la (*).
  cout<<"-------------------------------------------------------------------"<<
    endl;
  ContBancar *oInstantaX=new ContBancar("4");
  cout<<"Totalul din \"banca.dat\" in lei: "<<oInstantaX->spune_total()<<endl;
  delete oInstantaX;
  return 0;
}