//get_cpu.h

#ifndef __GET_CPU__
#define __GET_CPU__

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <unistd.h>
#include <assert.h>
#include <algorithm>
#include <vector>
#define PROCESS_ITEM 14

typedef struct
{
    pid_t pid;
    unsigned int utime;   //live thread at user status  (jiffies)
    unsigned int stime;   //live thread at kernel status
    unsigned int cutime;  //killed thread at user status
    unsigned int cstime;  //killed thread at kernel status
}process_cpu_occupy;

vector<unsigned int>total_cpu_time;

unsigned int get_cpu_process_occupy(const pid_t p);
const char* get_items(const char* buffer,int ie);

extern float get_cpu(pid_t p);
extern unsigned int get_total_cpu();

#endif

//get_cpu.cc

#include "get_cpu.h"
const char* get_items(const char* buffer,int ie)
{
    assert(buffer);
    char* p = buffer;
    int len = strlen(buffer);
    int count = 0;
    int i;

    if (1 == ie || ie < 1)
    {
        return p;
    }

    for (i=0; i<len; i++)
    {
        if (‘ ‘ == *p)
        {
            count++;
            if (count == ie-1)
            {
                p++;
                break;
            }
        }
        p++;
    }

    return p;
}
unsigned int get_cpu_process_occupy(const pid_t p)
{
    char file[64] = {0};
    process_cpu_occupy t;
    FILE *fd;
    char line_buff[1024] = {0};

    sprintf(file,"/proc/%d/stat",p);

    fd = fopen (file, "r");
    fgets (line_buff, sizeof(line_buff), fd);
    sscanf(line_buff,"%u",&t.pid);
    char* q = get_items(line_buff,PROCESS_ITEM);
    sscanf(q,"%u %u %u %u",&t.utime,&t.stime,&t.cutime,&t.cstime);

    fclose(fd);
    return (t.utime + t.stime + t.cutime + t.cstime);
}
unsigned int get_cpu(pid_t p,int index)
{
    unsigned int procputime;

    procputime = get_cpu_process_occupy(p);
    std::cout<<"procputime :"<<procputime<<endl;

    switch(index){
        case 1:
            total_cpu_time.clear();
            total_cpu_time.push_back(procputime);
            break;
        case 2:
            total_cpu_time.push_back(procputime);
            break;
        case 3:
            total_cpu_time.push_back(procputime);
            break;
        default:
            DSTREAM_WARN("index is errno");
            break;
    }
    return procputime;
}
unsigned int get_total_cpu(){
    int length=total_cpu_time.size();
    unsigned int total_time=0;
    if(length != 3){
        DSTREAM_WARN("get total cpu failed");
        return -1;
    }
    for(int i=0;i<length;i++){
        total_time+=total_cpu_time[i];
    }
    return total_time;
}

#ifndef __GET_MEM__
#define __GET_MEM__

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <unistd.h>
#include <assert.h>
#include <algorithm>
#include <vector>
#define VMRSS_LINE 15  //VMRSS line

vector<int>total_memory;

int get_phy_mem(const pid_t p);

extern int get_mem(pid_t p);
extern int get_total_memory();
extern int get_total_mem();

#endif

//get_mem.cc
#include "get_mem.h"
int get_phy_mem(const pid_t p)
{
    char file[64] = {0};

    FILE *fd;
    char line_buff[256] = {0};
    sprintf(file,"/proc/%d/status",p);

    fd = fopen (file, "r");
    int i;
    char name[32];
    int vmrss;
    for (i=0;i<VMRSS_LINE-1;i++)
    {
        fgets (line_buff, sizeof(line_buff), fd);
    }
    fgets (line_buff, sizeof(line_buff), fd);
    sscanf (line_buff, "%s %d", name,&vmrss);
    fclose(fd);
    return vmrss;
}

int get_mem(pid_t p,int index)
{
    int procmemory;
    promemory=get_phy_mem(p);
    switch(index){
    case 1:
        total_memory.clear();
        total_memory.push_back(promemory);
        break;
    case 2:
        total_memory.push_back(promemory);
        break;

    case 3:
        total_memory.push_back(promemory);
        break;
    default:
        DSTREAM_WARN("index is errno");
        break;
    }
    return promemory;
}

//importer+aggregater+exporter
int get_total_memory(){
    int length=total_memory.size();

    int total_mem=0;
    if(length != 3){
        DSTREAM_WARN("get total cpu failed");
        return -1;
    }

    for(int i=0;i<length;i++){
        total_mem+=total_memory[i];
    }
    return total_mem;
}


//total memory
int get_all_mem()
{
    char* file = "/proc/meminfo";

    FILE *fd;
    char line_buff[256] = {0};
    fd = fopen (file, "r");
    int i;
    char name[32];
    int memtotal;
    fgets (line_buff, sizeof(line_buff), fd);
    sscanf (line_buff, "%s %d", name,&memtotal);
    fclose(fd);
    return memtotal;
}