#pragma once
#include "SysInforTool.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/vfs.h>
#include <sys/types.h>
#include <sys/sysinfo.h>
#include <sys/utsname.h>
#include <errno.h>
#include <fstream>
#include <iostream>
#include <iomanip>

extern  int errno;
static void get_system_output(char *cmd, char *output, int size)
{
    FILE *fp = NULL;
    fp = popen(cmd, "r");
    if (fp)
    {
        if (fgets(output, size, fp) != NULL)
        {
            if (output[strlen(output) - 1] == '\n')
                output[strlen(output) - 1] = '\0';
        }
        pclose(fp);
    }
}

/*block to kbyte*/
static unsigned long kscale(unsigned long m_block, unsigned long m_kbyte)
{

    return ((unsigned long long) m_block * m_kbyte + 1024 / 2 ) /1024;
}

/*convert size to GB MB KB*/
static void convert_size(float m_size, int *dest)
{
    if((((m_size / 1024.0) / 1024.0)) >= 1.0)
    {
        *dest = (int)((m_size/1024.0)/1024.0);
    }
    else if((m_size / 1024.0) >= 1.0)
    {
        *dest = (int)(m_size/1024);
    }
}


SysInforTool::SysInforTool(ScannerSysInfo tinfo)
{
    m_sysinfo = tinfo;
}

SysInforTool::~SysInforTool()
{

}

/*获取文件系统信息*/
int SysInforTool::get_fileSystem_info(const char *fileSystem_name,struct fileSystem_info *fi)
{
    struct statfs buf;
    float fileSystem_total_size = 0;
    float fileSystem_free_size = 0;

    if(statfs(fileSystem_name,&buf))
    {
        fprintf(stderr,"statfs %s\n",strerror(errno));
        return -1;
    }

    switch(buf.f_type)
    {
    case 0xEF51:
    case 0xEF53:
        sprintf(fi->fileSystem_format,"EXT");
        break;

    case 0x4d44:
        sprintf(fi->fileSystem_format,"FAT");
        break;

    case 0x5346544e:
        sprintf(fi->fileSystem_format,"NIFS");
        break;

    default:
        sprintf(fi->fileSystem_format,"unknown");
        break;
    }

    //bzero(&fi->fileSystem_total_capacity,sizeof(fi->fileSystem_total_capacity));
    //bzero(&fi->fileSystem_free_capacity,sizeof(fi->fileSystem_free_capacity));

    printf("blocks %ld\n",buf.f_blocks);
    printf("bfree %ld\n",buf.f_bfree);
    printf("bsize %ld\n",buf.f_bsize);

    fileSystem_total_size =
                    (float)(kscale(buf.f_blocks, buf.f_bsize));
    fileSystem_free_size =
                    (float)(kscale(buf.f_bfree, buf.f_bsize));

    printf("total %f\n",fileSystem_total_size);
    printf("free %f\n",fileSystem_free_size);

    fi->fileSystem_total_capacity = fileSystem_total_size;
    fi->fileSystem_free_capacity = fileSystem_free_size;
    //convert_size(fileSystem_total_size,(int*)(&fi->fileSystem_total_capacity));
    //convert_size(fileSystem_free_size,(int*)(&fi->fileSystem_free_capacity));

    bzero(fi->fileSystem_permissions,sizeof(fi->fileSystem_permissions));
    sprintf(fi->fileSystem_permissions,"rw");

    return 0;
}

std::string SysInforTool::GetSysInfo()
{
    struct sysinfo memInfo;
    sysinfo(&memInfo);
    m_sysinfo.MemTotal = memInfo.totalram;
    fileSystem_info fileinfo;
    get_fileSystem_info("/",&fileinfo);
    m_sysinfo.DiskTotal = fileinfo.fileSystem_total_capacity;//KB
    m_sysinfo.DiskUsed = fileinfo.fileSystem_free_capacity;//KB

    struct utsname t_uname;
    if(uname(&t_uname)!=0)
       perror("uname doesn't return 0, so there is an error");

   printf("System Name = %s\n", t_uname.sysname);
   printf("Node Name = %s\n", t_uname.nodename);
   printf("Version = %s\n", t_uname.version);
   printf("Release = %s\n", t_uname.release);
   printf("Machine = %s\n", t_uname.machine);
   if(strcmp(t_uname.nodename,"linaro-alip")==0 && strcmp(t_uname.machine,"armv7l")==0)
   {
       m_sysinfo.Systype=SysType::Sys_Linux_Debian;
       m_sysinfo.CPU = SCPU::CPU_3288;
       printf("Machine = %s CPU = %s \n", "Sys_Linux_Debian","CPU_3288");
   }
   else if(strcmp(t_uname.nodename,"linaro-alip")==0 && strcmp(t_uname.machine,"aarch64")==0)
   {
       m_sysinfo.Systype = SysType::Sys_Linux_Debian;
       m_sysinfo.CPU = SCPU::CPU_3399;
       printf("Machine = %s CPU = %s \n", "Sys_Linux_Debian","CPU_3399");
   }
   m_sysinfo.MtType = SMBType::MB_DRV_8825;
   m_sysinfo.Cistype = HGCISType::CIS_DUNNAN_MONO_V0;
   char output[512];
   get_system_output("uname -a",output,sizeof(output));
   std::string ver(output);
   m_sysinfo.KernelVersion = ver;
   printf("system version  = %s \n",ver.c_str());
   json j;
   struct2json(j,m_sysinfo);
   std::ofstream o("/usr/local/huago/sysinfo.json");
   o << std::setw(4) << j << std::endl;
   return j.dump();
}

void SysInforTool::struct2json(json& j,ScannerSysInfo& info)
{
    j["CPU"]=info.CPU;
    j["Systype"]=info.Systype;
    j["Screentype"] = info.Screentype;
    j["MtBoardVersion"] = info.MtBoardVersion;
    j["MtType"] = info.MtType;
    j["FPGAVersion"] = info.FPGAVersion;
    j["Cistype"] = info.Cistype;
    j["MaxRes"] = info.ResSup;
    j["MemTotal"] = info.MemTotal;
    j["DiskTotal"] = info.DiskTotal;
    j["DiskUsed"] = info.DiskUsed;
    j["KernelVersion"] = info.KernelVersion;
    j["Have_EthernPort"] = info.Have_EthernPort;
    j["ServiceVersion"] = info.ServiceVersion;
    j["UsbProtocol"] = info.UsbProtocol;
}