/* kerhohar.cpp */
/* Kerho-ohjelman runko ja alustavat luokat.
**  Tekijät:          Vesa Lappalainen
**                    Ohjelmointikurssi 1996
**  Tehty:            20.12.1991
**  Muutettu          19.12.1993/vl
**                    06.12.1995/vl  - C++ versio
**  Mitä muutettu:    avustus
**  Muutettu          06.12.1995/vl
**  Mitä muutettu:    tehty C++ versio
**  Muutettu          07.12.1995/vl
**  Mitä muutettu:    tehty document/view C++ versio
**  Muutettu          11.03.1996/vl
**  Mitä muutettu:    lisätty harrasteet
**  Muutettu          20.01.1997/vl
**  Mitä muutettu:    lisätty alustava .bak käsittely
**  Muutettu          27.12.2001/vl
**  Mitä muutettu:    apufunktioita Kerhoon, suorat saantimetodit poistettu
**
**
**
**  Tehtäviä: 1) Luodaanko pääohjelman kerholle mitään jäsentaulukkoa
**               ennekuin tehdään naytto.lue()?
**            2) Poistetaanko jotakin pääohjelman kerhosta pääohjelman
**               alkaessa?
**            3) Miksi metodissa "int cJasenet::lisaa(const cJasen &jasen)"
**               luodaan uusi jäsen, eikä tyydytä laittamaan osoitinta
**               parametrina tuotuun jäseneen?
**
*/

#include <iostream>
#include <stdio>
#include <stdlib>
#include <string>
#include <new>
using namespace std;
#include "dosout.h"

#ifdef __TURBOC__               /* Syöttö Turbo-C:n mukaisesti.             */
# define GETCH
# include <conio.h>
#endif


//----------------------------------------------------------------------------
// Vakiota
//----------------------------------------------------------------------------
const char *TARKENNIN       = ".dat";
const char *VANHATARK       = ".bak";
const int  MAX_JASENIA      = 5;
const int  MAX_HARRASTUKSIA = 10;
const int  MERKKI_ISOKSI    = 1;
const int  MYOS_PIENET      = 0;
const char *KAIKKI_KELPAA   = NULL;
const char EI_OLETUSTA      = 0;
const char *RIVINVAIHTO     = "\r\n";



//----------------------------------------------------------------------------
// Yleiskäyttöisiä apualiohjelmia:
//----------------------------------------------------------------------------

char lue_merkki(void)
{
#ifdef GETCH /* Seuraava toimii mm. Turbo C:ssä: */
  return (char)getch();

#else        /* Seuraava on standardin mukainen: */
  char s[50];
  fgets(s,50,stdin);
  return s[0];
#endif

}


char isoksi(char c)
{
  if ( c<'a' ) return c;
  if ( c>'z' ) return c;
  return (char)(c-('a'-'A'));
}


char odota_nappain(const char *kelpaavat, char oletus,
                            int merkki_isoksi)
{
  char painettu;
  do {
    painettu = lue_merkki();
    if ( merkki_isoksi ) painettu = isoksi(painettu);
    if ( oletus != EI_OLETUSTA && strchr(RIVINVAIHTO,painettu) )
      return oletus;
  } while ( kelpaavat != NULL && strchr(kelpaavat,painettu) == NULL );
  return painettu;
}


void odota_jotakin(void)
{
  cout << "Paina jotakin!" << endl;
  odota_nappain(KAIKKI_KELPAA,EI_OLETUSTA,MERKKI_ISOKSI);
}


int kylla_vastaus(void)
{
  return ( odota_nappain("KE",'K',MERKKI_ISOKSI) == 'K' );
}


void ei_toimi(void)
{
  cout << "Ei toimi vielä!" << endl;
  odota_jotakin();
}


void viiva(int pit, char merkki)
{
  for (int i = 0; i<pit; i++)
    cout << merkki;
}


void otsikko(char c,const char *teksti)
{
  cout << "\n\n\n" << endl;
  cout << c << ".  " << teksti << endl;
  viiva(  1  +  3     + strlen(teksti),'=');
  cout << "\n" << endl;
}


int ilmoitus(const char *s)
{
  if ( s == NULL ) return 0;
  cout << "\n" << s << endl;
  odota_jotakin();
  return 1;
}

int ilmoitus(const string &s)
{
  if ( s == "" ) return 0;
  cout << "\n" << s << endl;
  odota_jotakin();
  return 1;
}


//----------------------------------------------------------------------------
// Jasenen määrittely:
//----------------------------------------------------------------------------

class cJasen {     // Jäsenluokka, jolle tulee vielä paljon ominaisuuksia
  int tunnus_nro;
  string nimi;
  string hetu;
  string katuosoite;
  string postinumero;
  string postiosoite;
  string kotipuhelin;
  string tyopuhelin;
  string autopuhelin;
  int    liittymisvuosi;
  double jmaksu;
  double maksu;
  string lisatietoja;
  static int seuraava_nro;
public:
  cJasen() { alusta(); }
  void alusta();
  void vastaa_aku_ankka();
  void tulosta(ostream &os) const;
  int  rekisteroi() { tunnus_nro = seuraava_nro; seuraava_nro++; return tunnus_nro;}
  int Tunnus_nro() const { return tunnus_nro; }
};


//----------------------------------------------------------------------------
// Jasenen käsittely:
//----------------------------------------------------------------------------
int cJasen::seuraava_nro = 1;


void cJasen::alusta()
{
  tunnus_nro     = 0;
  nimi           = "";
  hetu           = "";
  katuosoite     = "";
  postinumero    = "";
  postiosoite    = "";
  kotipuhelin    = "";
  tyopuhelin     = "";
  autopuhelin    = "";
  liittymisvuosi = 0;
  jmaksu         = 0;
  maksu          = 0;
  lisatietoja    = "";
}


void cJasen::vastaa_aku_ankka()
{
  char apuhetu[50];
  sprintf(apuhetu,"%02d%02d%02d-%03d%c",
          rand()%31+1,rand()%12+1,rand()%91+1,rand()%1000,rand()%25+'A');
  apuhetu[11]=0;

  nimi           = "Ankka Aku";
  hetu           = apuhetu;
  katuosoite     = "Ankkakuja 6";
  postinumero    = "12345";
  postiosoite    = "ANKKALINNA";
  kotipuhelin    = "12-1234";
  tyopuhelin     = "";
  autopuhelin    = "";
  liittymisvuosi = 1996;
  jmaksu         = 50.00;
  maksu          = 30.00;
  lisatietoja    = "Velkaa Roopelle";
}


void cJasen::tulosta(ostream &os) const
{
  os << "  " << nimi << "  " << hetu << endl;
  os << "  " << katuosoite << "  " <<
                postinumero << " " << postiosoite << endl;
  os << "  k: " << kotipuhelin <<
         " t: " << tyopuhelin  <<
         " a: " << autopuhelin << endl;
  os << "  Liittynyt " << liittymisvuosi << ".";
           cout.precision(2); cout.setf(ios::showpoint);
  os << "  Jäsenmaksu " << jmaksu << " mk."
        "  Maksettu "   << maksu  << " mk." << endl;
  os << "  " << lisatietoja << endl;
}


//----------------------------------------------------------------------------
// Harrastuksen määrittely:
//----------------------------------------------------------------------------
class cHarrastus {
  int    tunnus_nro;
  int    viite_nro;
  string ala;
  int    aloitusvuosi;
  int    tuntia_viikossa;
  static int seuraava_nro;
public:
  cHarrastus() { tunnus_nro=0; viite_nro=0; ala="";
                 aloitusvuosi=0; tuntia_viikossa=0; }
  void tulosta(ostream &os) const {
    os << "    " << aloitusvuosi << ": " << ala << ", "
       << tuntia_viikossa << "h viikossa" <<endl;
  }
  void vastaa_pitsin_nyplays(int nro) {
    viite_nro = nro;
    ala = "Pitsin nypläys";
    aloitusvuosi = rand()%100+1900;
    tuntia_viikossa = rand()%60;
  }
  int Viite_nro()  { return viite_nro; }
  int rekisteroi() { tunnus_nro = seuraava_nro; seuraava_nro++;
                     return tunnus_nro;}
  int Tunnus_nro() const { return tunnus_nro; }
};


//----------------------------------------------------------------------------
// Harrastusten määrittely:
//----------------------------------------------------------------------------
class cHarrastukset {
  int    max_lkm;
  int    lkm;
  int    muutettu;
  string tiedoston_nimi;
  string bak_nimi;
  string koko_nimi;
  int    kohdalla;
  cHarrastus apualkio;
  cHarrastus **alkiot;

  void  poista_kaikki()      { poista_alkiot(); poista_taulukko();           }
  void  poista_alkiot();
  void  poista_taulukko();
  string luo_taulukko(int koko=MAX_HARRASTUKSIA);
  void alusta() { tiedoston_nimi = ""; max_lkm = 0;  lkm = 0; muutettu = 0;  }
  cHarrastukset(const cHarrastukset &) {}
  void operator=(const cHarrastukset &) {}
public:
  cHarrastukset(int koko=0)  { alusta(); luo_taulukko(koko);                 }
  ~cHarrastukset()           { if ( muutettu ) talleta(); poista_kaikki();   }

  string lisaa(const cHarrastus &harrastus);

  const cHarrastus &anna(int i) const  {
    if ( i < 0 || lkm <= i ) return apualkio;
    return *alkiot[i];
  }

  string lue_tiedostosta(const string &tied);
  string talleta();

  int Lkm()                      const   { return lkm;                       }
  const string &Tiedoston_nimi() const   { return tiedoston_nimi;            }
  const cHarrastus *eka(int nro);
  const cHarrastus *seuraava(int nro);
  const string &Bak_nimi()       const { return bak_nimi;                    }
  int   TeeBak(const string &bak_tark) { bak_nimi = bak_tark; return 0;      }
};


//----------------------------------------------------------------------------
// Harrastusten toteutus:
//----------------------------------------------------------------------------
const char *EI_VOI_LUODA = "Taulukolle ei saada varattua tilaa muistista!";
const char *LIIKAA_ALKIOITA = "Liikaa alkioita, ei voi lisätä!";
const char *EI_SAA_ALKIOTA = "Ei saada tilaa uudelle alkiolle!";


int cHarrastus::seuraava_nro = 1;

const cHarrastus *cHarrastukset::seuraava(int nro)
{
  int i;
  for (i=kohdalla+1; i<lkm; i++) {
    if ( alkiot[i]->Viite_nro() == nro ) {
      kohdalla = i;
      return alkiot[i];
    }
  }
  return NULL;
}

const cHarrastus *cHarrastukset::eka(int nro)
{
  kohdalla = -1;
  return seuraava(nro);
}


void cHarrastukset::poista_alkiot()
{
  for (int i=0; i<lkm; i++)
    delete alkiot[i];
  lkm = 0;
}


string cHarrastukset::lisaa(const cHarrastus &harrastus)
{
  cHarrastus *uusi;

  if ( lkm >= max_lkm ) return LIIKAA_ALKIOITA;
  uusi = new(nothrow) cHarrastus(harrastus);
  if ( uusi == NULL ) return EI_SAA_ALKIOTA;

  alkiot[lkm] = uusi;
  lkm++;

  return "";
}


string cHarrastukset::luo_taulukko(int koko)
{
  poista_kaikki();
  if ( koko <= 0 ) return "";
  alkiot = (cHarrastus **)malloc( koko * (sizeof(cHarrastus *)) );
  lkm = 0;
  max_lkm = 0;
  if ( alkiot == NULL ) return EI_VOI_LUODA;
  max_lkm = koko;
  return "";
}


void cHarrastukset::poista_taulukko()
{
  if ( max_lkm > 0 ) free(alkiot);
  max_lkm = 0;
}


string cHarrastukset::lue_tiedostosta(const string &tied)
{
  // Pahasti kesken
  tiedoston_nimi = tied;
  koko_nimi = tied;
  return luo_taulukko();
}


string cHarrastukset::talleta()
{
  // Pahasti kesken
  return "";
}



//----------------------------------------------------------------------------
// Jäsenistön määrittely:
//----------------------------------------------------------------------------
class cJasenet {
  int    max_lkm;
  int    lkm;
  int    muutettu;
  string tiedoston_nimi;
  string bak_nimi;
  string koko_nimi;
  cJasen apualkio;
  cJasen **alkiot;

  void  poista_kaikki()     { poista_alkiot(); poista_taulukko();            }
  void  poista_alkiot();
  void  poista_taulukko();
  string luo_taulukko(int koko=MAX_JASENIA);
  void alusta()             { koko_nimi = ""; tiedoston_nimi = "";
                              max_lkm = 0;  lkm = 0; muutettu = 0;           }
  cJasenet(const cJasenet &) {}
  void operator=(const cJasenet &) {}
public:
  cJasenet(int koko=0)      { alusta(); luo_taulukko(koko);                  }
  ~cJasenet()               { if ( muutettu ) talleta(); poista_kaikki();    }

  string lisaa(const cJasen &jasen);

  const cJasen &anna(int i) const  {
    if ( i < 0 || lkm <= i ) return apualkio;
    return *alkiot[i];
  }

  string lue_tiedostosta(const string &tied);
  string talleta();

  const string &Koko_nimi()    const   { return koko_nimi;                   }
  int Lkm()                    const   { return lkm;                         }
  const string &Tiedoston_nimi() const { return tiedoston_nimi;              }
  const string &Bak_nimi()       const { return bak_nimi;                    }
  int   TeeBak(const string &bak_tark) { bak_nimi = bak_tark; return 0;      }
};



//----------------------------------------------------------------------------
// Jäsenistön toteutus:
//----------------------------------------------------------------------------

void cJasenet::poista_alkiot()
{
  for (int i=0; i<lkm; i++)
    delete alkiot[i];
  lkm = 0;
}


string cJasenet::lisaa(const cJasen &jasen)
{
  cJasen *uusi;

  if ( lkm >= max_lkm ) return LIIKAA_ALKIOITA;
  uusi = new(nothrow) cJasen(jasen);
  if ( uusi == NULL ) return EI_SAA_ALKIOTA;

  alkiot[lkm] = uusi;
  lkm++;

  return "";
}



string cJasenet::luo_taulukko(int koko)
{
  poista_kaikki();
  if ( koko <= 0 ) return "";
  alkiot = (cJasen **)malloc( koko * (sizeof(cJasen *)) );
  lkm = 0;
  max_lkm = 0;
  if ( alkiot == NULL ) return EI_VOI_LUODA;
  max_lkm = koko;
  return "";
}


void cJasenet::poista_taulukko()
{
  if ( max_lkm > 0 ) free(alkiot);
  max_lkm = 0;
}


string cJasenet::lue_tiedostosta(const string &tied)
{
  // Pahasti kesken
  koko_nimi = tied;
  tiedoston_nimi = tied;
  return luo_taulukko();
}


string cJasenet::talleta()
{
  // Pahasti kesken
  return "";
}


//----------------------------------------------------------------------------
// Kerhon määrittely:
//----------------------------------------------------------------------------

class cKerho {
  cJasenet jasenet;
  cHarrastukset harrastukset;

  void alusta()       {                                                      }
public:
  cKerho(int koko=0):jasenet(),harrastukset()  { alusta();                   }
  ~cKerho()           { talleta();                                           }

  string lue_tiedostosta(const string &tied);
  string talleta() { jasenet.talleta(); return harrastukset.talleta();  }

  const string &Kerhon_nimi()    const   { return jasenet.Koko_nimi();       }
  int Jasenia()                  const   { return jasenet.Lkm();             }
  // poista poistaa jäsenistöstä ja harrasteista ne joilla on nro - tekemättä!
  int poista(int nro)                    { return 0;                         }
  int TeeBak(const string &bak_tark)     { return jasenet.TeeBak(bak_tark)+
                                               harrastukset.TeeBak(bak_tark);}
  string Tiedoston_nimi() const          { return jasenet.Tiedoston_nimi();  }
  string Bak_nimi() const                { return jasenet.Bak_nimi();        }
  const cHarrastus *eka_harrastus(int nro)     { return harrastukset.eka(nro);     }
  const cHarrastus *seuraava_harrastus(int nro){ return harrastukset.seuraava(nro);}
//  const cJasen *eka_jasen(int nro)             { return jasenet.eka(nro);          }
//  const cJasen *seuraava_jasen(int nro)        { return jasenet.seuraava(nro);     }
  string lisaa(const cHarrastus &har)     { return harrastukset.lisaa(har);  }
  string lisaa(const cJasen &jasen)       { return jasenet.lisaa(jasen);     }
  const cJasen &anna_jasen(int i) const   { return jasenet.anna(i);          }
};

string cKerho::lue_tiedostosta(const string &tied)
{
  // Pahasti kesken
  string virhe = jasenet.lue_tiedostosta(tied);
  if ( virhe != "" ) return virhe;
  return harrastukset.lue_tiedostosta(tied);
}


//----------------------------------------------------------------------------
// Näytön määrittely
//----------------------------------------------------------------------------
class cNaytto {
  cKerho *kerho; // Osoitin kerhoon => voi olla sama kerho monessa näytössä

  void logo(void);
  void avustus(char valinta);
  void lisaa_uusi_jasen(char valinta);
  void etsi_jasenen_tiedot(char valinta);
  void tulosteet(char valinta);
  void tietojen_korjailu(char valinta);
  void paivita_jasenmaksuja(char valinta);
  void paamenu();
  void tulosta(ostream &os,const cJasen &jasen);
  void kysy_tiedot(cJasen &jasen);
public:
  cNaytto(cKerho *p) : kerho(p) {;}
  ~cNaytto() { talleta(); }

  void ohjeet(void);
  void kiitokset(void);

  int  lue_tiedosto();
  int  talleta();

  int  paavalinta();
};


void cNaytto::logo(void)
{
  cout << endl;
  cout << "      ###################################" << endl;
  cout << "      #   J Ä S E N R E K I S T E R I   #" << endl;
  cout << "      #     versio 9.95                 #" << endl;
  cout << "      #     Hannu Hanhi                 #" << endl;
  cout << "      ###################################" << endl;
}


void cNaytto::ohjeet(void)
{
  logo();
  cout << endl;
  cout << "Tällä ohjelmalla ylläpidetään kerhon jäsenrekisteriä." << endl;
}


void cNaytto::kiitokset(void)
{
  cout << endl;
  cout << "KIITOS KÄYTÖSTÄ JA TERVETULOA UUDELLEEN" << endl;
  cout << "\n\n" << endl;
}


int cNaytto::lue_tiedosto()
{
  cout << "Anna kerhon nimi>" << endl;
  ei_toimi();

  return ilmoitus(kerho->lue_tiedostosta("KELMIT"));
}


int cNaytto::talleta()
{
  logo();

  kerho->TeeBak(VANHATARK);
  if ( ilmoitus(kerho->talleta()) ) return 1;

  cout << endl;
  cout << "Tiedot talletettu tiedostoon " << kerho->Tiedoston_nimi()
       <<  endl;
  cout << "Vanhat tiedot tiedostossa    " << kerho->Bak_nimi()
       <<  endl;

  cout << "\n\nTosin talletus ei vielä toimi!" << endl;

  return 0;
}

void cNaytto::tulosta(ostream &os,const cJasen &jasen)
{
  const cHarrastus *har;
  int nro = jasen.Tunnus_nro();
  jasen.tulosta(os);
  har = kerho->eka_harrastus(nro);
  while ( har ) {
    har->tulosta(os);
    har = kerho->seuraava_harrastus(nro);
  }
}


void cNaytto::kysy_tiedot(cJasen &jasen)
{
  cHarrastus har;
  int nro = jasen.Tunnus_nro();
  cout << "Toistaiseksi osaan lisätä vain Aku Ankan" << endl;
  jasen.vastaa_aku_ankka();
  int lkm = rand()%5;
  for (int i=0; i<lkm; i++) {
    har.vastaa_pitsin_nyplays(nro);
    if ( ilmoitus(kerho->lisaa(har)) ) break;
  }
}

void cNaytto::lisaa_uusi_jasen(char valinta)
{
  cJasen jasen;

  otsikko(valinta,"Uuden jäsenen lisäys");

    jasen.rekisteroi();
    kysy_tiedot(jasen);
    cout << "Lisätäänkö" << endl;
    tulosta(cout,jasen);
    cout << ":";
    int pois = 1;
    if ( kylla_vastaus() )
      pois = ilmoitus(kerho->lisaa(jasen));
    if ( pois ) kerho->poista(jasen.Tunnus_nro());
}



void cNaytto::etsi_jasenen_tiedot(char valinta)
{
  otsikko(valinta,"Etsi jäsenen tiedot");
  ei_toimi();
}


void cNaytto::tulosteet(char valinta)
{
  otsikko(valinta,"Tulosteet");
  cout << "Toimii toistaiseksi vain näytölle\n" << endl;
  cout << "---------------------------------------------------------" << endl;

  for (int i=0; i<kerho->Jasenia(); i++) {
    const cJasen &jasen = kerho->anna_jasen(i);
    tulosta(cout,jasen);
    cout << endl;
  }

  cout << "---------------------------------------------------------" << endl;
  odota_jotakin();
}


void cNaytto::tietojen_korjailu(char valinta)
{
  otsikko(valinta,"Tietojen korjailu");
  ei_toimi();
}


void cNaytto::paivita_jasenmaksuja(char valinta)
{
  otsikko(valinta,"Päivitä jäsenmaksuja");
  ei_toimi();
}


void cNaytto::avustus(char valinta)
{
  otsikko(valinta,"Avustus");
  ei_toimi();
}


void cNaytto::paamenu()
{
  cout << "\n\n\n\n" << endl;
  cout << "Jäsenrekisteri" << endl;
  cout << "==============" << endl;
  cout << endl;
  cout << "Kerhossa " << kerho->Kerhon_nimi() << " on " <<
          kerho->Jasenia() << " jäsentä." << endl;
  cout << endl;
  cout << "Valitse:" << endl;
  cout << "   ?  = avustus" << endl;
  cout << "   0  = lopetus" << endl;
  cout << "   1  = lisää uusi jäsen" << endl;
  cout << "   2  = etsi jäsenen tiedot" << endl;
  cout << "   3  = tulosteet" << endl;
  cout << "   4  = tietojen korjailu" << endl;
  cout << "   5  = päivitä jäsenmaksuja" << endl;
  cout << "   :";
}


int cNaytto::paavalinta()
{
  char nappain;

  while (1) {

    paamenu();

    nappain = odota_nappain("?012345",EI_OLETUSTA,MERKKI_ISOKSI);

    switch (nappain) {
      case '?': avustus(nappain);               break;
      case '0': return 0;
      case '1': lisaa_uusi_jasen(nappain);      break;
      case '2': etsi_jasenen_tiedot(nappain);   break;
      case '3': tulosteet(nappain);             break;
      case '4': tietojen_korjailu(nappain);     break;
      case '5': paivita_jasenmaksuja(nappain);  break;
      default : cout << "Näin ei voi käydä!" << endl; return 1;
    }

  }
}


int main(void)
{
  cKerho kerho;
  cNaytto naytto(&kerho);
  naytto.ohjeet();

  if ( naytto.lue_tiedosto() ) return 1;

  naytto.paavalinta();

  if ( naytto.talleta() ) return 2;

  naytto.kiitokset();

  return 0;
}