/***************************************************************************/
/*
**       T U O T E A L I . C
**
**
**  Tuoterekisterin yll„pidossa k„ytett„vi„ yleisi„ aliohjelmia.
**
**  Aliohjelmat:
**     int_jonoksi       - muuttaa kokonaisluvun mjonoksi, -1 -> ""
**     double_jonoksi    - muuttaa reaaliluvun mjonoksi,   -1 -> ""
**     pvm_jonoksi       - muuttaa p„iv„m„„r„merkinn„n mjonoksi
**     jono_intiksi      - muuttaa jonon kokonaisluvuksi,  "" -> -1
**     jono_doubleksi    - muuttaa jonon reaaliluvuksi,    "" -> -1
**     jono_pvmksi       - muuttaa jonon p„iv„m„„r„merkinn„ksi
**     selvita_nyky_pvm  - selvitt„„ t„m„n p„iv„n p„iv„m„„r„n
**     sama_pvm          - selvitt„„, ovatko kaksi p„iv„m„„r„„ samat
**     lue_merkki        - lukee yhden merkin n„pp„imist”lt„
**                         (laiteriippuva)
**     odota_nappain     - odottaa yhden vain sallitussa joukossa olevan
**                         n„pp„imen painallusta
**     odota_jotakin     - odottaa mink„ tahansa n„pp„imen painamista
**     kylla_vastaus     - odottaa K tai E n„pp„imen painallusta
**     ei_toimi          - tulostaa viestin "Ei toimi" ja odottaa
**                         n„pp„imen painallusta
**     logo              - tulostaa ohjelman logon
**
**
**  Tekij„: Iiris Suutarinen  9.4.1992
**
*/


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "mjonot.h"
#include "tuote.h"


/***************************************************************************/
char                           /*                                          */
*int_jonoksi(                  /* Jonon osoite.                            */
  char *jono,                  /* t  Jono, jonne tulos tulee.              */
  int max_pit,                 /* s  Jonon maksimipituus.                  */
  int arvo,                    /* s  Arvo, joka muutetaan jonoksi.         */
  char *formaatti              /* s  Formaatti, jota muutoksessa k„ytet„„n.*/
)
/*
**  Funktiolla muutetaan kokonaisluku merkkijonoksi annetun formaatin
**  mukaan. Mik„li luku on TYHJA_ARVO, palautetaan tyhj„ arvo.
**
**  Kutsuu: kopioi_jono
---------------------------------------------------------------------------*/
{
  char apu[80];

  if (arvo == TYHJA_ARVO) {
    jono[0] = 0;
    return jono;
  }
  sprintf(apu,formaatti,arvo);
  kopioi_jono(jono,max_pit,apu);
  return jono;
}

/***************************************************************************/
char                           /*                                          */
*double_jonoksi(               /* Jonon osoite.                            */
  char *jono,                  /* t  Jono, jonne tulos tulee.              */
  int max_pit,                 /* s  Jonon maksimipituus.                  */
  double arvo,                 /* s  Arvo, joka muutetaan jonoksi.         */
  char *formaatti              /* s  Formaatti, jota muunnoksessa k„ytet„„n*/
)
/*
**  Funktiolla muutetaan reaaliluku merkkijonoksi annetun formaatin
**  mukaan. Mik„li luku on TYHJA_ARVO, palautetaan tyhj„ arvo.
**
**  Kutsuu: kopioi_jono
---------------------------------------------------------------------------*/
{
  char apu[80];

  if (arvo == TYHJA_ARVO) {
    jono[0] = 0;
    return jono;
  }
  sprintf(apu,formaatti,arvo);
  kopioi_jono(jono,max_pit,apu);
  return jono;
}

/***************************************************************************/
char                           /*                                          */
*pvm_jonoksi(                  /* Jonon osoite.                            */
  char *jono,                  /* t  Jono, jonne tulos tulee.              */
  int max_pit,                 /* s  Jonon maksimipituus.                  */
  Pvm_tyyppi *pvm              /* s  Arvo, joka muutetaan jonoksi.         */
)
/*
**  Funktiolla muutetaan p„iv„m„„r„merkint„ pv.kk.vvvv vast. merkkijonoksi.
**  (Yksinumeroisiin p„iviin ja kuukausiin lis„t„„n etunollat.)
**
**  Kutsuu: kopioi_jono
---------------------------------------------------------------------------*/
{
  char apu[80];

  sprintf(apu,"%02d.%02d.%02d",pvm->pv,pvm->kk,pvm->vv);
  kopioi_jono(jono,max_pit,apu);
  return jono;
}

/***************************************************************************/
int                            /*                                          */
jono_intiksi(                  /*                                          */
  char *jono,                  /* s  Kokonaisluvuksi muutettava merkkijono.*/
  char *formaatti              /* s  Formaatti, jota muunnoksessa k„ytet„„n*/
)
/*
**  Funktiolla muutetaan merkkijono kokonaisluvuksi. Mik„li jono on tyhj„,
**  palautetaan TYHJA_ARVO.
**
---------------------------------------------------------------------------*/
{
  int i = TYHJA_ARVO;

  sscanf(jono,formaatti,&i);
  return i;
}

/***************************************************************************/
double  	               /*                                          */
jono_doubleksi(                /*                                          */
  char *jono,                  /* s  Reaaliluvuksi muutettava merkkijono.  */
  char *formaatti              /* s  Formaatti, jota muunnoksessa k„ytet„„n*/
)
/*
**  Funktiolla muutetaan merkkijono reaaliluvuksi. Mik„li jono on tyhj„,
**  palautetaan TYHJA_ARVO.
**
---------------------------------------------------------------------------*/
{
  double r = TYHJA_ARVO;

  sscanf(jono,formaatti,&r);
  return r;
}

/***************************************************************************/
Pvm_tyyppi	               /*                                          */
jono_pvmksi(                   /*                                          */
  char *jono                   /* s  P„iv„m„„r„ksi muutettava merkkijono.  */
)
/*
**  Funktiolla muutetaan merkkijono p„iv„m„„r„merkinn„ksi pv.kk.vvvv
**
---------------------------------------------------------------------------*/
{
  Pvm_tyyppi pvm;

  sscanf(jono,"%d.%d.%d",&pvm.pv,&pvm.kk,&pvm.vv);
  return pvm;
}

/***************************************************************************/
void                           /*                                          */
selvita_nyky_pvm(              /*                                          */
  Pvm_tyyppi *nyky             /* t  T„m„n p„iv„n p„iv„m„„r„.              */
)
/*
**  Aliohjelmalla selvitet„„n t„m„n p„iv„n p„iv„m„„r„.
**
**  Kutsuu:  <time.h>
---------------------------------------------------------------------------*/
{
  time_t timer;
  struct tm *tblock;

  /* gets time of day */
  timer = time(NULL);

  /* converts date/time to a structure */
  tblock = localtime(&timer);

  nyky->pv = tblock->tm_mday;
  nyky->kk = tblock->tm_mon+1;
  nyky->vv = tblock->tm_year+1900;
}

/***************************************************************************/
			       /* -1 = p„iv„m„„r„ pvm1 on ennen pvm2:ta    */
int     		       /*  0 = p„iv„m„„r„t ovat samat              */
sama_pvm(                      /*  1 = p„iv„m„„r„ pvm1 on pvm2:n j„lkeen   */
  Pvm_tyyppi *pvm1,            /*  s  Vertailtavat                         */
  Pvm_tyyppi *pvm2             /*  s  p„iv„m„„r„t.                         */
)
/*
**  Aliohjelmalla selvitet„„n, onko p„iv„m„„r„ pvm1 ennen p„iv„m„„r„„ pvm2
**  vai pvm2:n j„lkeen vai ovatko p„iv„m„„r„t samat.
**
---------------------------------------------------------------------------*/
{
/* Verrataan ensin vuosilukuja                                */
  if (pvm1->vv < pvm2->vv) return -1;
  if (pvm1->vv > pvm2->vv) return  1;

/* T„h„n menness„ vuosiluvut ovat samat - verrataan kuukausia */
  if (pvm1->kk < pvm2->kk) return -1;
  if (pvm1->kk > pvm2->kk) return  1;

/* T„h„n menness„ kuukaudetkin ovat samat - verrataan p„ivi„  */
  if (pvm1->pv < pvm2->pv) return -1;
  if (pvm1->pv > pvm2->pv) return  1;

/* P„iv„m„„r„t ovat samat                                     */
  return 0;
}

/***************************************************************************/
char lue_merkki(void)          /* N„pp„imist”lt„ luettu merkki.            */
/*  Funktiolla luetaan n„pp„imist”lt„ yksi merkki. Mik„li ohjelmassa
**  ei ole m„„ritelty vakiota GETCH, vaaditaan RET-n„pp„imen painallus.
**  Globaalit: GETCH - m„„ritys
**  Sy”tt”: N„pp„imist”lt„
---------------------------------------------------------------------------*/
{
/* Seuraava toimii mm. Turbo C:ss„: */
#ifdef GETCH
  return getch();

#else

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

/***************************************************************************/
char                           /*                                          */
odota_nappain(                 /*    = p„„tteelt„ luettu merkki            */
  char *kelpaavat,             /* s  Ne merkit, jotka hyv„ksyt„„n.         */
  char oletus,                 /* s  Merkki, joka palautet., jos pain. RET */
  int isot                     /* s  Jos !=0 niin isot ja pienet samaistet.*/
)
/*  P„„tteelt„ luetaan merkki. Jos isot ja pienet kirjaimet halutaan
**  samaistaa (isot!=0), niin muutetaan luettu merkki isoksi.
**  Jos oletus ei ole 0-merkki ja ollaan kohdattu rivinvaihto
**  tai return-n„pp„imen painallus, palautetaan oletus.
**  T„m„ operaatio toistuu, kunnes ollaan luettu merkki, joka kuuluu
**  sallittuun joukkoon (kelpaavat).
**  Jos sallittu joukko on NULL, niin kaikki painetut kelpaavat.
---------------------------------------------------------------------------*/
{
  char painettu;
  do {
    while (!(painettu = lue_merkki()));     /* Luetaan painettu n„pp„in.   */
    if (isot) painettu = isoksi(painettu);  /* Jos tarv. muuttaa isoksi.   */
    if ( oletus && ((painettu == '\n') || (painettu == '\r')) )
      return oletus;                        /* Pal. oletus, jos pain. RET. */
  } while ( kelpaavat && !strchr(kelpaavat,painettu) );
  return painettu;
}

/***************************************************************************/
void odota_jotakin(void)
/*
**  Aliohjelmalla odotetaan, kunnes jotakin n„pp„int„ on painettu.
**  Kutsuu: odota_nappain
**  Algoritmi:
**   odota_nappain aliohjelmalla sallitaan kaikki merkit (kelpaavat = NULL)
**   ja oletusn„pp„int„ ei k„ytet„ (ei haittaisi, vaikka k„ytett„isiinkin).
---------------------------------------------------------------------------*/
{
  printf("Paina jotakin!\n");
  odota_nappain(NULL,0,VAIN_ISOT);
}

/***************************************************************************/
int kylla_vastaus(void)        /* 1 jos painettiin K tai RET ja 0 jos E    */
/*
**  Funktiolla odotetaan, kunnes painetaan K tai E tai RET.
**  Tulostus: N„yt”lle rivinvaihto.
---------------------------------------------------------------------------*/
{
  int palautus;
  palautus = (odota_nappain("KE",'K',VAIN_ISOT) == 'K');
  printf("\n");
  return palautus;
}

/***************************************************************************/
void ei_toimi(                 /*                                          */
  Rekisteri_tyyppi *rekisteri  /* H„m„yst„, jottei valitusta k„ytt„m„tt”m. */
)
/*  Funktiolla tulostetaan teksti ei toimi ja odotetaan n„pp„int„.
---------------------------------------------------------------------------*/
{
  printf("\n\n   Ei toimi viel„! ");
  if (rekisteri->tuotteita == 0);
  odota_jotakin();
}

/***************************************************************************/
void logo(void)
/*
**  Aliohjelmalla tulostetaan ohjelman logo.
**
**  Tulostus: N„ytt””n
---------------------------------------------------------------------------*/
{
  printf("\n\n\n");
  printf("                 ************************************\n");
  printf("                 *                                  *\n");
  printf("                 *   T U O T E R E K I S T E R I    *\n");
  printf("                 *                                  *\n");
  printf("                 *      Versio 1.0  %10s"    "      *\n",VERSIO);
  printf("                 *         Iiris Suutarinen         *\n");
  printf("                 *                                  *\n");
  printf("                 ************************************\n");
  printf("\n\n\n");
}