#include <stdio.h>
#include <sys/time.h>
#include <fcntl.h>
/* http://eic.sourceforge.net/documentation/node141.html 
Paprasciau yra naudotissiomis funkcijomis - trumpiau viskas 
daroma; tuo tarpu sita include faila galima rasti praktiskai
kiekvienoje linux sistemoje.
*/

#include <sys/vfs.h>
/* sitas reikalingas laisvos disko vietos atsekimui */

/* #include <string.h> - mums butu reikalingas, jei su atmintimi reiketu daugiau ka nors padaryti
siu atveju galima isiverst paprastu nereikalingu parametru ismetimu su sscanf, bet esant 
sudetingesniam atrinkimui jau nebeekonomiska/sudetinga/ir kartais net neimanoma pasirinkt reikiamu 
stulpeliu.
http://gd.tuwien.ac.at/languages/c/programming-bbrown/c_031.htm */


#define UPDATE_DELAY 1
/* intervalas kas kiek gausime duomenis, vertetu pagalvoti ar
jo nereikia padaryti tokio pat kaip ir www refresho
*/

static int pstat,mstat,udelay;
void getload(void);
void gethdd(void);
void getmem(void);
void updelay(void);

int main(void)
{
  pstat = open("/proc/stat", O_RDONLY);
  if(pstat == -1) perror("Nepavyko atidaryti /proc/stat"), exit(1);

  mstat = open("/proc/meminfo", O_RDONLY);
  if(mstat == -1) perror("Nepavyko atidaryti /proc/meminfo"), exit(1);

/* is idejos viska galima iskelt laukan - visai nebutina kartu nuskaitinet to failo
bet siu atveju privalumas - pakeitus update delay nereikia is naujo refresinti
nes jis yra nuskaitomas su ankstesnio ciklo dazniu. Trukumas - kreipimasis i faila 
kas kelios sekundes */

  udelay = open("params.txt", O_RDONLY);
  if(udelay == -1) perror("Nepavyko atidaryti params.txt"), exit(1);

  while(1) {
    getload();
    gethdd();
    getmem();
    updelay();
    sleep(UPDATE_DELAY); 
  } 
}


void getload(void)
{
   int len, status;
   int user, nice, system, idle;
   static int prev_user, prev_nice, prev_system, prev_idle;
   int delta_user, delta_nice, delta_system, delta_idle;
   int full, load;
   float prcf, prcu,prcs,prci,prcn;
   char buf[1000], dummy[50]; 

/* tiesa sakant, tiek kintamuju niekam nereikia.
Daug efektyviau galima perdaryti viska apdorojant masyvo viduje
bet tada kodas pakankamai sunkiai skaitomas gausis
tuo tarpu dabar galima pasiimti bet kuria reiksme
ir naudoti i sveikata - tiek idle, tiek....
*/

   lseek(pstat, 0, SEEK_SET);
   len = read(pstat, buf, sizeof(buf));
   buf[len] = 0;
   status = sscanf(buf, "%s %d %d %d %d", dummy, &user, &nice, &system, &idle);
   
   if(status == EOF)
      perror("sscanf /proc/stat"), exit(1);
   if(status != 5)
      fprintf(stderr, "sscanf /proc/stat grazino %d\n", status), exit(1);

   delta_idle=idle-prev_idle;
   delta_user=user-prev_user;
   delta_nice=nice-prev_nice;
   delta_system=system-prev_system;

/* dabar velgi neaisku ko reikia is tikruju
jei tik bendro sistemos apkrovimo tada uztenka percentage reiksmes;
tuo tarpu jei skaidant user/nice/system/idle galima naudotis daugybe
budu. Pasiimsim primityviausia, irtoli grazu ne efektyviausia */

    full=delta_idle+delta_user+delta_nice+delta_system;
    load=full-delta_idle;
    prcf=(load*1.0/full*1.0)*100;
    prcu=(delta_user*1.0/full*1.0)*100;
    prcs=(delta_system*1.0/full*1.0)*100;
    prcn=(delta_nice*1.0/full*1.0)*100;
    
/* analogiskai ir su nice bei system procesais - load - tai bendras, pagal
ji reiketu ir kitus skaiciuot */
   printf("Procentais bendras:%g User:%g System:%g Idle:%g Nice %g\n",prcf,prcu,prcs,prci,prcn);
   
   prev_user=user;
   prev_nice=nice;
   prev_system=system;
   prev_idle=idle;
}

void gethdd(void)
{
   struct statfs sf;

/*    if(argc > 1) {
        statfs(argv[1], &sf);
    } else { */
/* auksciau paminetu eiluciu reikia jei norisi placiau aiskintis kur kiek vietos yra 
 tai yra, nuskaityti primontuotas FS, bei susizinoti kiekvienos is ju fryspeisa */
    
        statfs("/", &sf);

/*    } */


    /* f_bavail == paprastiems useriams, f_bfree == root useriui */
    printf("%d MB is viso; laisvu: %d MB(%d MB root vartotojui)\n",
	    (sf.f_blocks * sf.f_bsize)/1048576,
            (sf.f_bavail * sf.f_bsize)/1048576,
            (sf.f_bfree * sf.f_bsize)/1048576
            );

}

void getmem(void)
{

   int ilgis,status;
   long mem,mem1,mem2;
   char buferis[1000], dummy[50]; 
    lseek(mstat, 0, SEEK_SET);
    ilgis = read(mstat, buferis, sizeof(buferis));
    buferis[ilgis] = 0;
    status = sscanf(buferis, "%s %s %s %s %s %s %s %d %d %d",&dummy,&dummy,&dummy,&dummy,&dummy,&dummy,&dummy,&mem,&mem1,&mem2); 
    printf("Mem bendrai=%d MB, Mem used=%d MB, Mem free=%d MB\n",mem/1048576,mem1/1048576,mem2/1048576);
}

void updelay(void)
{
    printf ("vykdom\n");
    int update_delay,status,ilgis;
    char buferis[1000];
    printf ("definishinai");
    lseek(udelay,0,SEEK_SET);
    printf ("lseek baigta");
    ilgis = read(udelay,buferis,sizeof(buferis));
    buferis[ilgis]=0;
    status = sscanf(buferis,"%d",update_delay);
    printf ("delay=%d",update_delay);
}