#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <stdbool.h>
#include <sys/socket.h> //包含套接字的函数库
#include <netinet/in.h> //包含AF_INET的相关结构
#include <arpa/inet.h>  //包含AF_INET的操作函数


#define MAXBUFSIZE 1024
#define WAIT_SECOND 3   //暂停时间，单位为“秒”
#define PROJECTNAME "haojiangbo"

#define PORT 9999 //你服务器的端口号
#define HOST "127.0.0.1" //你服务器的IP
typedef  struct occupy
{
    char name[20];
    unsigned int user;
    unsigned int nice;
    unsigned int system;
    unsigned int idle;
} CPU_OCCUPY ;

typedef  struct  SysInfo
{
    int me_cpu_num;
    float me_cpu_used;
    float me_mem_used;
    float me_io_used;
    char me_disk_used[10];
    char me_download[1024];
}SysInfo;


typedef  struct  HJB_MEM{
    char title[20];
    char total[20];
    char used[20];
    char free[20];
    char sjared[20];
    char catch[20];
    char available[20];
}HJB_MEM;


typedef  struct  HJB_NETWORK{
    char rxkb[20];
    char txkb[20];
    char name[100];
}HJB_NETWORK;


float g_cpu_used;
int cpu_num;                //定义一个全局的int类型cup_num
void cal_occupy(CPU_OCCUPY *, CPU_OCCUPY *);
void get_occupy(CPU_OCCUPY *);
float get_io_occupy();
void get_disk_occupy(char **reused);
float  hjbGetMemInfo(HJB_MEM *mem);
void hjbGetNetWorkInfo(HJB_NETWORK *hjb_network);
int main(){
    CPU_OCCUPY ocpu,ncpu;
    HJB_MEM hjb_mem;
    HJB_NETWORK hjb_network;

    //描述客户端的socket
    struct sockaddr_in addr;
    //消息长度
    int dataBytes = 0;
    //消息
    char sendbuf[MAXBUFSIZE];
    char recvbuf[MAXBUFSIZE];

    //客户端套接字标识符，只需要一个套接字文件描述符，用于和客户端通信
    int sockfd;
    //创建套接字
    sockfd = socket(AF_INET,SOCK_STREAM,0);
    if(sockfd < 0){
        perror("创建套接字失败");
        return 0;
    }
    printf("创建套接字成功\n");
    addr.sin_family = AF_INET;
    //定义服务端的套接字端口
    addr.sin_port = htons(PORT);

    //指定服务器端的ip，本地测试：127.0.0.1
    //inet_addr()函数，将点分十进制IP转换成网络字节序IP
    addr.sin_addr.s_addr = inet_addr(HOST);

    /**********************连接服务器**********************/
    if(connect(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0)
    {
        perror("连接服务器失败");
    }
    printf("连接到服务器成功...\n");

    while (true){
        SysInfo *sysInfo;
        sysInfo =  (SysInfo *)malloc(sizeof(SysInfo));
        sleep(3);
        printf("--------------------------------\n");
        //获取cpu核数
        cpu_num = sysconf(_SC_NPROCESSORS_ONLN);
        sysInfo->me_cpu_num = cpu_num;
        printf("cpu mum:%d\n",sysInfo->me_cpu_num);
        //获取cpu使用率
        get_occupy(&ocpu);
        sleep(1);
        get_occupy(&ncpu);
        cal_occupy(&ocpu, &ncpu);
        sysInfo->me_cpu_used = g_cpu_used;
        //获取内存使用率
        sysInfo->me_mem_used = hjbGetMemInfo(&hjb_mem)*100;

        //IO内存使用率
        sysInfo->me_io_used = get_io_occupy();

        //获取当前磁盘的使用率
        char *used;
        get_disk_occupy(&used);
        printf("used_path2 = %d \n",&used);
        strcpy(sysInfo->me_disk_used,used);
        free(used);
        printf("sysInfo->me_disk_used = %s \n",sysInfo->me_disk_used);

        //获取网卡信息
        hjbGetNetWorkInfo(&hjb_network);
        printf("network read Info %s %s %s \n", hjb_network.name,hjb_network.rxkb,
               hjb_network.txkb);

        strcat(sysInfo->me_download,hjb_network.name);
        strcat(sysInfo->me_download,"> rxkb: ");
        strcat(sysInfo->me_download,hjb_network.rxkb);
        strcat(sysInfo->me_download," txkb: ");
        strcat(sysInfo->me_download,hjb_network.txkb);

        char *sendInfo = (char *)malloc(1024);
        if(sendInfo != NULL){
            //memcpy(sendInfo,sysInfo, sizeof(SysInfo));
            sprintf(sendInfo,"{\"cpunuber\":%d,\n"
                             "\"cpu_used\":%4.2f,\n"
                             "\"mem_used\":%4.2f,\n"
                             "\"download\":\" %s \",\n"
                             "\"io_used\":%4.2f,\n"
                             "\"disk_used\":\"%s\",\n"
                             "\"projectName\":\"%s\"}\n",
                    sysInfo->me_cpu_num,
                    sysInfo->me_cpu_used,
                    sysInfo->me_mem_used,
                    sysInfo->me_download,
                    sysInfo->me_io_used,
                    sysInfo->me_disk_used,
                    PROJECTNAME);

            if (sockfd > 0){
                int resultValue =  send(sockfd,sendInfo, strlen(sendInfo),MSG_NOSIGNAL);
                printf("sendMessage value = \n %s  \n", sendInfo);
                printf("sendMessage len -> %d \n",strlen(sendInfo));
                if (resultValue == -1){
                    close(sockfd);
                    /**********************连接服务器**********************/
                    printf("正在尝试重新连接........\n");
                    //创建套接字
                    sockfd = socket(AF_INET,SOCK_STREAM,0);
                    if(sockfd < 0){
                        perror("创建套接字失败..\n");
                        return 0;
                    }
                    printf("创建套接字成功\n");
                    addr.sin_family = AF_INET;
                    //定义服务端的套接字端口
                    addr.sin_port = htons(PORT);

                    //指定服务器端的ip，本地测试：127.0.0.1
                    //inet_addr()函数，将点分十进制IP转换成网络字节序IP
                    addr.sin_addr.s_addr = inet_addr(HOST);

                    /**********************连接服务器**********************/
                    if(connect(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0)
                    {
                        perror("连接服务器失败");
                    }
                    printf("重新连接成功...\n");
                }
                printf("发送消息返回指 %d \n",resultValue);
            } else{
                printf("正在尝试重新连接........\n");
                //创建套接字
                sockfd = socket(AF_INET,SOCK_STREAM,0);
                if(sockfd < 0){
                    perror("创建套接字失败..\n");
                    return 0;
                }
                printf("创建套接字成功..\n");
                addr.sin_family = AF_INET;
                //定义服务端的套接字端口
                addr.sin_port = htons(PORT);

                //指定服务器端的ip，本地测试：127.0.0.1
                //inet_addr()函数，将点分十进制IP转换成网络字节序IP
                addr.sin_addr.s_addr = inet_addr(HOST);

                /**********************连接服务器**********************/
                if(connect(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0)
                {
                    perror("连接服务器失败");
                }
                printf("重新连接成功...\n");
            }

            //recv(sockfd,recvbuf,MAXBUFSIZE,0);
            free(sysInfo);
            free(sendInfo);
            // close(sockfd);
        }


    }

    //close(sockfd);

}


float hjbGetMemInfo(HJB_MEM *mem) {
    char buff1[MAXBUFSIZE];
    char buff2[MAXBUFSIZE];
    FILE *free;
    free = popen("free", "r");
    if (free == NULL) {
        return 0;
    }
    fgets(buff1, sizeof(buff1), free);
    fgets(buff2, sizeof(buff2), free);
    // printf("read = %s, \n",buff2);
    sscanf(buff2, "%s %s %s %s %s %s %s",
            mem->title, mem->total,
            mem->used, mem->free,
            mem->sjared, mem->catch,
            mem->available);
    int total ;
    int used;
    int catch;
    sscanf(mem->total,"%d",&total);
    sscanf(mem->used,"%d",&used);
    sscanf(mem->catch,"%d",&catch);
    float  use = (used+catch)/((double)total);
    pclose(free);
    return use;
}


    void  cal_occupy (CPU_OCCUPY *o, CPU_OCCUPY *n){
    double od, nd;
    double id, sd;
    double scale;
    od = (double) (o->user + o->nice + o->system +o->idle);//第一次(用户+优先级+系统+空闲)的时间再赋给od
    nd = (double) (n->user + n->nice + n->system +n->idle);//第二次(用户+优先级+系统+空闲)的时间再赋给od
    scale = 100.0 / (float)(nd-od);       //100除强制转换(nd-od)之差为float类型再赋给scale这个变量
    id = (double) (n->user - o->user);    //用户第一次和第二次的时间之差再赋给id
    sd = (double) (n->system - o->system);//系统第一次和第二次的时间之差再赋给sd
    g_cpu_used = ((sd+id)*100.0)/(nd-od); //((用户+系统)乖100)除(第一次和第二次的时间差)再赋给g_cpu_used
}
void  get_occupy (CPU_OCCUPY *o) {

    FILE *fd;
    char buff[MAXBUFSIZE];
    fd = fopen ("/proc/stat", "r"); //这里只读取stat文件的第一行及cpu总信息，如需获取每核cpu的使用情况，请分析stat文件的接下来几行。
    fgets (buff, sizeof(buff), fd);
    sscanf (buff, "%s %u %u %u %u", o->name, &o->user, &o->nice,&o->system, &o->idle);
    fclose(fd);
}


float get_io_occupy(){
    char cmd[] ="iostat -d -x";
    char buffer[MAXBUFSIZE];
    char a[20];
    float arr[20];
    FILE* pipe = popen(cmd, "r");
    if (!pipe)  return -1;
    fgets(buffer, sizeof(buffer), pipe);
    fgets(buffer, sizeof(buffer), pipe);
    fgets(buffer, sizeof(buffer), pipe);
    fgets(buffer, sizeof(buffer), pipe);
    sscanf(buffer,"%s %f %f %f %f %f %f %f %f %f %f %f %f %f ",a,&arr[0],&arr[1],&arr[2],&arr[3],&arr[4],&arr[5],&arr[6],&arr[7],&arr[8],&arr[9],&arr[10],&arr[11],&arr[12]);
    //printf("%f\n",arr[12]);
    pclose(pipe);
    return arr[12];
}

void get_disk_occupy(char **reused){
    char currentDirectoryPath[ MAXBUFSIZE ];
    getcwd(currentDirectoryPath, MAXBUFSIZE);
    //printf("当前目录：%s\n",currentDirectoryPath);
    char cmd[50]="df ";
    strcat(cmd,currentDirectoryPath);
    //printf("%s\n",cmd);

    char buffer[MAXBUFSIZE];
    FILE* pipe = popen(cmd, "r");
    char fileSys[20];
    char blocks[20];
    char used[20];
    char free_[20];
    char percent[10];
    char moment[20];

    if (!pipe)  return ;

    if(fgets(buffer, sizeof(buffer), pipe)!=NULL){
        sscanf(buffer,"%s %s %s %s %s %s",fileSys,blocks,used,free_,percent,moment);
    }
    if(fgets(buffer, sizeof(buffer), pipe)!=NULL){
        sscanf(buffer,"%s %s %s %s %s %s",fileSys,blocks,used,free_,percent,moment);
    }
    *reused = (char *)malloc(sizeof(percent));
    memcpy(*reused,&percent, sizeof(percent));
    /*printf("used_path1 = %d \n",&*reused);
    printf("percent mem used: = %s\n",percent);
    printf("reused mem used: = %s\n",*reused);*/
    pclose(pipe);
}

void hjbGetNetWorkInfo(HJB_NETWORK  *hjb_network){
    FILE *file;
    file = popen("sar -n DEV 1 1 | grep e","r");
    char buff1[1024];
    if(NULL == file){
        return;
    }
    fgets(buff1, sizeof(buff1),file);
    fgets(buff1, sizeof(buff1),file);
    //printf("netWordReadData1 = %s \n",buff1);
    sscanf(buff1,"%*s %*s %s %*s %*s %s %s %*s %*s %*s",
            hjb_network->name,hjb_network->rxkb,
            hjb_network->txkb);
    pclose(file);
}

void getCurrentDownloadRates(long int * save_rate)
{
    char intface[] = "eth0:";  //这是网络接口名，根据主机配置
    //char intface[] = "wlan0:";
    FILE * net_dev_file;
    char buffer[1024];
    size_t bytes_read;
    char * match;
    if ( (net_dev_file=fopen("/proc/net/dev", "r")) == NULL )
    {
        printf("open file /proc/net/dev/ error!\n");
        exit(EXIT_FAILURE);
    }

    int i = 0;
    while(i++<20){
        if(fgets(buffer, sizeof(buffer), net_dev_file)!=NULL){
            if(strstr(buffer,intface)!=NULL){
                //printf("%d   %s\n",i,buffer);
                sscanf(buffer,"%s %ld",buffer,save_rate);
                break;
            }
        }
    }
    if(i==20) *save_rate=0.01;
    fclose(net_dev_file); //关闭文件
    return ;
}